Add in break monitoring timer system to both pads.

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
@@ -9,6 +10,7 @@ class SMX_PGE : public olc::PixelGameEngine
     bool paused = false;
     int mode = 0;
     vf2d playerPos = { 0,0 };
+    bool enabled{true};
 public:
     SMX_PGE()
     {
@@ -19,49 +21,150 @@ public:
     bool OnUserCreate() override
     {
         // Called once at the start, so create things here
+        //smx.EnableLogMessages(true);
         return true;
     }
 
+    struct Pad{
+        int consecutiveNotesHit{0}; //Once more than 100 are hit in a row, we're online.
+        float lastNoteHit{0.f}; //Amount of time that passed since the last note was hit. If this goes above ten seconds, reset consectiveNotesHit.
+        float idleTime{120.f}; //Timer that determines if the pad has been in an idle state long enough to issue a warning.
+        bool alertActive{false}; //Turns on when the alert sound should be played. Sets back to false when idle time is reset.
+        float flashTime{0.f}; //How much time has passed since the pad has flashed to a brighter/darker color.
+        bool flashRed{false}; //Set to true to choose the brighter red tone.
+        bool isActive{true};
+    };
+
+    Pad p1,p2;
+
     bool OnUserUpdate(float fElapsedTime) override
     {
-        smx.GetPanel(RIGHT, 0).bHeld;
-        if (GetKey(RIGHT).bPressed) {
-            mode = (mode + 1) % 3;
+        Clear({0,0,0});
+
+        SetPixelMode(Pixel::ALPHA);
+        p1.lastNoteHit+=fElapsedTime;
+        p2.lastNoteHit+=fElapsedTime;
+        FillRect({0,0},{12,21},{32,0,32,64});
+        FillRect({12,0},{12,21},{0,32,32,64});
+
+        #undef RIGHT
+
+        if(GetKey(HOME).bPressed)enabled=!enabled;
+        
+        if(enabled){
+            p1.idleTime+=fElapsedTime;
+            p2.idleTime+=fElapsedTime;
+            if(p1.idleTime>=120.f&&p1.isActive){
+                //Over the next 40 seconds, the outline of the pad will slowly enclose in.
+                const float timeRatio{std::min(1.f-((160.f-p1.idleTime)/40.f),1.f)};
+                const uint8_t alpha{uint8_t(p1.flashRed?255:uint8_t(timeRatio*48))};
+                FillRect({0,0},{int(11),int(11*timeRatio)},{255,0,0,alpha}); //Top
+                FillRect({0,int(21-11*timeRatio+1)},{int(11),int(11*timeRatio)},{255,0,0,alpha}); //Bottom
+                FillRect({0,0},{int(6*timeRatio),int(21)},{255,0,0,alpha}); //Left
+                FillRect({int(12-6*timeRatio+1),0},{int(6*timeRatio),int(21)},{255,0,0,alpha}); //Right
+            }
+            if(p2.idleTime>=120.f&&p2.isActive){
+                //Over the next 40 seconds, the outline of the pad will slowly enclose in.
+                const float timeRatio{std::min(1.f-((160.f-p2.idleTime)/40.f),1.f)};
+                const uint8_t alpha{uint8_t(p2.flashRed?255:uint8_t(timeRatio*48))};
+                FillRect({12,0},{int(11),int(11*timeRatio)},{255,0,0,uint8_t(alpha)}); //Top
+                FillRect({12,int(21-11*timeRatio+1)},{int(11),int(11*timeRatio)},{255,0,0,uint8_t(alpha)}); //Bottom
+                FillRect({12,0},{int(6*timeRatio),int(21)},{255,0,0,alpha}); //Left
+                FillRect({12+int(12-6*timeRatio+1),0},{int(6*timeRatio),int(21)},{255,0,0,uint8_t(alpha)}); //Right
+            }
+            if(p1.idleTime>=600.f)p1.isActive=false;
+            if(p2.idleTime>=600.f)p2.isActive=false;
+
+        
+            if(smx.GetPanel(RIGHT,0).bReleased||smx.GetPanel(LEFT,0).bReleased||smx.GetPanel(UP,0).bReleased||smx.GetPanel(DOWN,0).bReleased){
+                p1.consecutiveNotesHit++;
+                p1.lastNoteHit=0.f;
+            }
+            if(smx.GetPanel(RIGHT,1).bReleased||smx.GetPanel(LEFT,1).bReleased||smx.GetPanel(UP,1).bReleased||smx.GetPanel(DOWN,1).bReleased){
+                p2.consecutiveNotesHit++;
+                p2.lastNoteHit=0.f;
+            }
+
+            if(p1.lastNoteHit>=10.f){
+                p1.lastNoteHit=0.f;
+                p1.consecutiveNotesHit=std::clamp(p1.consecutiveNotesHit-10,0,100);
+            }
+            if(p2.lastNoteHit>=10.f){
+                p2.lastNoteHit=0.f;
+                p2.consecutiveNotesHit=std::clamp(p2.consecutiveNotesHit-10,0,100);
+            }
+
+            if(p1.consecutiveNotesHit>=100){
+                p1.idleTime=0.f;
+                p1.isActive=true;
+                p1.alertActive=false;
+            }
+            if(p2.consecutiveNotesHit>=100){
+                p2.idleTime=0.f;
+                p2.isActive=true;
+                p2.alertActive=false;
+            }
+        
+            if(p1.idleTime>=160.f){
+                p1.alertActive=true;
+                //PLAY SOUND HERE!!
+            }
+            if(p2.idleTime>=160.f){
+                p2.alertActive=true;
+                //PLAY SOUND HERE!!
+            }
+
+            if(p1.alertActive){
+                p1.flashTime-=fElapsedTime;
+                if(p1.flashTime<=0.f){
+                    p1.flashRed=!p1.flashRed;
+                    p1.flashTime=1.f;
+                }
+            }
+            if(p2.alertActive){
+                p2.flashTime-=fElapsedTime;
+                if(p2.flashTime<=0.f){
+                    p2.flashRed=!p2.flashRed;
+                    p2.flashTime=1.f;
+                }
+            }
         }
-        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(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(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(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(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(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(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(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(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);
+        }
+
+        SetPixelMode(Pixel::MASK);
+
         return true;
     }
 };
@@ -70,7 +173,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);