Fixed a bug in ostd::Random that occurred when min > max

other/build.nr

@@ -1 +1 @@
-1908
+1909

src/ostd/Random.cpp

@@ -6,7 +6,7 @@ namespace ostd
 	void RandomGenerator::seed(int64_t _seed)
 	{
 		m_engine.seed(_seed);
-		m_noiseGen.SetSeed(_seed); 
+		m_noiseGen.SetSeed(_seed);
 		m_seed = _seed;
 	}
 
@@ -14,85 +14,95 @@ namespace ostd
 	{
 		m_seed = std::chrono::steady_clock::now().time_since_epoch().count();
 		m_engine.seed(m_seed);
-		m_noiseGen.SetSeed(m_seed); 
+		m_noiseGen.SetSeed(m_seed);
 	}
-	
+
 	int64_t RandomGenerator::getSeed(void)
 	{
 		return m_seed;
 	}
-	
+
 	float RandomGenerator::getf32(float min, float max)
 	{
+		__swap_if_first_is_bigger<float>(min, max);
 		std::uniform_real_distribution<float> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	double RandomGenerator::getf64(double min, double max)
 	{
+		__swap_if_first_is_bigger<double>(min, max);
 		std::uniform_real_distribution<double> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	uint64_t RandomGenerator::getui64(uint64_t min, uint64_t max)
 	{
+		__swap_if_first_is_bigger<uint64_t>(min, max);
 		std::uniform_int_distribution<uint64_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	uint32_t RandomGenerator::getui32(uint32_t min, uint32_t max)
 	{
+		__swap_if_first_is_bigger<uint32_t>(min, max);
 		std::uniform_int_distribution<uint32_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	uint16_t RandomGenerator::getui16(uint16_t min, uint16_t max)
 	{
+		__swap_if_first_is_bigger<uint16_t>(min, max);
 		std::uniform_int_distribution<uint16_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	uint8_t RandomGenerator::getui8(uint8_t min, uint8_t max)
 	{
+		__swap_if_first_is_bigger<uint8_t>(min, max);
 		std::uniform_int_distribution<uint8_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	int64_t RandomGenerator::geti64(int64_t min, int64_t max)
 	{
+		__swap_if_first_is_bigger<int64_t>(min, max);
 		std::uniform_int_distribution<int64_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	int32_t RandomGenerator::geti32(int32_t min, int32_t max)
 	{
+		__swap_if_first_is_bigger<int32_t>(min, max);
 		std::uniform_int_distribution<int32_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	int16_t RandomGenerator::geti16(int16_t min, int16_t max)
 	{
+		__swap_if_first_is_bigger<int16_t>(min, max);
 		std::uniform_int_distribution<int16_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	int8_t RandomGenerator::geti8(int8_t min, int8_t max)
 	{
+		__swap_if_first_is_bigger<int8_t>(min, max);
 		std::uniform_int_distribution<int8_t> dist(min, max);
 		return dist(m_engine);
 	}
-	
+
 	bool RandomGenerator::getb(float true_percentage)
 	{
 		return getf32() >= (1.0f - std::clamp(true_percentage, 0.0f, 1.0f));
 	}
-	
+
 	Vec2 RandomGenerator::getVec2(float min, float max, bool match_xy)
 	{
 		float x = getf32(min, max);
 		return { x, (match_xy ? x : getf32(min, max)) };
 	}
-	
+
 	Vec2 RandomGenerator::getVec2(Vec2 minmax_x, Vec2 minmax_y)
 	{
 		return { getf32(minmax_x.x, minmax_x.y), getf32(minmax_y.x, minmax_y.y) };
@@ -103,5 +113,5 @@ namespace ostd
 		m_noiseGen.SetNoiseType(FastNoiseLite::NoiseType_OpenSimplex2);
 		return m_noiseGen.GetNoise(x, y);
 	}
-	
+
 }

src/ostd/Random.hpp

@@ -42,6 +42,16 @@ namespace ostd
 				return list[index];
 			}
 
+		private:
+			template <typename T>
+			inline void __swap_if_first_is_bigger(T& n1, T& n2)
+			{
+				if (n1 <= n2) return;
+				T n3 = n1;
+				n1 = n2;
+				n2 = n3;
+			}
+
 		private:
 			int64_t m_seed { 0 };
 			std::mt19937_64 m_engine;