Ellpeck/MLEM
1
0
Fork 0
mirror of https://github.com/Ellpeck/MLEM.git synced 2024-11-26 06:28:35 +01:00
Code Issues Projects Releases Wiki Activity

Compare commits

base: Ellpeck:8ffd9ab48a643f1dde82a8b8e19145593ed4ece1
Branches Tags
Ellpeck:main
Ellpeck:7.1.1
Ellpeck:7.1.0
Ellpeck:7.0.0
Ellpeck:6.3.1
Ellpeck:6.3.0
..
compare: Ellpeck:1a1b2025cd1526a490910940a8a64916bea4b23a
Branches Tags
Ellpeck:main
Ellpeck:7.1.1
Ellpeck:7.1.0
Ellpeck:7.0.0
Ellpeck:6.3.1
Ellpeck:6.3.0

No commits in common. "8ffd9ab48a643f1dde82a8b8e19145593ed4ece1" and "1a1b2025cd1526a490910940a8a64916bea4b23a" have entirely different histories.
8ffd9ab48a ... 1a1b2025cd

3 changed files with 0 additions and 216 deletions
Show stats Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -18,7 +18,6 @@ Additions
- Added GetDownTime, GetUpTime, GetTimeSincePress, WasModifierDown and WasDown to Keybind and Combination - Added GetDownTime, GetUpTime, GetTimeSincePress, WasModifierDown and WasDown to Keybind and Combination
- Added the ability for UniformTextureAtlases to have padding for each region - Added the ability for UniformTextureAtlases to have padding for each region
- Added UniformTextureAtlas methods ToList and ToDictionary - Added UniformTextureAtlas methods ToList and ToDictionary
- Added the SingleRandom utility class
- **Added the ability to find paths to one of multiple goals using AStar** - **Added the ability to find paths to one of multiple goals using AStar**
Improvements Improvements

166
MLEM/Misc/SingleRandom.cs
View file

