Restore "Merge pull request #925 from maddie480/fancy-unicode-characters"

This reverts commit e47f67f.

Author: maddie480

Celeste.Mod.mm/Mod/Everest/Emoji.cs

@@ -1,8 +1,7 @@
-using Monocle;
-using System.Collections;
+using Celeste.Mod.Helpers;
+using Monocle;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Linq;
 using System.Text;
 using System.Xml;
 
@@ -16,16 +15,20 @@ public static class Emoji {
         /// A list of all registered emoji names, in order of their IDs.
         /// </summary>
         public static ReadOnlyCollection<string> Registered => new ReadOnlyCollection<string>(_Registered);
+
         public static char Last => (char) ('\uE000' + _Registered.Count - 1);
 
         private static List<string> _Registered = new List<string>();
         private static Dictionary<string, int> _IDs = new Dictionary<string, int>();
         private static List<bool> _IsMonochrome = new List<bool>();
         private static List<PixelFontCharacter> _Chars = new List<PixelFontCharacter>();
 
+        private static readonly CachedApply cachedApplies = new CachedApply();
+
         private static bool Initialized = false;
         private static Queue<KeyValuePair<string, MTexture>> Queue = new Queue<KeyValuePair<string, MTexture>>();
         private static XmlElement _FakeXML;
+
         public static XmlElement FakeXML {
             get {
                 if (_FakeXML != null)
@@ -129,6 +132,7 @@ public static void Register(string name, MTexture emoji, float scale) {
             }
 
             _Chars.Add(new PixelFontCharacter(Start + id, emoji, xml));
+            cachedApplies.Clear();
         }
 
         /// <summary>
@@ -174,68 +178,76 @@ public static bool TryGet(string name, out char c) {
         public static bool IsMonochrome(char c)
             => _IsMonochrome[c - Start];
 
-        /// <summary>
-        /// Transforms all instances of :emojiname: to \uSTART+ID
-        /// </summary>
-        /// <param name="text"></param>
-        /// <returns></returns>
-        public static string Apply(string text) {
-            if (text == null)
-                return text;
-            // TODO: This trashes the GC and doesn't allow escaping!
-            lock (_IDs) {
-                StringBuilder resultBuilder = new StringBuilder();
-                int appendStartIndex = 0;
-                int head = -1, tail = 0;
-                // suppose text is "aaaa:1111:2222:bbbb", and only ":2222:" is emoji name
-                // H = head, T = tail, S = appendStartIndex
-                while (tail < text.Length) {
-                    if (text[tail] == ':') {
-                        if (head >= 0 && text[head] == ':') {
-                            /*
-                                    aaaa:1111:2222:bbbb
-                                (2) ^S  ^H   ^T   ^
-                                (4) ^S       ^H   ^T
-                                now head and tail are pointing to colons so we need to check if the text inside colons is an emoji name
-                            */
-                            string name = text.Substring(head + 1, (tail - 1) - (head + 1) + 1);
-                            if (_IDs.TryGetValue(name, out int value)) {
-                                // if it is, we need to first append the text before emoji
-                                resultBuilder.Append(text, appendStartIndex, (head - 1) - appendStartIndex + 1);
-                                // then append the emoji itself
-                                resultBuilder.Append((char) (Start + value));
-                                // the emoji name has been replaced, we need to advance tail pointer once
-                                // because the colon is used and can't belong to next emoji
-                                tail++;
-                                appendStartIndex = tail;
+        private class CachedApply : CacheHelper<string, string> {
+            public CachedApply() : base(name: "Emoji.Apply", maxSize: 1000) { }
+
+            protected override string Compute(string text) {
+                if (text == null)
+                    return text;
+
+                // TODO: This trashes the GC and doesn't allow escaping!
+                lock (_IDs) {
+                    StringBuilder resultBuilder = new StringBuilder();
+                    int appendStartIndex = 0;
+                    int head = -1, tail = 0;
+                    // suppose text is "aaaa:1111:2222:bbbb", and only ":2222:" is emoji name
+                    // H = head, T = tail, S = appendStartIndex
+                    while (tail < text.Length) {
+                        if (text[tail] == ':') {
+                            if (head >= 0 && text[head] == ':') {
                                 /*
                                         aaaa:1111:2222:bbbb
-                                    (5)          ^H   S^T
+                                    (2) ^S  ^H   ^T   ^
+                                    (4) ^S       ^H   ^T
+                                    now head and tail are pointing to colons so we need to check if the text inside colons is an emoji name
                                 */
+                                string name = text.Substring(head + 1, (tail - 1) - (head + 1) + 1);
+                                if (_IDs.TryGetValue(name, out int value)) {
+                                    // if it is, we need to first append the text before emoji
+                                    resultBuilder.Append(text, appendStartIndex, (head - 1) - appendStartIndex + 1);
+                                    // then append the emoji itself
+                                    resultBuilder.Append((char) (Start + value));
+                                    // the emoji name has been replaced, we need to advance tail pointer once
+                                    // because the colon is used and can't belong to next emoji
+                                    tail++;
+                                    appendStartIndex = tail;
+                                    /*
+                                            aaaa:1111:2222:bbbb
+                                        (5)          ^H   S^T
+                                    */
+                                }
                             }
+                            head = tail;
+                            /*
+                                    aaaa:1111:2222:bbbb
+                                (1) ^S H^T   ^
+                                (3) ^S      H^T
+                                when tail is pointing to a colon, we need to let head also points to it
+                                so when tail moves to next colon, text[head..tail] can be an emoji name and we can check then replace it
+                            */
                         }
-                        head = tail;
-                        /*
-                                aaaa:1111:2222:bbbb
-                            (1) ^S H^T   ^
-                            (3) ^S      H^T
-                            when tail is pointing to a colon, we need to let head also points to it
-                            so when tail moves to next colon, text[head..tail] can be an emoji name and we can check then replace it
-                        */
+                        tail++;
                     }
-                    tail++;
-                }
-                /*
-                        aaaa:1111:2222:bbbb
-                    (6)               H^S  ^T
-                    there are still text left since last append, so we need to append them
-                */
-                if (appendStartIndex < text.Length) {
-                    resultBuilder.Append(text, appendStartIndex, (text.Length - 1) - appendStartIndex + 1);
+                    /*
+                            aaaa:1111:2222:bbbb
+                        (6)               H^S  ^T
+                        there are still text left since last append, so we need to append them
+                    */
+                    if (appendStartIndex < text.Length) {
+                        resultBuilder.Append(text, appendStartIndex, (text.Length - 1) - appendStartIndex + 1);
+                    }
+                    return resultBuilder.ToString();
                 }
-                return resultBuilder.ToString();
             }
         }
 
+        /// <summary>
+        /// Transforms all instances of :emojiname: to \uSTART+ID
+        /// </summary>
+        /// <param name="text"></param>
+        /// <returns></returns>
+        public static string Apply(string text) {
+            return cachedApplies.GetCached(text);
+        }
     }
 }

Celeste.Mod.mm/Mod/Helpers/CacheHelper.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+
+namespace Celeste.Mod.Helpers {
+    /**
+     * A helper class that wraps a <code>compute</code> function, in order to keep the
+     * latest computed values in memory (holding up to <code>maxSize</code> values),
+     * to help with performance or with repeated memory allocations.
+     */
+    public abstract class CacheHelper<Key, Value> {
+        private readonly struct ValueNode {
+            public LinkedListNode<Key> Node { get; init; }
+            public Value Value { get; init; }
+        }
+
+        private readonly string name;
+        private readonly int maxSize;
+        private readonly Dictionary<Key, ValueNode> cache = new Dictionary<Key, ValueNode>();
+        private readonly LinkedList<Key> cacheOldestToNewest = new LinkedList<Key>();
+
+        public CacheHelper(string name, int maxSize) {
+            this.name = name;
+            this.maxSize = maxSize;
+        }
+
+        public Value GetCached(Key key) {
+            lock (cache) {
+                if (cache.TryGetValue(key, out ValueNode valueNode)) {
+                    cacheOldestToNewest.Remove(valueNode.Node);
+                    cacheOldestToNewest.AddLast(valueNode.Node);
+                    return valueNode.Value;
+                }
+
+                Value value = Compute(key);
+                while (cache.Count >= maxSize) {
+                    Key keyToEvict = cacheOldestToNewest.First.Value;
+                    cache.Remove(keyToEvict);
+                    cacheOldestToNewest.RemoveFirst();
+                }
+
+                LinkedListNode<Key> node = cacheOldestToNewest.AddLast(key);
+                cache.Add(key, new ValueNode { Node = node, Value = value });
+                Logger.Verbose("CacheHelper", $"[{name}] Cached value for \"{key}\" => \"{value}\", cache size: {cache.Count}");
+                return value;
+            }
+        }
+
+        protected abstract Value Compute(Key key);
+
+        public void Clear() {
+            lock (cache) {
+                cache.Clear();
+                cacheOldestToNewest.Clear();
+            }
+        }
+    }
+}

Celeste.Mod.mm/Mod/Helpers/UnicodeStringHelper.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using YamlDotNet.Core.Tokens;
+
+namespace Celeste.Mod.Helpers {
+    public static class UnicodeStringHelper {
+        // helper class because manipulating generic types in IL is annoying
+        public class ListInt {
+            public required int[] Elements;
+            public int Count => Elements.Length;
+            public int this[int index] => Elements[index];
+        }
+
+        private class Cacher : CacheHelper<string, ListInt> {
+            public Cacher() : base(name: "UnicodeStringHelper.ToCodePointList", maxSize: 1000) { }
+
+            protected override ListInt Compute(string text) {
+                return new ListInt {
+                    Elements = text.EnumerateRunes().Select(r => r.Value).ToArray()
+                };
+            }
+        }
+
+        private static readonly Cacher cacher = new Cacher();
+
+        public static ListInt ToCodePointList(string text) {
+            return cacher.GetCached(text);
+        }
+    }
+}

Celeste.Mod.mm/Patches/FancyText.cs

@@ -3,11 +3,13 @@
 using Celeste.Mod;
 using Microsoft.Xna.Framework;
 using Monocle;
+using MonoMod;
 
 namespace Celeste {
     // The FancyText ctor is private.
     class patch_FancyText {
 
+        [PatchTextIteration]
         private extern void orig_AddWord(string word);
         private void AddWord(string word) {
             word = Emoji.Apply(word);