fix: Optimizes OPL using string interpolation (#1041)

## Breaking Changes (New API)
ObjectPropertyList supports the following API:
```cs
list.Add(500000);
list.Add(500001, stringArgument);
list.Add("Some text");
list.Add($"Some text with {argument}");
list.Add(500002, $"{arg1}\t{arg2}");
```

## Notes
1. All API uses that require a formatter like this:
    ```cs
    list.Add(500002, "{0}\t{1}", arg1, arg2);
    ```
    Should be changed to use string interpolation, for example:
    ```cs
    list.Add(500002, $"{arg1}\t{arg2}");
    ```
2. The following paradigm should no longer be used:
    ```cs
    list.Add(1061170, prop.ToString()); // strength requirement ~1_val~
    ```
    The new string interpolation API will avoid having to convert the argument to a string before writing it to the packet. Instead use the following:
    ```cs
    list.Add(1061170, $"{prop}"); // strength requirement ~1_val~
    ```

### Benchmarks
```cs
|                         Method |     Mean |   Error |  StdDev |  Gen 0 | Allocated |
|------------------------------- |---------:|--------:|--------:|-------:|----------:|
|                BenchmarkOldOPL | 241.0 ns | 0.56 ns | 0.47 ns | 0.0105 |      88 B |
| BenchmarkStringInterpolatedOPL | 199.9 ns | 2.44 ns | 2.39 ns |      - |         - |
```

### Changes
- [X] Removes crash in STArray.Return when array is null.
- [X] Fixes NPE in OPL when entity is null. Serial in packet will be 0 when entity is null.
- [X] Fixes NPE in AosAttributes when Parent is null.
- [X] Changes OPL to use string interpolation.
- [X] Introduces `IPropertyList` to allow extending PropertyList for other uses.

Projects/Server/Buffers/RawInterpolatedStringHandler.cs

@@ -78,7 +78,7 @@ public ref struct RawInterpolatedStringHandler
     /// <param name="formattedCount">The number of interpolation expressions in the interpolated string.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)] // becomes a constant when inputs are constant
     internal static int GetDefaultLength(int literalLength, int formattedCount) =>
-        Math.Max(MinimumArrayPoolLength, literalLength + (formattedCount * GuessedLengthPerHole));
+        Math.Max(MinimumArrayPoolLength, literalLength + formattedCount * GuessedLengthPerHole);
 
     /// <summary>Clears the handler, returning any rented array to the pool.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)] // used only on a few hot paths

Projects/Server/Buffers/STArrayPool.cs

@@ -78,7 +78,7 @@ public class STArrayPool<T> : ArrayPool<T>
     {
         if (array is null)
         {
-            throw new ArgumentNullException(nameof(array));
+            return;
         }
 
         var bucketIndex = SelectBucketIndex(array.Length);

Projects/Server/Items/Container.cs

@@ -755,7 +755,7 @@ namespace Server.Items
 
         public virtual void SendContentTo(NetState state) => state.SendContainerContent(state.Mobile, this);
 
-        public override void GetProperties(ObjectPropertyList list)
+        public override void GetProperties(IPropertyList list)
         {
             base.GetProperties(list);
 
@@ -767,21 +767,14 @@ namespace Server.Items
                     {
                         list.Add(
                             1073841, // Contents: ~1_COUNT~/~2_MAXCOUNT~ items, ~3_WEIGHT~ stones
-                            "{0}\t{1}\t{2}",
-                            TotalItems,
-                            MaxItems,
-                            TotalWeight
+                            $"{TotalItems}\t{MaxItems}\t{TotalWeight}"
                         );
                     }
                     else
                     {
                         list.Add(
                             1072241, // Contents: ~1_COUNT~/~2_MAXCOUNT~ items, ~3_WEIGHT~/~4_MAXWEIGHT~ stones
-                            "{0}\t{1}\t{2}\t{3}",
-                            TotalItems,
-                            MaxItems,
-                            TotalWeight,
-                            MaxWeight
+                            $"{TotalItems}\t{MaxItems}\t{TotalWeight}\t{MaxWeight}"
                         );
                     }
 
@@ -790,7 +783,7 @@ namespace Server.Items
                 else
                 {
                     // ~1_COUNT~ items, ~2_WEIGHT~ stones
-                    list.Add(1050044, "{0}\t{1}", TotalItems, TotalWeight);
+                    list.Add(1050044, $"{TotalItems}\t{TotalWeight}");
                 }
             }
         }

Projects/Server/Items/Item.cs

@@ -176,7 +176,7 @@ namespace Server
         Spawner = 0x100
     }
 
-    public class Item : IHued, IComparable<Item>, ISpawnable, IPropertyListObject
+    public class Item : IHued, IComparable<Item>, ISpawnable, IObjectPropertyListEntity
     {
         private static readonly ILogger logger = LogFactory.GetLogger(typeof(Item));
 
@@ -769,7 +769,7 @@ namespace Server
         ///     custom
         ///     properties.
         /// </summary>
-        public virtual void GetProperties(ObjectPropertyList list)
+        public virtual void GetProperties(IPropertyList list)
         {
             AddNameProperties(list);
         }
@@ -1817,7 +1817,7 @@ namespace Server
         ///     Overridable. Adds the name of this item to the given <see cref="ObjectPropertyList" />. This method should be overridden
         ///     if the item requires a complex naming format.
         /// </summary>
-        public virtual void AddNameProperty(ObjectPropertyList list)
+        public virtual void AddNameProperty(IPropertyList list)
         {
             var name = Name;
 
@@ -1829,7 +1829,7 @@ namespace Server
                 }
                 else
                 {
-                    list.Add(1050039, "{0}\t#{1}", m_Amount, LabelNumber); // ~1_NUMBER~ ~2_ITEMNAME~
+                    list.Add(1050039, $"{m_Amount}\t#{LabelNumber}"); // ~1_NUMBER~ ~2_ITEMNAME~
                 }
             }
             else
