Fixes RNG (#181)

Projects/Server/Random/BaseRandomSource.cs

@@ -0,0 +1,173 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright (C) 2019-2020 - ModernUO Development Team                   *
+ * Email: hi@modernuo.com                                                *
+ * File: BaseRandomSource.cs - Created: 2020/07/25 - Updated: 2020/07/25 *
+ *                                                                       *
+ * 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.                                   *
+ *                                                                       *
+ * This program is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ * GNU General Public License for more details.                          *
+ *                                                                       *
+ * 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.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Server.Random
+{
+  public abstract class BaseRandomSource : IRandomSource
+  {
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Log2(uint v)
+    {
+      int exp = BitOperations.Log2(v);
+      return v == 1 << exp ? exp : exp + 1;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Log2(ulong v)
+    {
+      int exp = BitOperations.Log2(v);
+      return v == 1UL << exp ? exp : exp + 1;
+    }
+
+    const double INCR_DOUBLE = 1.0 / (1UL << 53);
+    const float INCR_FLOAT = 1f / (1U << 24);
+
+    public abstract ulong NextULong();
+    public abstract void NextBytes(Span<byte> buffer);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int Next()
+    {
+      ulong rtn;
+      do rtn = NextULong() >> 33;
+      while(rtn == 0x7fff_ffffUL);
+
+      return (int)rtn;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int Next(int count)
+    {
+      if (count == 0) throw new ArgumentOutOfRangeException(nameof(count), count, "count must not be 0");
+      if (count == 1 || count == -1) return 0;
+
+      bool negative = count < 0;
+
+      int max = negative ? -count : count;
+
+      int bits = Log2((uint)max);
+
+      int x;
+      do x = (int)(NextULong() >> (64 - bits));
+      while (x >= max);
+
+      return negative ? -x : x;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int Next(int minValue, int count) => minValue + Next(count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Next(uint count)
+    {
+      if (count == 0) throw new ArgumentOutOfRangeException(nameof(count), count, "count must not be 0");
+      if (count == 1) return 0;
+
+      int bits = Log2(count);
+
+      uint x;
+      do x = (uint)(NextULong() >> (64 - bits));
+      while (x >= count);
+
+      return x;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Next(uint minValue, uint count) => minValue + Next(count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long Next(long count)
+    {
+      if (count == 0) throw new ArgumentOutOfRangeException(nameof(count), count, "count must not be 0");
+      if (count == 1 || count == -1) return 0;
+
+      bool negative = count < 0;
+
+      long max = negative ? -count : count;
+
+      int bits = Log2((ulong)max);
+
+      long x;
+      do x = (long)(NextULong() >> (64 - bits));
+      while (x >= max);
+
+      return negative ? -x : x;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public long Next(long minValue, long count) => minValue + Next(count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double NextDouble() => (NextULong() >> 11) * INCR_DOUBLE;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int NextInt() => (int)(NextULong() >> 33);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint NextUInt() => (uint)NextULong();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool NextBool() => (NextULong() & 0x8000000000000000) != 0;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public byte NextByte() => (byte)(NextULong() >> 56);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float NextFloat() => (NextULong() >> 40) * INCR_FLOAT;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float NextFloatNonZero() => NextFloat() + INCR_FLOAT;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double NextDoubleNonZero() => NextDouble() + INCR_DOUBLE;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double NextDoubleHighRes()
+    {
+      int exponent = -64;
+      ulong significand;
+      int shift;
+
+      while ((significand = NextULong()) == 0)
+      {
+        exponent -= 64;
+
+        if (exponent < -1074)
+          return 0;
+      }
+
+      shift = BitOperations.LeadingZeroCount(significand);
+      if (shift != 0)
+      {
+        exponent -= shift;
+        significand <<= shift;
+        significand |= NextULong() >> (64 - shift);
+      }
+
+      significand |= 1;
+
+      return significand * Math.Pow(2, exponent);
+    }
+  }
+}