ported from perforce

RobotAndDonkey.Game/Utils/SeedString.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RobotAndDonkey.Game.Utils;
+
+public static class SeedString
+{
+    /// <summary>
+    ///     Encode an int seed to a short, human-friendly string.
+    /// </summary>
+    /// <param name="seed">Any 32-bit signed integer.</param>
+    /// <param name="includeChecksum">Append 1 char to detect typos.</param>
+    /// <param name="group">Insert '-' every 4 chars for readability.</param>
+    public static string ToString(int seed, bool includeChecksum = true, bool group = false)
+    {
+        var u = unchecked((uint)seed);
+
+        // Convert to base-32 (most-significant digit first)
+        if (u == 0)
+            return includeChecksum ? "0" + CheckChar(0) : "0";
+
+        var digits = new List<char>(8);
+        while (u > 0)
+        {
+            var v = (int)(u & 31);
+            digits.Add(Alphabet[v]);
+            u >>= 5;
+        }
+
+        digits.Reverse();
+
+        var sb = new StringBuilder(digits.Count + (includeChecksum ? 1 : 0) + (group ? digits.Count / 4 : 0));
+        for (var i = 0; i < digits.Count; i++)
+        {
+            if (group && i > 0 && i % 4 == 0)
+                sb.Append('-');
+            sb.Append(digits[i]);
+        }
+
+        if (includeChecksum)
+            sb.Append(CheckChar(unchecked((uint)seed)));
+
+        return sb.ToString();
+    }
+
+    /// <summary>
+    ///     Try to parse a seed string back to the original int.
+    /// </summary>
+    /// <param name="code">Case-insensitive; hyphens/spaces/underscores ignored. O=0, I/L=1 accepted.</param>
+    /// <param name="seed">Decoded seed.</param>
+    /// <param name="requireChecksum">If true, only accept strings with a valid trailing checksum.</param>
+    public static bool TryParse(string code, out int seed, bool requireChecksum = false)
+    {
+        seed = 0;
+        if (string.IsNullOrWhiteSpace(code))
+            return false;
+
+        var t = Normalize(code);
+        if (t.Length == 0)
+            return false;
+
+        // If checksum is required (or present), prefer validating it:
+        if (t.Length >= 2)
+        {
+            if (TryParsePayload(t.AsSpan(0, t.Length - 1), out var u) && TryMap(t[^1], out var chk) && chk == Check5(u))
+            {
+                seed = unchecked((int)u);
+                return true;
+            }
+
+            if (requireChecksum)
+                return false;
+        }
+
+        // Fallback: treat entire string as payload without checksum.
+        if (TryParsePayload(t.AsSpan(), out var uv))
+        {
+            seed = unchecked((int)uv);
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Parse or throw (optionally requiring checksum).
+    /// </summary>
+    public static int Parse(string code, bool requireChecksum = false)
+    {
+        return TryParse(code, out var seed, requireChecksum) ? seed : throw new FormatException("Invalid seed string.");
+    }
+
+    // ---------- publics ----------
+
+    private static Dictionary<char, int> BuildMap()
+    {
+        var d = new Dictionary<char, int>(64);
+        for (var i = 0; i < Alphabet.Length; i++)
+            d[Alphabet[i]] = i;
+
+        // Forgiving mappings
+        d['O'] = d['0']; // O -> 0
+        d['I'] = d['1']; // I -> 1
+        d['L'] = d['1']; // L -> 1
+        return d;
+    }
+
+    private static string Normalize(string s)
+    {
+        var sb = new StringBuilder(s.Length);
+        foreach (var ch in s)
+        {
+            if (ch == '-' || ch == '_' || char.IsWhiteSpace(ch))
+                continue;
+            sb.Append(char.ToUpperInvariant(ch));
+        }
+
+        return sb.ToString();
+    }
+
+    private static bool TryParsePayload(ReadOnlySpan<char> span, out uint u)
+    {
+        u = 0;
+        if (span.Length == 0)
+            return false;
+        if (span.Length > 7)
+            return false; // 7 base32 digits cover full 32-bit range (5 bits per digit)
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            if (!TryMap(span[i], out var v))
+                return false;
+            u = (u << 5) | (uint)v;
+        }
+
+        return true;
+    }
+
+    private static bool TryMap(char c, out int v)
+    {
+        return CharToVal.TryGetValue(char.ToUpperInvariant(c), out v);
+    }
+
+    // 5-bit checksum: multiplicative hash then take top 5 bits.
+    private static int Check5(uint u)
+    {
+        return (int)((u * 0x9E3779B1u) >> 27);
+    }
+
+    private static char CheckChar(uint u)
+    {
+        return Alphabet[Check5(u)];
+    }
+
+    // Crockford Base32 (no I, L, O, U)
+    private const string Alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    private static readonly Dictionary<char, int> CharToVal = BuildMap();
+}