@@ -1840,7 +1840,7 @@ namespace Server
                 }
                 else
                 {
-                    list.Add(1050039, "{0}\t{1}", m_Amount, Name); // ~1_NUMBER~ ~2_ITEMNAME~
+                    list.Add(1050039, $"{m_Amount}\t{Name}"); // ~1_NUMBER~ ~2_ITEMNAME~
                 }
             }
         }
@@ -1849,7 +1849,7 @@ namespace Server
         ///     Overridable. Adds the loot type of this item to the given <see cref="ObjectPropertyList" />. By default, this will be
         ///     either 'blessed', 'cursed', or 'insured'.
         /// </summary>
-        public virtual void AddLootTypeProperty(ObjectPropertyList list)
+        public virtual void AddLootTypeProperty(IPropertyList list)
         {
             if (m_LootType == LootType.Blessed)
             {
@@ -1868,59 +1868,51 @@ namespace Server
         /// <summary>
         ///     Overridable. Adds any elemental resistances of this item to the given <see cref="ObjectPropertyList" />.
         /// </summary>
-        public virtual void AddResistanceProperties(ObjectPropertyList list)
+        public virtual void AddResistanceProperties(IPropertyList list)
         {
             var v = PhysicalResistance;
 
             if (v != 0)
             {
-                list.Add(1060448, v.ToString()); // physical resist ~1_val~%
+                list.Add(1060448, $"{v}"); // physical resist ~1_val~%
             }
 
             v = FireResistance;
 
             if (v != 0)
             {
-                list.Add(1060447, v.ToString()); // fire resist ~1_val~%
+                list.Add(1060447, $"{v}"); // fire resist ~1_val~%
             }
 
             v = ColdResistance;
 
             if (v != 0)
             {
-                list.Add(1060445, v.ToString()); // cold resist ~1_val~%
+                list.Add(1060445, $"{v}"); // cold resist ~1_val~%
             }
 
             v = PoisonResistance;
 
             if (v != 0)
             {
-                list.Add(1060449, v.ToString()); // poison resist ~1_val~%
+                list.Add(1060449, $"{v}"); // poison resist ~1_val~%
             }
 
             v = EnergyResistance;
 
             if (v != 0)
             {
-                list.Add(1060446, v.ToString()); // energy resist ~1_val~%
+                list.Add(1060446, $"{v}"); // energy resist ~1_val~%
             }
         }
 
         /// <summary>
         ///     Overridable. Displays cliloc 1072788-1072789.
         /// </summary>
-        public virtual void AddWeightProperty(ObjectPropertyList list)
+        public virtual void AddWeightProperty(IPropertyList list)
         {
             var weight = PileWeight + TotalWeight;
-
-            if (weight == 1)
-            {
-                list.Add(1072788, weight.ToString()); // Weight: ~1_WEIGHT~ stone
-            }
-            else
-            {
-                list.Add(1072789, weight.ToString()); // Weight: ~1_WEIGHT~ stones
-            }
+            list.Add(weight == 1 ? 1072788 : 1072789, $"{weight}");
         }
 
         /// <summary>
@@ -1928,7 +1920,7 @@ namespace Server
         ///     <see cref="AddBlessedForProperty" /> (if applicable), and <see cref="AddLootTypeProperty" /> (if
         ///     <see cref="DisplayLootType" />).
         /// </summary>
-        public virtual void AddNameProperties(ObjectPropertyList list)
+        public virtual void AddNameProperties(IPropertyList list)
         {
             AddNameProperty(list);
 
@@ -1969,7 +1961,7 @@ namespace Server
         /// <summary>
         ///     Overridable. Adds the "Quest Item" property to the given <see cref="ObjectPropertyList" />.
         /// </summary>
-        public virtual void AddQuestItemProperty(ObjectPropertyList list)
+        public virtual void AddQuestItemProperty(IPropertyList list)
         {
             list.Add(1072351); // Quest Item
         }
@@ -1977,7 +1969,7 @@ namespace Server
         /// <summary>
         ///     Overridable. Adds the "Locked Down & Secure" property to the given <see cref="ObjectPropertyList" />.
         /// </summary>
-        public virtual void AddSecureProperty(ObjectPropertyList list)
+        public virtual void AddSecureProperty(IPropertyList list)
         {
             list.Add(501644); // locked down & secure
         }
@@ -1985,7 +1977,7 @@ namespace Server
         /// <summary>
         ///     Overridable. Adds the "Locked Down" property to the given <see cref="ObjectPropertyList" />.
         /// </summary>
-        public virtual void AddLockedDownProperty(ObjectPropertyList list)
+        public virtual void AddLockedDownProperty(IPropertyList list)
         {
             list.Add(501643); // locked down
         }
@@ -1993,9 +1985,9 @@ namespace Server
         /// <summary>
         ///     Overridable. Adds the "Blessed for ~1_NAME~" property to the given <see cref="ObjectPropertyList" />.
         /// </summary>
-        public virtual void AddBlessedForProperty(ObjectPropertyList list, Mobile m)
+        public virtual void AddBlessedForProperty(IPropertyList list, Mobile m)
         {
-            list.Add(1062203, "{0}", m.Name); // Blessed for ~1_NAME~
+            list.Add(1062203, m.Name); // Blessed for ~1_NAME~
         }
 
         /// <summary>
@@ -2003,7 +1995,7 @@ namespace Server
         ///     Recursively calls <see cref="Item.GetChildProperties">Item.GetChildProperties</see> or
         ///     <see cref="Mobile.GetChildProperties">Mobile.GetChildProperties</see>.
         /// </summary>
-        public virtual void GetChildProperties(ObjectPropertyList list, Item item)
+        public virtual void GetChildProperties(IPropertyList list, Item item)
         {
             if (m_Parent is Item parentItem)
             {
@@ -2021,7 +2013,7 @@ namespace Server
         ///     . Recursively calls <see cref="Item.GetChildProperties">Item.GetChildNameProperties</see> or
         ///     <see cref="Mobile.GetChildProperties">Mobile.GetChildNameProperties</see>.
         /// </summary>
-        public virtual void GetChildNameProperties(ObjectPropertyList list, Item item)
+        public virtual void GetChildNameProperties(IPropertyList list, Item item)
         {
             if (m_Parent is Item parentItem)
             {
@@ -2377,7 +2369,7 @@ namespace Server
             return bounds;
         }
 
-        public virtual void AppendChildProperties(ObjectPropertyList list)
+        public virtual void AppendChildProperties(IPropertyList list)
         {
             if (m_Parent is Item item)
             {
@@ -2389,7 +2381,7 @@ namespace Server
             }
         }
 
-        public virtual void AppendChildNameProperties(ObjectPropertyList list)
+        public virtual void AppendChildNameProperties(IPropertyList list)
         {
             if (m_Parent is Item item)
             {

Projects/Server/Items/VirtualCheck.cs

@@ -120,7 +120,7 @@ namespace Server.Items
             LabelTo(from, "Offer: {0:#,0} platinum, {1:#,0} gold", Plat, Gold);
         }
 
-        public override void GetProperties(ObjectPropertyList list)
+        public override void GetProperties(IPropertyList list)
         {
             base.GetProperties(list);
 

Projects/Server/Mobiles/Mobile.cs

@@ -403,7 +403,7 @@ namespace Server
     /// <summary>
     ///     Base class representing players, npcs, and creatures.
     /// </summary>
-    public class Mobile : IHued, IComparable<Mobile>, ISpawnable, IPropertyListObject
+    public class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPropertyListEntity
     {
         // Allow four warmode changes in 0.5 seconds, any more will be delay for two seconds
         private const int WarmodeCatchCount = 4;
@@ -2476,7 +2476,7 @@ namespace Server
         public virtual int HuedItemID => m_Female ? 0x2107 : 0x2106;
         public ObjectPropertyList PropertyList => m_PropertyList ??= InitializePropertyList(new ObjectPropertyList(this));
 
-        public virtual void GetProperties(ObjectPropertyList list)
+        public virtual void GetProperties(IPropertyList list)
         {
             AddNameProperties(list);
         }
@@ -3445,57 +3445,51 @@ namespace Server
 
         public virtual string ApplyNameSuffix(string suffix) => suffix;
 
-        public virtual void AddNameProperties(ObjectPropertyList list)
+        public virtual void AddNameProperties(IPropertyList list)
         {
-            var name = Name ?? "";
+            var name = Name ?? " ";
 
             string prefix;
 
             if (ShowFameTitle && (m_Player || m_Body.IsHuman) && m_Fame >= 10000)
             {
-                prefix = m_Female ? "Lady" : "Lord";
+                prefix = m_Female ? "Lady " : "Lord ";
             }
             else
             {
-                prefix = "";
+                prefix = " ";
             }
 
-            var suffix = "";
-
-            if (PropertyTitle && !string.IsNullOrEmpty(Title))
-            {
-                suffix = Title;
-            }
+            var title = PropertyTitle && !string.IsNullOrEmpty(Title) ? Title : "";
 
+            string suffix;
             var guild = m_Guild;
-
             if (guild != null && (m_Player || m_DisplayGuildTitle))
             {
-                suffix = suffix.Length > 0
-                    ? $"{suffix} [{Utility.FixHtml(guild.Abbreviation)}]"
+                suffix = title.Length > 0
+                    ? $"{title} [{Utility.FixHtml(guild.Abbreviation)}]"
                     : $"[{Utility.FixHtml(guild.Abbreviation)}]";
             }
+            else
+            {
+                suffix = " ";
+            }
 
-            suffix = ApplyNameSuffix(suffix);
-
-            list.Add(1050045, "{0} \t{1}\t {2}", prefix, name, suffix); // ~1_PREFIX~~2_NAME~~3_SUFFIX~
+            list.Add(1050045, $"{prefix}\t{name}\t{ApplyNameSuffix(suffix)}"); // ~1_PREFIX~~2_NAME~~3_SUFFIX~
 
             if (guild != null && (m_DisplayGuildTitle || m_Player && guild.Type != GuildType.Regular))
             {
                 var type = guild.Type >= 0 && (int)guild.Type < m_GuildTypes.Length ? m_GuildTypes[(int)guild.Type] : "";
 
-                var title = GuildTitle?.Trim() ?? "";
+                var guildTitle = GuildTitle?.Trim() ?? "";
 
-                if (title.Length > 0)
+                if (guildTitle.Length > 0)
                 {
-                    if (NewGuildDisplay)
-                    {
-                        list.Add("{0}, {1}", Utility.FixHtml(title), Utility.FixHtml(guild.Name));
-                    }
-                    else
-                    {
-                        list.Add("{0}, {1} Guild{2}", Utility.FixHtml(title), Utility.FixHtml(guild.Name), type);
-                    }
+                    list.Add(
+                        NewGuildDisplay
+                            ? $"{Utility.FixHtml(guildTitle)}, {Utility.FixHtml(guild.Name)}"
+                            : $"{Utility.FixHtml(guildTitle)}, {Utility.FixHtml(guild.Name)} Guild{type}"
+                    );
                 }
                 else
                 {
@@ -3504,11 +3498,11 @@ namespace Server
             }
         }
 
-        public virtual void GetChildProperties(ObjectPropertyList list, Item item)
+        public virtual void GetChildProperties(IPropertyList list, Item item)
         {
         }
 
-        public virtual void GetChildNameProperties(ObjectPropertyList list, Item item)
+        public virtual void GetChildNameProperties(IPropertyList list, Item item)
         {
         }
 

Projects/Server/Network/Packets/OutgoingEntityPackets.cs

@@ -41,7 +41,7 @@ public static class OutgoingEntityPackets
         writer.Write(hash);
     }
 
-    public static void SendOPLInfo(this NetState ns, IPropertyListObject obj) =>
+    public static void SendOPLInfo(this NetState ns, IObjectPropertyListEntity obj) =>
         ns.SendOPLInfo(obj.Serial, obj.PropertyList.Hash);
 
     public static void SendOPLInfo(this NetState ns, Serial serial, int hash)

Projects/Server/ObjectPropertyList.cs

@@ -1,184 +0,0 @@
-using System;
-using System.Buffers;
-using System.IO;
-using System.Runtime.CompilerServices;
-using Server.Network;
-
-namespace Server
-{
-    public interface IPropertyListObject : IEntity
-    {
-        ObjectPropertyList PropertyList { get; }
-
-        void GetProperties(ObjectPropertyList list);
-    }
-
-    public sealed class ObjectPropertyList
-    {
-        // Each of these are localized to "~1_NOTHING~" which allows the string argument to be used
-        private static readonly int[] m_StringNumbers =
-        {
-            1042971,
-            1070722
-        };
-
-        private int _hash;
-        private int _strings;
-        private byte[] _buffer;
-        private int _position;
-
-        public ObjectPropertyList(IEntity e)
-        {
-            Entity = e;
-            _buffer = GC.AllocateUninitializedArray<byte>(64);
-
-            var writer = new SpanWriter(_buffer);
-            writer.Write((byte)0xD6); // Packet ID
-            writer.Seek(2, SeekOrigin.Current);
-            writer.Write((ushort)1);
-            writer.Write(e.Serial);
-            writer.Write((ushort)0);
-            _position = writer.Position + 4; // Hash
-        }
-
-        public IEntity Entity { get; }
-
-        public int Hash => 0x40000000 + _hash;
-
-        public int Header { get; set; }
-
-        public string HeaderArgs { get; set; }
-
-        public static bool Enabled { get; set; }
-
-        public byte[] Buffer => _buffer;
-
-        public void Reset()
-        {
-            _position = 15;
-            _hash = 0;
-            _strings = 0;
-            Header = 0;
-            HeaderArgs = null;
-        }
-
-        public void Flush()
-        {
-            Resize(_buffer.Length * 2);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void Resize(int amount)
-        {
-            var newBuffer = GC.AllocateUninitializedArray<byte>(amount);
-            _buffer.AsSpan(0, Math.Min(amount, _buffer.Length)).CopyTo(newBuffer);
-            _buffer = newBuffer;
-        }
-
-        public void Terminate()
-        {
-            int length = _position + 4;
-            if (length != _buffer.Length)
-            {
-                Resize(length);
-            }
-
-            var writer = new SpanWriter(_buffer);
-            writer.Seek(_position, SeekOrigin.Begin);
-            writer.Write(0);
-
-            writer.Seek(11, SeekOrigin.Begin);
-            writer.Write(_hash);
-            writer.WritePacketLength();
-        }
-
-        public void AddHash(int val)
-        {
-            _hash ^= val & 0x3FFFFFF;
-            _hash ^= (val >> 26) & 0x3F;
-        }
-
-        public void Add(int number, string arguments = null)
-        {
-            if (number == 0)
-            {
-                return;
-            }
-
-            arguments ??= "";
-
-            if (Header == 0)
-            {
-                Header = number;
-                HeaderArgs = arguments;
-            }
-
-            AddHash(number);
-            if (arguments.Length > 0)
-            {
-                AddHash(arguments.GetHashCode(StringComparison.Ordinal));
-            }
-
-            int strLength = arguments.Length * 2;
-            int length = _position + 6 + strLength;
-            while (length > _buffer.Length)
-            {
-                Flush();
-            }
-
-            var writer = new SpanWriter(_buffer.AsSpan(_position));
-            writer.Write(number);
-            writer.Write((ushort)strLength);
-            writer.WriteLittleUni(arguments);
-
-            _position += writer.BytesWritten;
-        }
-
-        public void Add(int number, string format, object arg0)
-        {
-            Add(number, string.Format(format, arg0));
-        }
-
-        public void Add(int number, string format, object arg0, object arg1)
-        {
-            Add(number, string.Format(format, arg0, arg1));
-        }
-
-        public void Add(int number, string format, object arg0, object arg1, object arg2)
-        {
-            Add(number, string.Format(format, arg0, arg1, arg2));
-        }
-
-        public void Add(int number, string format, params object[] args)
-        {
-            Add(number, string.Format(format, args));
-        }
-
-        private int GetStringNumber() => m_StringNumbers[_strings++ % m_StringNumbers.Length];
-
-        public void Add(string text)
-        {
-            Add(GetStringNumber(), text);
-        }
-
-        public void Add(string format, string arg0)
-        {
-            Add(GetStringNumber(), string.Format(format, arg0));
-        }
-
-        public void Add(string format, string arg0, string arg1)
-        {
-            Add(GetStringNumber(), string.Format(format, arg0, arg1));
-        }
-
-        public void Add(string format, string arg0, string arg1, string arg2)
-        {
-            Add(GetStringNumber(), string.Format(format, arg0, arg1, arg2));
-        }
-
-        public void Add(string format, params object[] args)
-        {
-            Add(GetStringNumber(), string.Format(format, args));
-        }
-    }
-}

Projects/Server/PropertyList/IObjectPropertyListEntity.cs

@@ -0,0 +1,23 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2022 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: IObjectPropertyListEntity.cs                                    *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+namespace Server;
+
+public interface IObjectPropertyListEntity : IEntity
+{
+    ObjectPropertyList PropertyList { get; }
+
+    void GetProperties(IPropertyList list);
+}

Projects/Server/PropertyList/IPropertyList.cs

@@ -0,0 +1,30 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2022 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: IPropertyList.cs                                                *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System.Runtime.CompilerServices;
+using Server.Text;
+
+namespace Server;
+
+public interface IPropertyList : ISelfInterpolatedStringHandler
+{
+    public void Reset();
+    public void Terminate();
+    public void Add(int number, string argument = null);
+    public void Add(string text);
+
+    // String Interpolation
+    public void Add(int number, [InterpolatedStringHandlerArgument("")] ref InterpolatedStringHandler handler);
+}

Projects/Server/PropertyList/ObjectPropertyList.cs

@@ -0,0 +1,508 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2022 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: ObjectPropertyList.cs                                           *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+#nullable enable
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using Server.Buffers;
+using Server.Network;
+using Server.Text;
+
+namespace Server;
+
+public sealed class ObjectPropertyList : IPropertyList, IDisposable
+{
+    // Each of these are localized to "~1_NOTHING~" which allows the string argument to be used
+    private static readonly int[] _stringNumbers =
+    {
+        1042971,
+        1070722,
+        1114057, // ~1_val~
+        1114778, // ~1_val~
+        1114779 // ~1_val~
+    };
+
+    private int _hash;
+    private int _stringNumbersIndex;
+    private byte[] _buffer;
+    private int _bufferPos;
+
+    // For string interpolation
+    private int _pos;
+    private char[]? _arrayToReturnToPool;
+
+    public ObjectPropertyList(IEntity? e)
+    {
+        Entity = e;
+        _buffer = GC.AllocateUninitializedArray<byte>(64);
+
+        var writer = new SpanWriter(_buffer);
+        writer.Write((byte)0xD6); // Packet ID
+        writer.Seek(2, SeekOrigin.Current);
+        writer.Write((ushort)1);
+        writer.Write(e?.Serial ?? Serial.Zero);
+        writer.Write((ushort)0);
+        _bufferPos = writer.Position + 4; // Hash
+    }
+
+    public IEntity? Entity { get; }
+
+    public int Hash => 0x40000000 + _hash;
+
+    public int Header { get; set; }
+
+    public string HeaderArgs { get; set; }
+
+    public static bool Enabled { get; set; }
+
+    public byte[] Buffer => _buffer;
+
+    public void Reset()
+    {
+        _bufferPos = 15;
+        _hash = 0;
+        _stringNumbersIndex = 0;
+        Header = 0;
+        HeaderArgs = null;
+        STArrayPool<char>.Shared.Return(_arrayToReturnToPool);
+        _pos = 0;
+    }
+
+    private void Flush()
+    {
+        Resize(_buffer.Length * 2);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void Resize(int amount)
+    {
+        var newBuffer = GC.AllocateUninitializedArray<byte>(amount);
+        _buffer.AsSpan(0, Math.Min(amount, _buffer.Length)).CopyTo(newBuffer);
+        _buffer = newBuffer;
+    }
+
+    public void Terminate()
+    {
+        int length = _bufferPos + 4;
+        if (length != _buffer.Length)
+        {
+            Resize(length);
+        }
+
+        var writer = new SpanWriter(_buffer);
+        writer.Seek(_bufferPos, SeekOrigin.Begin);
+        writer.Write(0);
+
+        writer.Seek(11, SeekOrigin.Begin);
+        writer.Write(_hash);
+        writer.WritePacketLength();
+    }
+
+    private void AddHash(int val)
+    {
+        _hash ^= val & 0x3FFFFFF;
+        _hash ^= (val >> 26) & 0x3F;
+    }
+
+    public void Add(int number, string? arguments = null)
+    {
+        if (number == 0)
+        {
+            return;
+        }
+
+        arguments ??= "";
+
+        if (Header == 0)
+        {
+            Header = number;
+            HeaderArgs = arguments;
+        }
+
+        AddHash(number);
+        if (arguments.Length > 0)
+        {
+            AddHash(arguments.GetHashCode(StringComparison.Ordinal));
+        }
+
+        int strLength = arguments.Length * 2;
+        int length = _bufferPos + 6 + strLength;
+        while (length > _buffer.Length)
+        {
+            Flush();
+        }
+
+        var writer = new SpanWriter(_buffer.AsSpan(_bufferPos));
+        writer.Write(number);
+        writer.Write((ushort)strLength);
+        writer.WriteLittleUni(arguments);
+
+        _bufferPos += writer.BytesWritten;
+        _pos = 0;
+    }
+
+    private int GetStringNumber() => _stringNumbers[_stringNumbersIndex++ % _stringNumbers.Length];
+
+    public void Add(string argument) => Add(GetStringNumber(), argument);
+
+    public void Add(
+        [InterpolatedStringHandlerArgument("")]
+        ref IPropertyList.InterpolatedStringHandler handler
+    ) => Add(GetStringNumber(), ref handler);
+
+    // String Interpolation
+    public void Add(
+        int number,
+        [InterpolatedStringHandlerArgument("")]
+        ref IPropertyList.InterpolatedStringHandler handler)
+    {
+        if (number == 0)
+        {
+            return;
+        }
+
+        var chars = _arrayToReturnToPool.AsSpan(0, _pos);
+
+        if (Header == 0)
+        {
+            Header = number;
+            HeaderArgs = chars.ToString();
+            HeaderArgs.GetHashCode(StringComparison.Ordinal);
+        }
+
+        AddHash(number);
+        if (chars.Length > 0)
+        {
+            AddHash(string.GetHashCode(chars, StringComparison.Ordinal));
+        }
+
+        int strLength = chars.Length * 2;
+        int length = _bufferPos + 6 + strLength;
+        while (length > _buffer.Length)
+        {
+            Flush();
+        }
+
+        var writer = new SpanWriter(_buffer.AsSpan(_bufferPos));
+        writer.Write(number);
+        writer.Write((ushort)strLength);
+        writer.Write(chars, TextEncoding.UnicodeLE);
+
+        _bufferPos += writer.BytesWritten;
+    }
+
+    public void InitializeInterpolation(int literalLength, int formattedCount)
+    {
+        _arrayToReturnToPool ??= STArrayPool<char>.Shared.Rent(GetDefaultLength(literalLength, formattedCount));
+        _pos = 0;
+    }
+
+    // Copied from RawInterpolatedStringHandler
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int GetDefaultLength(int literalLength, int formattedCount) =>
+        Math.Max(256, literalLength + formattedCount * 11);
+
+    public void AppendLiteral(string value)
+    {
+        if (value.Length == 1)
+        {
+            Span<char> chars = _arrayToReturnToPool.AsSpan();
+            int pos = _pos;
+            if ((uint)pos < (uint)chars.Length)
+            {
+                chars[pos] = value[0];
+                _pos = pos + 1;
+            }
+            else
+            {
+                GrowThenCopyString(value);
+            }
+            return;
+        }
+
+        AppendStringDirect(value);
+    }
+
+    private void AppendStringDirect(string value)
+    {
+        if (value.TryCopyTo(_arrayToReturnToPool.AsSpan(_pos..)))
+        {
+            _pos += value.Length;
+        }
+        else
+        {
+            GrowThenCopyString(value);
+        }
+    }
+
+    public void AppendFormatted<T>(T value)
+    {
+
+        string? s;
+        if (value is IFormattable)
+        {
+            if (value is ISpanFormattable)
+            {
+                int charsWritten;
+                while (!((ISpanFormattable)value).TryFormat(_arrayToReturnToPool.AsSpan(_pos..), out charsWritten, default, null))
+                {
+                    Grow();
+                }
+
+                _pos += charsWritten;
+                return;
+            }
+
+            s = ((IFormattable)value).ToString(format: null, null);
+        }
+        else
+        {
+            s = value?.ToString();
+        }
+
+        if (s is not null)
+        {
+            AppendStringDirect(s);
+        }
+    }
+
+    public void AppendFormatted<T>(T value, string? format)
+    {
+        string? s;
+        if (value is IFormattable)
+        {
+            if (value is ISpanFormattable)
+            {
+                int charsWritten;
+                while (!((ISpanFormattable)value).TryFormat(_arrayToReturnToPool.AsSpan(_pos..), out charsWritten, format, null))
+                {
+                    Grow();
+                }
+
+                _pos += charsWritten;
+                return;
+            }
+
+            s = ((IFormattable)value).ToString(format, null);
+        }
+        else
+        {
+            s = value?.ToString();
+        }
+
+        if (s is not null)
+        {
+            AppendStringDirect(s);
+        }
+    }
+
+    public void AppendFormatted<T>(T value, int alignment)
+    {
+        int startingPos = _pos;
+        AppendFormatted(value);
+        if (alignment != 0)
+        {
+            AppendOrInsertAlignmentIfNeeded(startingPos, alignment);
+        }
+    }
+
+    public void AppendFormatted<T>(T value, int alignment, string? format)
+    {
+        int startingPos = _pos;
+        AppendFormatted(value, format);
+        if (alignment != 0)
+        {
+            AppendOrInsertAlignmentIfNeeded(startingPos, alignment);
+        }
+    }
+
+    public void AppendFormatted(ReadOnlySpan<char> value)
+    {
+        if (value.TryCopyTo(_arrayToReturnToPool.AsSpan(_pos..)))
+        {
+            _pos += value.Length;
+        }
+        else
+        {
+            GrowThenCopySpan(value);
+        }
+    }
+
+    public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
+    {
+        bool leftAlign = false;
+        if (alignment < 0)
+        {
+            leftAlign = true;
+            alignment = -alignment;
+        }
+
+        int paddingRequired = alignment - value.Length;
+        if (paddingRequired <= 0)
+        {
+            AppendFormatted(value);
+            return;
+        }
+
+        EnsureCapacityForAdditionalChars(value.Length + paddingRequired);
+        var chars = _arrayToReturnToPool.AsSpan();
+        if (leftAlign)
+        {
+            value.CopyTo(chars[_pos..]);
+            _pos += value.Length;
+            chars.Slice(_pos, paddingRequired).Fill(' ');
+            _pos += paddingRequired;
+        }
+        else
+        {
+            chars.Slice(_pos, paddingRequired).Fill(' ');
+            _pos += paddingRequired;
+            value.CopyTo(chars[_pos..]);
+            _pos += value.Length;
+        }
+    }
+
+    public void AppendFormatted(string? value)
+    {
+        if (value?.TryCopyTo(_arrayToReturnToPool.AsSpan(_pos..)) == true)
+        {
+            _pos += value.Length;
+        }
+        else
+        {
+            AppendFormattedSlow(value);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void AppendFormattedSlow(string? value)
+    {
+        if (value is not null)
+        {
+            EnsureCapacityForAdditionalChars(value.Length);
+            value.CopyTo(_arrayToReturnToPool.AsSpan(_pos..));
+            _pos += value.Length;
+        }
+    }
+
+    public void AppendFormatted(string? value, int alignment = 0, string? format = null) =>
+        AppendFormatted<string?>(value, alignment, format);
+
+    public void AppendFormatted(object? value, int alignment = 0, string? format = null) =>
+        AppendFormatted<object?>(value, alignment, format);
+
+    private void AppendOrInsertAlignmentIfNeeded(int startingPos, int alignment)
+    {
+        Debug.Assert(startingPos >= 0 && startingPos <= _pos);
+        Debug.Assert(alignment != 0);
+
+        int charsWritten = _pos - startingPos;
+
+        bool leftAlign = false;
+        if (alignment < 0)
+        {
+            leftAlign = true;
+            alignment = -alignment;
+        }
+
+        int paddingNeeded = alignment - charsWritten;
+        if (paddingNeeded > 0)
+        {
+            EnsureCapacityForAdditionalChars(paddingNeeded);
+
+            var chars = _arrayToReturnToPool.AsSpan();
+            if (leftAlign)
+            {
+                chars.Slice(_pos, paddingNeeded).Fill(' ');
+            }
+            else
+            {
+                chars.Slice(startingPos, charsWritten).CopyTo(chars[(startingPos + paddingNeeded)..]);
+                chars.Slice(startingPos, paddingNeeded).Fill(' ');
+            }
+
+            _pos += paddingNeeded;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void EnsureCapacityForAdditionalChars(int additionalChars)
+    {
+        if (_arrayToReturnToPool.Length - _pos < additionalChars)
+        {
+            Grow(additionalChars);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void GrowThenCopyString(string value)
+    {
+        Grow(value.Length);
+        value.CopyTo(_arrayToReturnToPool.AsSpan(_pos..));
+        _pos += value.Length;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void GrowThenCopySpan(ReadOnlySpan<char> value)
+    {
+        Grow(value.Length);
+        value.CopyTo(_arrayToReturnToPool.AsSpan(_pos..));
+        _pos += value.Length;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void Grow(int additionalChars)
+    {
+        Debug.Assert(additionalChars > _arrayToReturnToPool.Length - _pos);
+        GrowCore((uint)_pos + (uint)additionalChars);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void Grow()
+    {
+        GrowCore((uint)_arrayToReturnToPool.Length + 1);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void GrowCore(uint requiredMinCapacity)
+    {
+        uint newCapacity = Math.Max(requiredMinCapacity, Math.Min((uint)_arrayToReturnToPool.Length * 2, 0x3FFFFFDF));
+        int arraySize = (int)Math.Clamp(newCapacity, 256, int.MaxValue);
+
+        char[] newArray = STArrayPool<char>.Shared.Rent(arraySize);
+        _arrayToReturnToPool.AsSpan(.._pos).CopyTo(newArray);
+
+        char[] toReturn = _arrayToReturnToPool;
+        _arrayToReturnToPool = newArray;
+
+        STArrayPool<char>.Shared.Return(toReturn);
+    }
+
+    public void Dispose()
+    {
+        STArrayPool<char>.Shared.Return(_arrayToReturnToPool);
+        _arrayToReturnToPool = null;
+    }
+
+    ~ObjectPropertyList()
+    {
+        STArrayPool<char>.Shared.Return(_arrayToReturnToPool);
+        _arrayToReturnToPool = null;
+    }
+}

Projects/Server/Text/ISelfInterpolatedStringHandler.cs

@@ -0,0 +1,71 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2022 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: ISelfInterpolatedStringHandler.cs                               *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Server.Text;
+
+public interface ISelfInterpolatedStringHandler
+{
+    public void Add([InterpolatedStringHandlerArgument("")] ref InterpolatedStringHandler handler);
+    public void InitializeInterpolation(int literalLength, int formattedCount);
+    public void AppendLiteral(string value);
+    public void AppendFormatted<T>(T value);
+    public void AppendFormatted<T>(T value, string? format);
+    public void AppendFormatted<T>(T value, int alignment);
+    public void AppendFormatted<T>(T value, int alignment, string? format);
+    public void AppendFormatted(ReadOnlySpan<char> value);
+    public void AppendFormatted(ReadOnlySpan<char> value, int alignment, string? format = null);
+    public void AppendFormatted(object? value, int alignment = 0, string? format = null);
+    public void AppendFormatted(string? value);
+    public void AppendFormatted(string? value, int alignment, string? format = null);
+
+    [InterpolatedStringHandler]
+    public ref struct InterpolatedStringHandler
+    {
+        private ISelfInterpolatedStringHandler _parent;
+
+        public InterpolatedStringHandler(int literalLength, int formattedCount, ISelfInterpolatedStringHandler parent)
+        {
+            _parent = parent;
+            _parent.InitializeInterpolation(literalLength, formattedCount);
+        }
+
+        public void AppendLiteral(string value) => _parent.AppendLiteral(value);
+
+        public void AppendFormatted<T>(T value) => _parent.AppendFormatted(value);
+
+        public void AppendFormatted<T>(T value, string? format) => _parent.AppendFormatted(value, format);
+
+        public void AppendFormatted<T>(T value, int alignment) => _parent.AppendFormatted(value, alignment);
+
+        public void AppendFormatted<T>(T value, int alignment, string? format) =>
+            _parent.AppendFormatted(value, alignment, format);
+
+        public void AppendFormatted(ReadOnlySpan<char> value) => _parent.AppendFormatted(value);
+
+        public void AppendFormatted(ReadOnlySpan<char> value, int alignment, string? format = null) =>
+            _parent.AppendFormatted(value, alignment, format);
+
+        public void AppendFormatted(object? value, int alignment = 0, string? format = null) =>
+            _parent.AppendFormatted(value, alignment, format);
+
+        public void AppendFormatted(string? value) => _parent.AppendFormatted(value);
+
+        public void AppendFormatted(string? value, int alignment, string? format = null) =>
+            _parent.AppendFormatted(value, alignment, format);
+    }
+}

Projects/Server/Text/StringHelpers.cs

@@ -285,4 +285,22 @@ public static class StringHelpers
             4 => MemoryMarshal.Cast<byte, uint>(buffer).IndexOf((uint)0) * 4,
             _ => buffer.IndexOf((byte)0)
         };
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReplaceAny(this Span<char> chars, ReadOnlySpan<char> invalidChars, ReadOnlySpan<char> replacementChars)
+    {
+        while (true)
+        {
+            var indexOf = chars.IndexOfAny(invalidChars);
+            if (indexOf == -1)
+            {
+                break;
+            }
+
+            var chr = chars[indexOf];
+
+            chars[indexOf] = replacementChars[invalidChars.IndexOf(chr)];
+            chars = chars[(indexOf + 1)..];
+        }
+    }
 }

Projects/Server/Utilities/Utility.cs

@@ -560,7 +560,7 @@ namespace Server
                 return str;
             }
 
-            using var sb = new ValueStringBuilder(str, stackalloc char[Math.Min(40960, str.Length)]);
+            using var sb = new ValueStringBuilder(str, stackalloc char[Math.Min(128, str.Length)]);
             ReadOnlySpan<char> invalid = stackalloc []{ '<', '>', '#' };
             ReadOnlySpan<char> replacement = stackalloc []{ '(', ')', '-' };
             sb.ReplaceAny(invalid, replacement, 0, sb.Length);
@@ -568,6 +568,19 @@ namespace Server
             return sb.ToString();
         }
 
+        public static void FixHtml(Span<char> chars)
+        {
+            if (chars.Length == 0)
+            {
+                return;
+            }
+
+            ReadOnlySpan<char> invalid = stackalloc []{ '<', '>', '#' };
+            ReadOnlySpan<char> replacement = stackalloc []{ '(', ')', '-' };
+
+            chars.ReplaceAny(invalid, replacement);
+        }
+
         public static int InsensitiveCompare(string first, string second) => first.InsensitiveCompare(second);
 
         public static bool InsensitiveStartsWith(string first, string second) => first.InsensitiveStartsWith(second);