Fix bReleased boolean flags so they only trigger on actual release..

sample/PGEX_SMX_Example.cpp

@@ -1,6 +1,7 @@
 #define OLC_PGE_APPLICATION
 #include "olcPixelGameEngine.h"
 #include "PGEX_SMX.h"
+#include "util.h"
 using namespace olc;
 
 class SMX_PGE : public olc::PixelGameEngine
@@ -19,49 +20,187 @@ public:
     bool OnUserCreate() override
     {
         // Called once at the start, so create things here
+        //smx.EnableLogMessages(true);
         return true;
     }
 
+    struct Snow{
+        vf2d pos;
+        int id;
+    };
+
+    struct ExpandCircle{
+        vi2d pos;
+        float radius;
+        Pixel col;
+    };
+
+    std::vector<Snow>snow;
+    std::vector<Snow>backgroundSnow;
+    std::vector<ExpandCircle>expandCircles;
+    
+    const float backgroundSnowInterval{0.1f};
+    float backgroundSnowIntervalTimer{backgroundSnowInterval};
+    float backgroundSnowDirectionInterval{60.f};
+    
+    #define RIGHT true
+    bool backgroundSnowDirection{RIGHT};
+    float snowInterval{0.8f};
+    float snowTimer{snowInterval};
+    const float snowIntervalChangeInterval{60.f};
+    float snowIntervalTimer{snowIntervalChangeInterval};
+    double totalElapsedTime{0.};
+
+    float fallSpd{6.f};
+    float snowAmplitude{2.f};
+
+    std::map<std::pair<Key,int>,float>recreateCircleTimer{};
+    const float recreateCircleInterval{0.25f};
+
+    uint64_t SNOW_ID{0U};
+
     bool OnUserUpdate(float fElapsedTime) override
     {
-        smx.GetPanel(RIGHT, 0).bHeld;
-        if (GetKey(RIGHT).bPressed) {
-            mode = (mode + 1) % 3;
+        Clear({0,0,32});
+        backgroundSnowIntervalTimer-=fElapsedTime;
+        snowTimer-=fElapsedTime;
+        snowIntervalTimer-=fElapsedTime;
+        for(auto&[KEY,time]:recreateCircleTimer){
+            recreateCircleTimer[KEY]-=fElapsedTime;
         }
-        switch (mode) {
-            case 0: {
-                if (GetKey(SPACE).bPressed) {
-                    paused = !paused;
-                }
-                // called once per frame
-                if (!paused) {
-                    for (int x = 0; x < ScreenWidth(); x++)
-                        for (int y = 0; y < ScreenHeight(); y++)
-                            Draw(x, y, olc::Pixel(rand() % 255, rand() % 255, rand() % 255));
-                }
-            }break;
-            case 1: {
-                Clear(DARK_CYAN);
-                DrawRect({ 1,1 }, { 9,18 }, RED);
-            }break;
-            case 2: {
-                Clear(VERY_DARK_BLUE);
-                FillCircle(playerPos, 3,VERY_DARK_GREY);
-                DrawCircle(playerPos, 3);
-                if (GetKey(W).bHeld) {
-                    playerPos.y -= 5*fElapsedTime;
-                }
-                if (GetKey(A).bHeld) {
-                    playerPos.x -= 5 * fElapsedTime;
-                }
-                if (GetKey(S).bHeld) {
-                    playerPos.y += 5 * fElapsedTime;
-                }
-                if (GetKey(D).bHeld) {
-                    playerPos.x += 5 * fElapsedTime;
-                }
-            }break;
+        if(snowTimer<=0.f){
+            snow.emplace_back(vf2d{util::random(ScreenWidth()),-2.f},SNOW_ID++);
+            snowTimer=snowInterval;
         }
+        if(backgroundSnowIntervalTimer<=0.f){
+            int xOffset{int(util::random(ScreenWidth()))};
+            if(backgroundSnowDirection==RIGHT){
+                xOffset-=ScreenWidth()/2;
+            }else{
+                xOffset+=ScreenWidth()/2;
+            }
+            backgroundSnow.emplace_back(vf2d{float(xOffset),-2.f},SNOW_ID++);
+            backgroundSnowIntervalTimer=backgroundSnowInterval;
+        }
+        if(snowIntervalTimer<=0.f){
+            snowInterval=util::random_range(0.1f,2.f);
+            backgroundSnowDirection=!RIGHT;
+            if(rand()%2==0)backgroundSnowDirection=RIGHT;
+            snowIntervalTimer=snowIntervalChangeInterval;
+        }
+        for(Snow&backSnow:backgroundSnow){
+            srand(backSnow.id);
+            if(backgroundSnowDirection==RIGHT){
+                backSnow.pos.x+=fElapsedTime*snowAmplitude;
+            }else{
+                backSnow.pos.x-=fElapsedTime*snowAmplitude;
+            }
+            backSnow.pos.y+=fallSpd*fElapsedTime/2.f;
+            uint8_t randCol{uint8_t(10+rand()%50)};
+            Draw(backSnow.pos,Pixel{randCol,randCol,randCol});
+        }
+        for(Snow&snow:snow){
+            srand(snow.id);
+            float fallSpdMult{(rand()%25)/100.f};
+            snow.pos.y+=(fallSpd*(1.f-fallSpdMult))*fElapsedTime;
+            FillCircle(vi2d{int(snow.pos.x+sin(totalElapsedTime+snow.id*0.5f*fallSpd)*snowAmplitude),int(snow.pos.y)},rand()%2+1,{uint8_t(150+rand()%105),uint8_t(190+rand()%65),uint8_t(190+rand()%65)});
+        }
+        SetPixelMode(Pixel::ALPHA);
+        for(ExpandCircle&circle:expandCircles){
+            circle.radius+=fallSpd*fElapsedTime*6;
+            DrawCircle(circle.pos,circle.radius,circle.col);
+        }
+
+        std::erase_if(snow,[this](const Snow&snow){return snow.pos.y>ScreenHeight()+2;});
+        std::erase_if(backgroundSnow,[this](const Snow&backSnow){return backSnow.pos.y>ScreenHeight()+2;});
+        std::erase_if(expandCircles,[this](const ExpandCircle&circle){return circle.radius>24+2;});
+        double previousTotalElapsedTime{totalElapsedTime};
+        totalElapsedTime=fmod(totalElapsedTime+fElapsedTime,10000.);
+
+        #undef RIGHT
+        if(smx.GetPanel(RIGHT,0).bHeld){
+            FillRect({8,7},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({8,7},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{RIGHT,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{8+1,7+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{8+1,7+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{8+1,7+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{RIGHT,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{RIGHT,0}]=0;
+        if(smx.GetPanel(UP,0).bHeld){
+            FillRect({4,0},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({4,0},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{UP,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{4+1,0+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,0+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,0+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{UP,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{UP,0}]=0;
+        if(smx.GetPanel(DOWN,0).bHeld){
+            FillRect({4,14},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({4,14},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{DOWN,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{4+1,14+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,14+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,14+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{DOWN,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{DOWN,0}]=0;
+        if(smx.GetPanel(LEFT,0).bHeld){
+            FillRect({0,7},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({0,7},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{LEFT,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{0+1,7+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{0+1,7+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{0+1,7+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{LEFT,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{LEFT,0}]=0;
+        if(smx.GetPanel(RIGHT,1).bHeld){
+            FillRect({20,7},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({20,7},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{RIGHT,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{20+1,7+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{20+1,7+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{20+1,7+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{RIGHT,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{RIGHT,1}]=0;
+        if(smx.GetPanel(UP,1).bHeld){
+            FillRect({16,0},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({16,0},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{UP,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{16+1,3+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,3+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,3+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{UP,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{UP,1}]=0;
+        if(smx.GetPanel(DOWN,1).bHeld){
+            FillRect({16,14},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({16,14},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{DOWN,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{16+1,14+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,14+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,14+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{DOWN,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{DOWN,1}]=0;
+        if(smx.GetPanel(LEFT,1).bHeld){
+            FillRect({12,7},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({12,7},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{LEFT,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{12+1,3+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{12+1,3+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{12+1,3+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{LEFT,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{LEFT,1}]=0;
+
+        SetPixelMode(Pixel::MASK);
+
         return true;
     }
 };
@@ -70,7 +209,7 @@ public:
 int main()
 {
     SMX_PGE demo;
-    if (demo.Construct(12, 21, 50, 50))
+    if (demo.Construct(24, 21, 50, 50,false,true))
         demo.Start();
 
     return 0;

sample/SMXSample.vcxproj

@@ -62,7 +62,7 @@
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4063;4100;4127;4201;4244;4275;4355;4505;4512;4702;4786;4996;4996;4005;4018;4389;4389;4800;4592;%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <AdditionalIncludeDirectories>..\sdk</AdditionalIncludeDirectories>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -81,7 +81,7 @@
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4063;4100;4127;4201;4244;4275;4355;4505;4512;4702;4786;4996;4996;4005;4018;4389;4389;4800;4592;%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <AdditionalIncludeDirectories>..\sdk</AdditionalIncludeDirectories>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -93,6 +93,10 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="PGEX_SMX_Example.cpp" />
+    <ClCompile Include="util.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\sdk\Windows\SMX.vcxproj">
@@ -102,6 +106,10 @@
   <ItemGroup>
     <ClInclude Include="olcPixelGameEngine.h" />
     <ClInclude Include="PGEX_SMX.h" />
+    <ClInclude Include="util.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

sample/SMXSample.vcxproj.filters

@@ -13,6 +13,9 @@
     <ClCompile Include="PGEX_SMX_Example.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="olcPixelGameEngine.h">
@@ -21,5 +24,8 @@
     <ClInclude Include="PGEX_SMX.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

sample/util.cpp

@@ -0,0 +1,152 @@
+#pragma region License
+/*
+License (OLC-3)
+~~~~~~~~~~~~~~~
+
+Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions or derivations of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions or derivative works in binary form must reproduce the above
+copyright notice. This list of conditions and the following	disclaimer must be
+reproduced in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+Portions of this software are copyright © 2024 The FreeType
+Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
+All rights reserved.
+*/
+#pragma endregion
+#include "util.h"
+#include "olcPixelGameEngine.h"
+
+using namespace olc;
+
+std::random_device rd;
+std::mt19937 rng(rd());
+
+float util::random(float range){
+	static std::uniform_real_distribution<float>distrib(0,1);
+	return distrib(rng)*range;
+}
+
+int util::random(){
+	static std::uniform_int_distribution<int>distrib(0,32767);
+	return distrib(rng);
+}
+
+const float util::random_range(const float min,const float max){
+	return random(max-min)+min;
+}
+
+float util::radToDeg(float rad){
+	return rad*57.2957795130823208767f;
+}
+
+std::string util::timerStr(float time){
+	int seconds=int(time);
+	int hours=seconds/3600;
+	int minutes=seconds/60;
+
+	std::string timeStr="";
+	if(hours>0){
+		if(hours<10)timeStr+="0";
+		timeStr+=std::to_string(hours)+":";
+	}
+
+	if(minutes%60<10)timeStr+="0";
+	timeStr+=std::to_string(minutes%60)+":";
+
+	if(seconds%60<10)timeStr+="0";
+	timeStr+=std::to_string(seconds%60);
+
+	return timeStr;
+}
+
+std::string util::WrapText(PixelGameEngine*pge,std::string str,int width,bool proportional,vd2d scale){
+	std::string newStr="";
+	while(true){
+		std::string word="";
+		if(str.find(" ")==std::string::npos){
+			word=str;
+		}else{
+			word=str.substr(0,str.find(" "));
+		}
+		vi2d newSize = vd2d(proportional?pge->GetTextSizeProp(newStr+(newStr.size()>0?" ":"")+word):pge->GetTextSize(newStr+(newStr.size()>0?" ":"")+word))*scale;
+		if(newSize.x>width){
+			newStr+="\n"+word;
+		}else{
+			newStr+=(newStr.size()>0?" ":"")+word;
+		}
+		if(str.find(" ")==std::string::npos){
+			break;
+		}else{
+			str.erase(0,str.find(" ")+1);
+		}
+	}
+	return newStr;
+}
+
+
+#pragma region std::string util::GetHash(std::string fileName) //DO NOT MODIFY!
+std::string util::GetHash(std::string fileName){
+	//WARNING! This function is used to save/load files! This means if we ever modify this function all previous save files
+	//will no longer work! IN OTHER WORDS: DO NOT MODIFY THIS FUNCTION!
+	std::ifstream file(fileName);
+	std::string hash="";
+	uint8_t hashIndex=0;
+	while(file.good()){
+		uint8_t hashChar=0;
+		if(hash.size()==std::numeric_limits<uint8_t>::max()){
+			hashChar=hash[hashIndex];
+		}
+		char newChar=file.get();
+		if(newChar=='\r'||newChar=='\f'||newChar=='\n')continue;
+		hashChar+=newChar*21-7;
+		hashChar^=hashIndex;
+		if(hashIndex>0)hashChar+=hash[hashIndex-1];
+		hashChar%=94;
+		hashChar+=32;
+		if(hashChar=='"'||hashChar==',')hashChar+=60;
+		if(hashChar=='|')hashChar++; //FORBIDDEN CHARACTER IN EMSCRIPTEN BUILD!
+		if(hash.size()<std::numeric_limits<uint8_t>::max()){
+			hash+=hashChar;
+		}else{
+			hash[hashIndex]=hashChar;
+		}
+		hashIndex++;
+	}
+	file.close();
+	return hash;
+}
+#pragma endregion
+
+long double operator""_Pixels(long double unitDist){
+	return unitDist/100*24.;
+}
+
+const float util::distance(const vf2d&point1,const vf2d&point2){
+	return vf2d{point1-point2}.mag();
+}
+
+std::wstring util::to_wstring(const std::string&str){
+	return {str.begin(),str.end()};
+}

sample/util.h

@@ -0,0 +1,114 @@
+#pragma region License
+/*
+License (OLC-3)
+~~~~~~~~~~~~~~~
+
+Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions or derivations of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions or derivative works in binary form must reproduce the above
+copyright notice. This list of conditions and the following	disclaimer must be
+reproduced in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+Portions of this software are copyright © 2024 The FreeType
+Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
+All rights reserved.
+*/
+#pragma endregion
+#pragma once
+#include <stdlib.h>
+#include "olcPixelGameEngine.h"
+#include <random>
+
+namespace olc::util{
+	//Returns 0-range (as a float).
+	float random(float range);
+	//Returns a random float value min(inclusive) to max(exclusive).
+	const float random_range(const float min,const float max);
+	//Returns 0-32767 (as an int).
+	int random();
+	float radToDeg(float rad);
+
+	#pragma region Lerp templates + specializations
+	template<class T>
+	inline auto lerp(const T val1,const T val2,const float t){
+		return T(val1*(1-t)+val2*t);
+	}
+	
+	template<>
+	inline auto lerp<vf2d>(const vf2d val1,const vf2d val2,const float t){
+		return val1.lerp(val2,t);
+	}
+	
+	template<>
+	//NOTE: Also interpolates the alpha!!!
+	inline auto lerp<Pixel>(const Pixel val1,const Pixel val2,const float t){
+		Pixel col{PixelLerp(val1,val2,t)};
+		col.a=lerp(val1.a,val2.a,t);
+		return col;
+	}
+	#pragma endregion
+
+	template<class T,class U>
+	inline auto smoothstep(const T val1,const U val2,const float t){
+		auto x{decltype(val1+val2)(1-pow(1-t,3))};
+		return val1*(1-x)+val2*x;
+	}
+
+	std::string timerStr(float time);
+	std::string WrapText(PixelGameEngine*pge,std::string str,int width,bool proportional,vd2d scale);
+	std::string GetHash(std::string file);
+	const float distance(const vf2d&point1,const vf2d&point2);
+	std::wstring to_wstring(const std::string&str);
+	
+	template<class..._Args>
+	const std::string vformat(const std::string_view str,_Args..._Vals){
+		return std::vformat(str,std::make_format_args(_Vals...));
+	}
+	template<class..._Args>
+	const std::wstring wformat(const std::string_view str,_Args..._Vals){
+		return util::to_wstring(std::vformat(str,std::make_format_args(_Vals...)));
+	}
+
+	template<class T>
+	T map_range(T x, T in_min, T in_max, T out_min, T out_max) {
+		return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+	}
+}
+
+template<class TL, class TR>
+constexpr auto circ_add(
+	const TL& lhs, 
+	const TR& rhs, 
+	const decltype(lhs + rhs) rmin = 0, 
+	const decltype(lhs + rhs) rmax = 360)
+{
+	auto c = lhs + rhs;
+	auto range = rmax - rmin;
+	while (c >= rmax)  c -= range;
+	while (c <  rmin)  c += range;
+	return c;
+}
+
+//Converts unit distances to pixels. (Every 100 units = 24 pixels)
+long double operator""_Pixels(long double unitDist);