@ -1,166 +0,0 @@
using System;
namespace MLEM.Misc {
/// <summary>
/// The SingleRandom class allows generating single, one-off pseudorandom numbers based on a seed, or a set of seeds.
/// The types of numbers that can be generated are <see cref="int"/> and <see cref="float"/>, both of which can be generated with specific minimum and maximum values if desired.
/// Methods in this class are tested to be sufficiently "random", that is, to be sufficiently distributed throughout their range, as well as sufficiently different for neighboring seeds.
/// </summary>
public class SingleRandom {
/// <summary>
/// Generates a single, one-off pseudorandom integer between 0 and <see cref="int.MaxValue"/> based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static int Int(int seed) {
return (int) (SingleRandom.Single(seed) * int.MaxValue);
}
/// <summary>
/// Generates a single, one-off pseudorandom integer between 0 and <see cref="int.MaxValue"/> based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static int Int(params int[] seeds) {
return (int) (SingleRandom.Single(seeds) * int.MaxValue);
}
/// <summary>
/// Generates a single, one-off pseudorandom integer between 0 and <paramref name="maxValue"/> based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static int Int(int maxValue, int seed) {
return (int) (maxValue * SingleRandom.Single(seed));
}
/// <summary>
/// Generates a single, one-off pseudorandom integer between 0 and <paramref name="maxValue"/> based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static int Int(int maxValue, params int[] seeds) {
return (int) (maxValue * SingleRandom.Single(seeds));
}
/// <summary>
/// Generates a single, one-off pseudorandom integer between <paramref name="minValue"/> and <paramref name="maxValue"/> based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="minValue">The (inclusive) minimum value.</param>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static int Int(int minValue, int maxValue, int seed) {
return (int) ((maxValue - minValue) * SingleRandom.Single(seed)) + minValue;
}
/// <summary>
/// Generates a single, one-off pseudorandom integer between <paramref name="minValue"/> and <paramref name="maxValue"/> based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="minValue">The (inclusive) minimum value.</param>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static int Int(int minValue, int maxValue, params int[] seeds) {
return (int) ((maxValue - minValue) * SingleRandom.Single(seeds)) + minValue;
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between 0 and 1 based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static float Single(int seed) {
return (SingleRandom.Scramble(seed) / (float) int.MaxValue + 1) / 2;
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between 0 and 1 based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static float Single(params int[] seeds) {
return (SingleRandom.Scramble(seeds) / (float) int.MaxValue + 1) / 2;
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between 0 and <paramref name="maxValue"/> based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static float Single(float maxValue, int seed) {
return maxValue * SingleRandom.Single(seed);
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between 0 and <paramref name="maxValue"/> based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static float Single(float maxValue, params int[] seeds) {
return maxValue * SingleRandom.Single(seeds);
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between <paramref name="minValue"/> and <paramref name="maxValue"/> based on a given <paramref name="seed"/>.
/// This method is guaranteed to return the same result for the same <paramref name="seed"/>.
/// </summary>
/// <param name="minValue">The (inclusive) minimum value.</param>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seed">The seed to use.</param>
/// <returns>The generated number.</returns>
public static float Single(float minValue, float maxValue, int seed) {
return (maxValue - minValue) * SingleRandom.Single(seed) + minValue;
}
/// <summary>
/// Generates a single, one-off pseudorandom floating point number between <paramref name="minValue"/> and <paramref name="maxValue"/> based on a given set of <paramref name="seeds"/>.
/// This method is guaranteed to return the same result for the same set of <paramref name="seeds"/>.
/// </summary>
/// <param name="minValue">The (inclusive) minimum value.</param>
/// <param name="maxValue">The (exclusive) maximum value.</param>
/// <param name="seeds">The seeds to use.</param>
/// <returns>The generated number.</returns>
public static float Single(float minValue, float maxValue, params int[] seeds) {
return (maxValue - minValue) * SingleRandom.Single(seeds) + minValue;
}
private static int Scramble(int[] seeds) {
if (seeds == null || seeds.Length <= 0)
throw new ArgumentOutOfRangeException(nameof(seeds));
var ret = 1623487;
for (var i = 0; i < seeds.Length; i++)
ret += SingleRandom.ScrambleStep(seeds[i]) * 68659;
return ret;
}
private static int Scramble(int seed) {
return SingleRandom.ScrambleStep(seed) * 68659 + 1623487;
}
private static int ScrambleStep(int seed) {
seed ^= (seed << 7);
seed *= 207398809;
seed ^= (seed << 17);
seed *= 928511849;
seed ^= (seed << 12);
return seed + 3;
}
}
}

49
Tests/SingleRandomTests.cs
View file

@ -1,49 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using MLEM.Misc;
using NUnit.Framework;
namespace Tests;
public class SingleRandomTests {
[Test]
public void TestEquality() {
for (var i = 0; i < 1000000; i++) {
Assert.AreEqual(SingleRandom.Single(i), SingleRandom.Single(new[] {i}));
Assert.AreEqual(SingleRandom.Int(i), SingleRandom.Int(new[] {i}));
// test if all methods that accept mins and max are identical
Assert.AreEqual(SingleRandom.Int(i), SingleRandom.Int(int.MaxValue, i));
Assert.AreEqual(SingleRandom.Int(i), SingleRandom.Int(0, int.MaxValue, i));
Assert.AreEqual(SingleRandom.Single(i), SingleRandom.Single(1F, i));
Assert.AreEqual(SingleRandom.Single(i), SingleRandom.Single(0F, 1F, i));
}
}
[Test]
public void TestBounds() {
for (var i = 0; i < 1000000; i++) {
Assert.That(SingleRandom.Single(i), Is.LessThan(1).And.GreaterThanOrEqualTo(0));
Assert.That(SingleRandom.Single(127F, i), Is.LessThan(127).And.GreaterThanOrEqualTo(0));
Assert.That(SingleRandom.Single(12920F, 1203919023F, i), Is.LessThan(1203919023).And.GreaterThanOrEqualTo(12920));
Assert.That(SingleRandom.Int(i), Is.LessThan(int.MaxValue).And.GreaterThanOrEqualTo(0));
Assert.That(SingleRandom.Int(17, i), Is.LessThan(17).And.GreaterThanOrEqualTo(0));
Assert.That(SingleRandom.Int(19283, 832498394, i), Is.LessThan(832498394).And.GreaterThanOrEqualTo(19283));
}
}
[Test]
public void TestAverages() {
var ints = new List<int>();
var flts = new List<float>();
for (var i = 0; i < 1000000; i++) {
ints.Add(SingleRandom.Int(i));
flts.Add(SingleRandom.Single(i));
}
Assert.AreEqual(0.5, ints.Average() / int.MaxValue, 0.001);
Assert.AreEqual(0.5, flts.Average(), 0.001);
}
}