Merge branch 'master' of http://sig.projectdivar.com/sigonasr2/AdventuresInLestoria

Update rendering loop to use ranges and views instead of copies into vectors. Release Build 11997.

Adventures in Lestoria Tests/Adventures in Lestoria Tests.vcxproj

@@ -47,7 +47,7 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Unit Testing|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria;$(IncludePath)</IncludePath>
+    <IncludePath>J:\AdventuresInLestoria\Adventures in Lestoria;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria;$(IncludePath)</IncludePath>
     <OutDir>..\x64\Unit Testing</OutDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Unit Testing|Win32'">
@@ -58,12 +58,12 @@
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\sigon\OneDrive\Documents\include;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>J:\AdventuresInLestoria\Adventures in Lestoria\steam;J:\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\sigon\OneDrive\Documents\include;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
       <PrecompiledHeaderFile>
       </PrecompiledHeaderFile>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -103,6 +103,9 @@
     <ClCompile Include="..\Adventures in Lestoria\discord-files\store_manager.cpp" />
     <ClCompile Include="..\Adventures in Lestoria\discord-files\user_manager.cpp" />
     <ClCompile Include="..\Adventures in Lestoria\discord-files\voice_manager.cpp" />
+    <ClCompile Include="BuffTests.cpp">
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Unit Testing|x64'">$(ProjectDir)..\Adventures in Lestoria\discord-files;$(ProjectDir)..\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\sigon\OneDrive\Documents\include;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
     <ClCompile Include="EnchantTests.cpp">
       <SubType>
       </SubType>
@@ -110,6 +113,11 @@
     <ClCompile Include="EngineTests.cpp">
       <SubType>
       </SubType>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Unit Testing|x64'">$(ProjectDir)..\Adventures in Lestoria\discord-files;$(ProjectDir)..\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\sigon\OneDrive\Documents\include;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <ClCompile Include="FileTests.cpp">
+      <SubType>
+      </SubType>
     </ClCompile>
     <ClCompile Include="GeometryTests.cpp" />
     <ClCompile Include="ItemTests.cpp">
@@ -130,6 +138,12 @@
       <Project>{8e3067af-cfe7-4b11-bc6b-b867c32753d7}</Project>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="GameHelper.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

Adventures in Lestoria Tests/Adventures in Lestoria Tests.vcxproj.filters

@@ -75,5 +75,16 @@
     <ClCompile Include="EngineTests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="BuffTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="FileTests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="GameHelper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Adventures in Lestoria Tests/BuffTests.cpp

@@ -0,0 +1,173 @@
+#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 "CppUnitTest.h"
+#include "AdventuresInLestoria.h"
+#include "config.h"
+#include "ItemDrop.h"
+#include "Tutorial.h"
+#include "DamageNumber.h"
+#include "GameHelper.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace olc::utils;
+
+INCLUDE_MONSTER_DATA
+INCLUDE_game
+INCLUDE_GFX
+INCLUDE_DAMAGENUMBER_LIST
+INCLUDE_MONSTER_LIST
+INCLUDE_INITIALIZEGAMECONFIGURATIONS
+
+namespace BuffTests
+{
+	TEST_CLASS(BuffTest)
+	{
+	public:
+		std::unique_ptr<AiL>testGame;
+		#pragma region Setup Functions
+		void SetupTestMonster(){
+			InitializeGameConfigurations();
+			testGame.reset(new AiL(true));
+			ItemAttribute::Initialize();
+			ItemInfo::InitializeItems();
+			testGame->InitializeGraphics();
+			testGame->InitializeClasses();
+			sig::Animation::InitializeAnimations();
+			testGame->InitializeDefaultKeybinds();
+			testGame->InitializePlayer();
+			sig::Animation::SetupPlayerAnimations();
+			Menu::InitializeMenus();
+			Tutorial::Initialize();
+			Stats::InitializeDamageReductionTable();
+
+			GameState::Initialize();
+			GameState::STATE=GameState::states.at(States::State::GAME_RUN);
+			testGame->ResetLevelStates();
+			
+			#pragma region Setup a fake test map
+				game->MAP_DATA["CAMPAIGN_1_1"];
+				game->_SetCurrentLevel("CAMPAIGN_1_1");
+				ItemDrop::ClearDrops();
+			#pragma endregion
+
+			MonsterData testMonsterData{"TestName","Test Monster",30,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+			MONSTER_DATA["TestName"]=testMonsterData;
+
+			Menu::themes.SetInitialized();
+			GFX.SetInitialized();
+			DAMAGENUMBER_LIST.clear();
+		}
+		void SetupMockMap(){
+			game->MAP_DATA["CAMPAIGN_1_1"];
+			ItemDrop::ClearDrops();
+		}
+		#pragma endregion
+
+		TEST_METHOD_INITIALIZE(BuffInitialize){
+			SetupTestMonster();
+			SetupMockMap();
+		}
+		TEST_METHOD_CLEANUP(CleanupTests){
+			testGame->EndGame();
+			testGame->OnUserUpdate(0.f);
+			testGame.reset();
+		}
+		TEST_METHOD(AddBuffMonsterCallbackExpireFunctionTest){
+			Monster&m{game->SpawnMonster({},MONSTER_DATA.at("TestName"))};
+			Game::Update(0.f);
+			Assert::AreEqual(size_t(0),m.GetBuffs(BuffType::AFFECTED_BY_LIGHTNING_BOLT).size(),L"Monsters do not have any lightning bolt affected buffs when spawning.");
+			m.AddBuff(BuffType::AFFECTED_BY_LIGHTNING_BOLT,3.f,1,[](std::weak_ptr<Monster>attachedTarget,Buff&b){attachedTarget.lock()->Hurt(5,attachedTarget.lock()->OnUpperLevel(),attachedTarget.lock()->GetZ());});
+			Assert::AreEqual(size_t(1),m.GetBuffs(BuffType::AFFECTED_BY_LIGHTNING_BOLT).size(),L"Monster now has Affected By Lightning Bolt buff. Should get hurt for 5 damage in 3 seconds...");
+			Game::Update(0.f);
+			Game::Update(3.f);
+			Assert::AreEqual(25,m.GetHealth(),L"Monster should have taken 5 health from the expired callback provided.");
+		}
+		TEST_METHOD(AddBuffPlayerCallbackExpireFunctionTest){
+			Assert::AreEqual(size_t(0),game->GetPlayer()->GetBuffs(BuffType::AFFECTED_BY_LIGHTNING_BOLT).size(),L"Player does not have any lightning bolt affected buffs when spawning.");
+			game->GetPlayer()->AddBuff(BuffType::AFFECTED_BY_LIGHTNING_BOLT,3.f,1,[](Player*attachedTarget,Buff&b){attachedTarget->Hurt(5,attachedTarget->OnUpperLevel(),attachedTarget->GetZ());});
+			Game::Update(0.f);
+			Assert::AreEqual(size_t(1),game->GetPlayer()->GetBuffs(BuffType::AFFECTED_BY_LIGHTNING_BOLT).size(),L"Player is now affected By Lightning Bolt buff. Should get hurt for 5 damage in 3 seconds...");
+			Game::Update(0.f);
+			Game::Update(3.f);
+			Assert::AreEqual(95,game->GetPlayer()->GetHealth(),L"Player should have taken 5 health from the expired callback provided.");
+		}
+		TEST_METHOD(MonsterHasBuffFunctionTest){
+			Monster&m{game->SpawnMonster({},MONSTER_DATA.at("TestName"))};
+			Game::Update(0.f);
+			Assert::AreEqual(false,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should not have a speedboost buff before being given one.");
+			m.AddBuff(BuffType::ADRENALINE_RUSH,1.f,1.f);
+			Assert::AreEqual(false,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should not have a speedboost buff when given an unrelated buff.");
+			m.AddBuff(BuffType::SPEEDBOOST,1.f,1.f);
+			Assert::AreEqual(true,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should now have a speedboost buff.");
+			m.AddBuff(BuffType::SPEEDBOOST,2.f,1.f);
+			Assert::AreEqual(true,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should still report having a speedboost buff.");
+			Game::Update(0.f);
+			Game::Update(1.f);
+			Assert::AreEqual(true,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should still have one speedboost buff.");
+			Game::Update(1.f);
+			Assert::AreEqual(false,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should no longer have a speedboost buff.");
+			m.AddBuff(BuffType::SPEEDBOOST,1.f,1.f);
+			m.RemoveBuff(BuffType::SPEEDBOOST);
+			Assert::AreEqual(false,m.HasBuff(BuffType::SPEEDBOOST),L"Monster should no longer have a speedboost buff.");
+		}
+		TEST_METHOD(PlayerHasBuffFunctionTest){
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should not have a speedboost buff before being given one.");
+			Game::AddBuffToPlayer(BuffType::ADRENALINE_RUSH,1.f,1.f);
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should not have a speedboost buff when given an unrelated buff.");
+			Game::AddBuffToPlayer(BuffType::SPEEDBOOST,1.f,1.f);
+			Assert::AreEqual(true,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should now have a speedboost buff.");
+			Game::AddBuffToPlayer(BuffType::SPEEDBOOST,2.f,1.f);
+			Assert::AreEqual(true,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should still report having a speedboost buff.");
+			Game::Update(0.f);
+			Game::Update(1.f);
+			Assert::AreEqual(true,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should still have one speedboost buff.");
+			Game::Update(1.f);
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should no longer have a speedboost buff.");
+			Game::AddBuffToPlayer(BuffType::SPEEDBOOST,1.f,1.f);
+			game->GetPlayer()->RemoveBuff(BuffType::SPEEDBOOST);
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should no longer have a speedboost buff.");
+		}
+		TEST_METHOD(PlayerDoesNotImmediatelyReceiveBuffTest){
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should not have a speedboost buff before being given one.");
+			game->GetPlayer()->AddBuff(BuffType::SPEEDBOOST,1.f,1.f);
+			Assert::AreEqual(false,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should still not have a speedboost buff since it is in the add queue.");
+			Game::Update(0.f);
+			Assert::AreEqual(true,game->GetPlayer()->HasBuff(BuffType::SPEEDBOOST),L"Player should now have a speedboost buff.");
+		}
+	};
+}

Adventures in Lestoria Tests/EngineTests.cpp

@@ -38,20 +38,72 @@ All rights reserved.
 
 #include "CppUnitTest.h"
 #include "AdventuresInLestoria.h"
+#include "Tutorial.h"
+#include <random>
+#include <format>
+#include "ItemDrop.h"
+#include "DamageNumber.h"
+#include <ranges>
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
+INCLUDE_GFX
+INCLUDE_ITEM_DATA
+INCLUDE_DAMAGENUMBER_LIST
 INCLUDE_INITIALIZEGAMECONFIGURATIONS
 
+extern std::mt19937 rng;
+
 namespace EngineTests
 {
 	TEST_CLASS(EngineTest)
 	{
 	public:
 		std::unique_ptr<AiL>testGame;
+		InputGroup testKeyboardInput;
+		Player*player;
+		HWButton*testKey;
 		TEST_METHOD_INITIALIZE(PlayerInitialize){
 			InitializeGameConfigurations();
+			rng=std::mt19937{57189U};//Establish a fixed random seed on setup so the exact same results are generated every test run.
 			testGame.reset(new AiL(true));
+			ItemAttribute::Initialize();
+			ItemInfo::InitializeItems();
+			testGame->InitializeGraphics();
+			testGame->InitializeClasses();
+			sig::Animation::InitializeAnimations();
+			testGame->InitializeDefaultKeybinds();
+			testGame->InitializePlayer();
+			sig::Animation::SetupPlayerAnimations();
+			Menu::InitializeMenus();
+			Tutorial::Initialize();
+			Stats::InitializeDamageReductionTable();
+
+			GameState::Initialize();
+			GameState::STATE=GameState::states.at(States::State::GAME_RUN);
+			
+			#pragma region Setup a fake test map and test monster
+				game->MAP_DATA["CAMPAIGN_1_1"];
+				ItemDrop::ClearDrops();
+				MonsterData testMonsterData{"TestName","Test Monster",1000,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+				MONSTER_DATA["TestName"]=testMonsterData;
+			#pragma endregion
+			testGame->ResetLevelStates();
+
+			player=testGame->GetPlayer();
+			//Setup key "0" as a test input
+			testKeyboardInput.AddKeybind(Input{InputType::KEY,0});
+			testKey=testGame->GetKeyboardState(0);
+			testGame->olc_UpdateKeyFocus(true); //Force the game to be "focused" for tests. Required if we want keyboard inputs to work.
+			Menu::themes.SetInitialized();
+			GFX.SetInitialized();
+
+			DAMAGENUMBER_LIST.clear();
+		}
+		TEST_METHOD_CLEANUP(CleanupTests){
+			testGame->EndGame();
+			testGame->OnUserUpdate(0.f);
+			testGame.reset();
 		}
 		TEST_METHOD(StripColorTest){
 			std::string noColCode{"Hello World!"};
@@ -105,5 +157,22 @@ namespace EngineTests
 			std::u32string u32middleColorCodeStr{middleColorCodeStr.begin(),middleColorCodeStr.end()};
 			Assert::AreEqual(WHITE.n,testGame->GetFinalRenderColor(WHITE,middleColorCodeStr).n,L"Should use source color since there's no leading HTML color code.");
 		}
+		TEST_METHOD(UtilMapRangeTest){
+			Assert::AreEqual(0.f,util::map_range<float>(0.f,0,100,0,100),L"0 in input range 0-100 output range 0-100 maps to 0");
+			Assert::AreEqual(100.f,util::map_range<float>(100.f,0,100,0,100),L"100 in input range 0-100 output range 0-100 maps to 100");
+			Assert::AreEqual(50.f,util::map_range<float>(50.f,0,100,0,100),L"50 in input range 0-100 output range 0-100 maps to 100");
+
+			Assert::AreEqual(0.f,util::map_range<float>(0.f,0,50,0,100),L"0 in input range 0-50 output range 0-100 maps to 0");
+			Assert::AreEqual(200.f,util::map_range<float>(100.f,0,50,0,100),L"100 in input range 0-50 output range 0-100 maps to 200");
+			Assert::AreEqual(100.f,util::map_range<float>(50.f,0,50,0,100),L"50 in input range 0-50 output range 0-100 maps to 100");
+
+			Assert::AreEqual(100.f,util::map_range<float>(0.f,0,100,100,200),L"0 in input range 0-100 output range 100-200 maps to 100");
+			Assert::AreEqual(200.f,util::map_range<float>(100.f,0,100,100,200),L"100 in input range 0-100 output range 100-200 maps to 200");
+			Assert::AreEqual(150.f,util::map_range<float>(50.f,0,100,100,200),L"50 in input range 0-100 output range 100-200 maps to 150");
+
+			Assert::AreEqual(0.f,util::map_range<float>(0.f,50,100,100,200),L"0 in input range 50-100 output range 100-200 maps to 0");
+			Assert::AreEqual(200.f,util::map_range<float>(100.f,50,100,100,200),L"100 in input range 50-100 output range 100-200 maps to 200");
+			Assert::AreEqual(100.f,util::map_range<float>(50.f,50,100,100,200),L"50 in input range 50-100 output range 100-200 maps to 100");
+		}
 	};
 }

Adventures in Lestoria Tests/FileTests.cpp

@@ -0,0 +1,113 @@
+#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 "CppUnitTest.h"
+#include "AdventuresInLestoria.h"
+#include "config.h"
+#include "ItemDrop.h"
+#include "Tutorial.h"
+#include "DamageNumber.h"
+#include "GameHelper.h"
+#include "SaveFile.h"
+#include <ranges>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace olc::utils;
+
+INCLUDE_MONSTER_DATA
+INCLUDE_game
+INCLUDE_GFX
+INCLUDE_DAMAGENUMBER_LIST
+INCLUDE_MONSTER_LIST
+INCLUDE_INITIALIZEGAMECONFIGURATIONS
+
+namespace FileTests
+{
+	TEST_CLASS(FileTest)
+	{
+	public:
+		std::unique_ptr<AiL>testGame;
+		#pragma region Setup Functions
+		void SetupTest(){
+			InitializeGameConfigurations();
+			testGame.reset(new AiL(true));
+			ItemAttribute::Initialize();
+			ItemInfo::InitializeItems();
+			testGame->InitializeGraphics();
+			testGame->InitializeClasses();
+			sig::Animation::InitializeAnimations();
+			testGame->InitializeDefaultKeybinds();
+			testGame->InitializePlayer();
+			sig::Animation::SetupPlayerAnimations();
+			Menu::InitializeMenus();
+			Tutorial::Initialize();
+			Stats::InitializeDamageReductionTable();
+
+			GameState::Initialize();
+			GameState::STATE=GameState::states.at(States::State::GAME_RUN);
+			testGame->ResetLevelStates();
+			
+			#pragma region Setup a fake test map
+				game->MAP_DATA["CAMPAIGN_1_1"];
+				game->_SetCurrentLevel("CAMPAIGN_1_1");
+				ItemDrop::ClearDrops();
+			#pragma endregion
+
+			MonsterData testMonsterData{"TestName","Test Monster",30,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+			MONSTER_DATA["TestName"]=testMonsterData;
+
+			Menu::themes.SetInitialized();
+			GFX.SetInitialized();
+			DAMAGENUMBER_LIST.clear();
+		}
+		void SetupMockMap(){
+			game->MAP_DATA["CAMPAIGN_1_1"];
+			ItemDrop::ClearDrops();
+		}
+		#pragma endregion
+
+		TEST_METHOD_INITIALIZE(FileTestInitialize){
+			SetupTest();
+			SetupMockMap();
+		}
+		TEST_METHOD_CLEANUP(CleanupFileTests){
+			testGame->EndGame();
+			testGame->OnUserUpdate(0.f);
+			testGame.reset();
+		}
+	};
+}

Adventures in Lestoria Tests/GameHelper.h

@@ -0,0 +1,95 @@
+#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 "CppUnitTest.h"
+#include "AdventuresInLestoria.h"
+
+INCLUDE_game
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace Game{
+	enum class CastWaitProperty{
+		WAIT_FOR_CAST_TIME,
+		NO_WAIT,
+	};
+	inline void Update(const float fElapsedTime){
+		game->SetElapsedTime(fElapsedTime);
+		game->OnUserUpdate(fElapsedTime);
+	}
+	inline void CastAbilityAtLocation(Ability&ability,const vf2d&worldLoc,const CastWaitProperty castWaitTime=CastWaitProperty::WAIT_FOR_CAST_TIME){ //NOTE: screenLoc is the actual screen coordinates, NOT the world coordinates! You are defining the mouse position essentially.
+		game->GetPlayer()->SetTestScreenAimingLocation(worldLoc);
+		game->GetPlayer()->PrepareCast(ability);
+		game->GetPlayer()->CastSpell(ability);
+		Game::Update(ability.precastInfo.castTime);
+	}
+	inline void ChangeClass(Player*&player_in,const Class&cl){
+		game->ChangePlayerClass(cl);
+		player_in=game->GetPlayer();
+	}
+	inline std::weak_ptr<Item>GiveAndEquipEnchantedRing(const std::string_view enchantName,const EquipSlot slot=EquipSlot::RING1){
+		std::weak_ptr<Item>nullRing{Inventory::AddItem("Null Ring"s)};
+		Inventory::EquipItem(nullRing,slot);
+		nullRing.lock()->_EnchantItem(enchantName);
+		return nullRing;
+	}
+	//Adds the buff directly to the player instead of the buffs added list. (By calling an update tick.)
+	inline void AddBuffToPlayer(BuffType type,float duration,float intensity){
+		game->GetPlayer()->AddBuff(type,duration,intensity);
+		Update(0.f);
+	}
+	//NOTE: If adding a % increase stat, please use the percentage version! 100% = 1!!
+	inline void AddBuffToPlayer(BuffType type,float duration,float intensity,std::set<ItemAttribute>attr){
+		game->GetPlayer()->AddBuff(type,duration,intensity,attr);
+		Update(0.f);
+	}
+	//NOTE: If adding a % increase stat, please use the percentage version! 100% = 1!!
+	inline void AddBuffToPlayer(BuffType type,float duration,float intensity,std::set<std::string>attr){
+		game->GetPlayer()->AddBuff(type,duration,intensity,attr);
+		Update(0.f);
+	}
+}
+
+namespace Test
+{
+	template<class T>
+	inline static void InRange(T initialVal,std::pair<T,T>range,std::wstring_view assertMessage){
+		Assert::IsTrue(initialVal>=range.first&&initialVal<=range.second,std::format(L"Expected: {}~{}   Actual: {} - {}",range.first,range.second,initialVal,assertMessage).c_str());
+	}
+}

Adventures in Lestoria Tests/ItemTests.cpp

@@ -42,6 +42,7 @@ All rights reserved.
 #include <format>
 #include "ItemDrop.h"
 #include <ranges>
+#include "GameHelper.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 using namespace olc::utils;
@@ -79,6 +80,7 @@ namespace ItemTests
 			GameState::Initialize();
 			GameState::STATE=GameState::states.at(States::State::GAME_RUN);
 			
+			testGame->ResetLevelStates();
 			#pragma region Setup a fake test map and test monster
 				game->MAP_DATA["CAMPAIGN_1_1"];
 				ItemDrop::ClearDrops();
@@ -94,8 +96,10 @@ namespace ItemTests
 			Menu::themes.SetInitialized();
 			GFX.SetInitialized();
 		}
-		TEST_METHOD_CLEANUP(CleanupTests){
+		TEST_METHOD_CLEANUP(ItemCleanupTests){
 			testGame->EndGame();
+			testGame->OnUserUpdate(0.f);
+			testGame.reset();
 		}
 		TEST_METHOD(ItemGiveTest){
 			Inventory::AddItem("Health Potion"s,3);
@@ -151,6 +155,7 @@ namespace ItemTests
 			game->SetLoadoutItem(0,"Flat Recovery Potion");
 			testKey->bHeld=true; //Simulate key being pressed.
 			player->CheckAndPerformAbility(player->GetItem1(),testKeyboardInput);
+			game->OnUserUpdate(0.f); //Wait an extra tick for the buff to begin going down.
 			game->SetElapsedTime(0.05f);
 			game->OnUserUpdate(0.05f);//Wait some time as the item applies a buff that heals us. We're also going to gain one mana during this tick.
 			Assert::AreEqual(75,player->GetHealth(),L"Player Health is 75 after using Flat Recovery Potion.");
@@ -163,6 +168,7 @@ namespace ItemTests
 			game->SetLoadoutItem(1,"Pct Recovery Potion");
 			testKey->bHeld=true; //Simulate key being pressed.
 			player->CheckAndPerformAbility(player->GetItem2(),testKeyboardInput);
+			game->OnUserUpdate(0.f); //Wait an extra tick for the buff to begin going down.
 			game->SetElapsedTime(0.05f);
 			game->OnUserUpdate(0.05f);//Wait some time as the item applies a buff that heals us.
 			Assert::AreEqual(75,player->GetHealth(),L"Player Health is 75 after using Pct Recovery Potion.");
@@ -174,6 +180,7 @@ namespace ItemTests
 			game->SetLoadoutItem(2,"Bandages");
 			testKey->bHeld=true; //Simulate key being pressed.
 			player->CheckAndPerformAbility(player->GetItem3(),testKeyboardInput);
+			game->OnUserUpdate(0.f); //Wait an extra tick for the buff to begin going down.
 			game->SetElapsedTime(0.05f);
 			game->OnUserUpdate(0.05f);//Wait some time as the item applies a buff that heals us.
 			Assert::AreEqual(30,player->GetHealth(),L"Player is immediately healed for 5 health points on Bandages use.");
@@ -216,6 +223,7 @@ namespace ItemTests
 			std::weak_ptr<Item>testArmor{Inventory::AddItem("Test Armor"s)};
 			Assert::IsFalse(testArmor.lock()->CanBeRefined(),L"Test Armor should not be allowed to be refined since it's not an accessory.");
 			Inventory::AddItem(slimeKingRing.lock()->FragmentName(),50U);
+			Inventory::EquipItem(slimeKingRing,EquipSlot::RING1);
 			Assert::IsTrue(slimeKingRing.lock()->CanBeRefined(),L"Ring of the Slime King should now be allowed to be refined since we meet all requirements.");
 			player->SetMoney(0);
 			Assert::IsFalse(slimeKingRing.lock()->CanBeRefined(),L"Ring of the Slime King should not be allowed to be refined since we do not have enough money.");
@@ -227,22 +235,122 @@ namespace ItemTests
 			for(const auto&[attr,val]:slimeKingRing.lock()->RandomStats()){
 				Assert::AreEqual(ITEM_DATA[slimeKingRing.lock()->ActualName()].GetMaxStats().A_Read(attr),val,L"The current stats should be equal to the maximum stats when refinement is done.");
 			}
+			/*Ring of the Slime King has the following refining stats:
+			*	StatValues = Health,Mana,Move Spd %
+				MinStats = 5,1,1
+				MaxStats = 20,4,3
+			* 
+				Therefore, after this process is done the player should have 20 more health, 4 more mana, and 3% more move speed than normal.
+			*/
+			//These checks make sure that the refining call actually modifies already equipped items!
+			Assert::AreEqual(120,player->GetMaxHealth(),L"Player should now have 120 max health.");
+			Assert::AreEqual(104,player->GetMaxMana(),L"Player should now have 104 max mana.");
+			Assert::AreEqual(1.03f,player->GetMoveSpdMult(),L"Player should now have 103% move speed.");
 		}
 		TEST_METHOD(EnchantTestCheck){
 			std::weak_ptr<Item>slimeKingRing{Inventory::AddItem("Ring of the Slime King"s)};
 			Assert::IsFalse(slimeKingRing.lock()->HasEnchant());
+			bool obtainedDuplicate{false};
 			for(int i:std::ranges::iota_view(0,1000)){
-				slimeKingRing.lock()->EnchantItem(ItemEnchant::RollRandomEnchant());
+				std::optional<ItemEnchant>previousEnchant{slimeKingRing.lock()->GetEnchant()};
+				std::string previousEnchantName{};
+				if(slimeKingRing.lock()->HasEnchant())previousEnchantName=slimeKingRing.lock()->GetEnchant().value().Name();
+				slimeKingRing.lock()->_EnchantItem(ItemEnchant::RollRandomEnchant(previousEnchant));
 				Assert::IsTrue(slimeKingRing.lock()->HasEnchant());
+				if(previousEnchantName==slimeKingRing.lock()->GetEnchant().value().Name()){
+					bool improvementExists{false};
+					std::string statDowngrades{};
+					if(previousEnchant.value().HasAttributes()){
+						for(const auto&[attr,val]:previousEnchant.value()){
+							if(slimeKingRing.lock()->GetEnchant().value().GetAttribute(attr.ActualName())>val){
+								improvementExists=true;
+								break;
+							}else statDowngrades+=std::format("{} - Previous:{}, New:{}\n",attr.Name(),val,slimeKingRing.lock()->GetEnchant().value().GetAttribute(attr.ActualName()));
+						}
+					}else improvementExists=true;
+					Assert::IsTrue(improvementExists,util::wformat("Could not find a stat improvement for same name stat! {} THIS SHOULD NOT BE ALLOWED!",statDowngrades).c_str());
+					obtainedDuplicate=true;
+				}
 				if(ItemEnchantInfo::ENCHANT_LIST.at(slimeKingRing.lock()->GetEnchant().value().Name()).GetClass().has_value())Assert::AreEqual(int(player->GetClass()),int(ItemEnchantInfo::ENCHANT_LIST.at(slimeKingRing.lock()->GetEnchant().value().Name()).GetClass().value())); //Validate enchant is only for this class if it's a class-based ability.
 			}
 			testGame->ChangePlayerClass(WIZARD);
 			player=testGame->GetPlayer(); //The player pointer has been reassigned...
 			for(int i:std::ranges::iota_view(0,1000)){
-				slimeKingRing.lock()->EnchantItem(ItemEnchant::RollRandomEnchant());
+				std::optional<ItemEnchant> previousEnchant{slimeKingRing.lock()->GetEnchant()};
+				std::string previousEnchantName{};
+				if(slimeKingRing.lock()->HasEnchant())previousEnchantName=slimeKingRing.lock()->GetEnchant().value().Name();
+				slimeKingRing.lock()->_EnchantItem(ItemEnchant::RollRandomEnchant(previousEnchant));
 				Assert::IsTrue(slimeKingRing.lock()->HasEnchant());
+				if(previousEnchantName==slimeKingRing.lock()->GetEnchant().value().Name()){
+					bool improvementExists{false};
+					std::string statDowngrades{};
+					if(previousEnchant.value().HasAttributes()){
+						for(const auto&[attr,val]:previousEnchant.value()){
+							if(slimeKingRing.lock()->GetEnchant().value().GetAttribute(attr.ActualName())>val){
+								improvementExists=true;
+								break;
+							}else statDowngrades+=std::format("{} - Previous:{}, New:{}\n",attr.Name(),val,slimeKingRing.lock()->GetEnchant().value().GetAttribute(attr.ActualName()));
+						}
+					}else improvementExists=true;
+					Assert::IsTrue(improvementExists,util::wformat("Could not find a stat improvement for same name stat! {} THIS SHOULD NOT BE ALLOWED!",statDowngrades).c_str());
+					obtainedDuplicate=true;
+				}
 				if(ItemEnchantInfo::ENCHANT_LIST.at(slimeKingRing.lock()->GetEnchant().value().Name()).GetClass().has_value())Assert::AreEqual(int(player->GetClass()),int(ItemEnchantInfo::ENCHANT_LIST.at(slimeKingRing.lock()->GetEnchant().value().Name()).GetClass().value())); //Validate enchant is only for this class if it's a class-based ability.
 			}
+			Assert::IsTrue(obtainedDuplicate,L"During this test a duplicate enchant was never obtained! THIS SHOULD BE ALLOWED!");
+		}
+		TEST_METHOD(AccessoryAntiCompatibilityCheck){
+			std::weak_ptr<Item>extraRing{Inventory::AddItem("Ring of the Slime King"s)};
+			std::weak_ptr<Item>extraRing2{Inventory::AddItem("Ring of the Slime King"s)};
+
+			Inventory::EquipItem(extraRing,EquipSlot::RING2);
+			Assert::AreEqual(true,Item::SelectedEquipIsDifferent(extraRing2,EquipSlot::RING1),L"The game should allow equipping of any two normal rings that are not the same ring.");
+			Assert::AreEqual(false,Item::SelectedEquipIsDifferent(extraRing,EquipSlot::RING1),L"The game should not allow equipping the same ring if it's already equipped.");
+			Inventory::UnequipItem(EquipSlot::RING2);
+			Assert::AreEqual(true,Item::SelectedEquipIsDifferent(extraRing,EquipSlot::RING1),L"The game should allow equipping a ring to either blank slot if they're open.");
+		}
+		TEST_METHOD(AccessoryRandomEnchantTest){
+			std::weak_ptr<Item>extraRing{Inventory::AddItem("Ring of the Slime King"s)};
+			std::unordered_map<ItemEnchantInfo::ItemEnchantCategory,uint32_t>enchantCounts;
+			for(int i:std::ranges::iota_view(0,1000)){
+				Inventory::AddItem(extraRing.lock()->FragmentName(),"Fragment Enchant Cost"_i[0]);
+				player->AddMoney("Fragment Enchant Cost"_i[1]);
+				const ItemEnchant&resultEnchant{extraRing.lock()->ApplyRandomEnchant()};
+				if(resultEnchant.GetClass().has_value())Assert::AreEqual(int(resultEnchant.GetClass().value()),int(player->GetClass()),L"Player's class matches the class of the enchant.");
+				enchantCounts[resultEnchant.Category()]++;
+				Assert::AreEqual(true,extraRing.lock()->GetEnchant().has_value(),L"Ring is expected to be enchanted.");
+				Assert::AreEqual(resultEnchant.Name(),extraRing.lock()->GetEnchant().value().Name(),L"Ring is expected to be enchanted with the same enchant that was selected.");
+				Assert::AreEqual(false,player->HasEnchant(resultEnchant.Name()),L"Player is not expected to have the same enchant that was selected while the ring is unequipped.");
+				Inventory::EquipItem(extraRing,EquipSlot::RING1);
+				Assert::AreEqual(true,player->HasEnchant(resultEnchant.Name()),L"Player is expected to have the same enchant that was selected.");
+				Inventory::UnequipItem(EquipSlot::RING1);
+			}
+			Test::InRange(enchantCounts[ItemEnchantInfo::ItemEnchantCategory::GENERAL],{450U,550U},util::wformat("General enchants % is approx 50%."));
+			Test::InRange(enchantCounts[ItemEnchantInfo::ItemEnchantCategory::CLASS],{350U,450U},util::wformat("Class enchants % is approx 40%."));
+			Test::InRange(enchantCounts[ItemEnchantInfo::ItemEnchantCategory::UNIQUE],{50U,150U},util::wformat("Unique enchants % is approx 40%."));
+		}
+		TEST_METHOD(EnchantColorTest){
+			Assert::AreEqual("Item Enchants.General Enchants.Enchant Display Color"_Pixel.n,ItemEnchantInfo::GetEnchant("Health Boost").DisplayCol().n,L"Expecting a general enchant to have the general enchant pixel display color.");
+			Assert::AreEqual("Item Enchants.Class Enchants.Enchant Display Color"_Pixel.n,ItemEnchantInfo::GetEnchant("Quickdraw").DisplayCol().n,L"Expecting a class enchant to have the class enchant pixel display color.");
+			Assert::AreEqual("Item Enchants.Unique Enchants.Enchant Display Color"_Pixel.n,ItemEnchantInfo::GetEnchant("Magical Protection").DisplayCol().n,L"Expecting a unique enchant to have the unique enchant pixel display color.");
+		}
+		TEST_METHOD(CanBeEnchantedTest){
+			std::weak_ptr<Item>extraRing{Inventory::AddItem("Ring of the Slime King"s)};
+			std::weak_ptr<Item>testArmor{Inventory::AddItem("Test Armor"s)};
+			Assert::AreEqual(false,extraRing.lock()->CanBeEnchanted(),L"We don't have the money nor required fragments to enchant this item.");
+			Assert::AreEqual(false,testArmor.lock()->CanBeEnchanted(),L"We can't enchant armor.");
+			player->SetMoney(2000U);
+			Assert::AreEqual(false,extraRing.lock()->CanBeEnchanted(),L"We don't have the required fragments to enchant this item.");
+			player->SetMoney(0U);
+			Inventory::AddItem(extraRing.lock()->FragmentName(),"Fragment Enchant Cost"_i[0]);
+			Assert::AreEqual(false,extraRing.lock()->CanBeEnchanted(),L"We don't have the required money to enchant this item.");
+			player->SetMoney(2000U);
+			Assert::AreEqual(true,extraRing.lock()->CanBeEnchanted(),L"We don't have the required money to enchant this item.");
+			extraRing.lock()->ApplyRandomEnchant();
+			Assert::AreEqual(false,extraRing.lock()->CanBeEnchanted(),L"Ring cannot be enchanted again due to consumption of fragments.");
+			Inventory::AddItem(extraRing.lock()->FragmentName(),"Fragment Enchant Cost"_i[0]);
+			Assert::AreEqual(true,extraRing.lock()->CanBeEnchanted(),L"Ring can be enchanted again with the right amount of fragments.");
+			Assert::AreEqual(uint32_t(2000-"Fragment Enchant Cost"_i[1]),player->GetMoney(),util::wformat("Lost {} money due to enchanting ring.","Fragment Enchant Cost"_i[1]).c_str());
 		}
 	};
 }

Adventures in Lestoria Tests/MonsterTests.cpp

@@ -41,6 +41,7 @@ All rights reserved.
 #include "ItemDrop.h"
 #include "Tutorial.h"
 #include "DamageNumber.h"
+#include "GameHelper.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 using namespace olc::utils;
@@ -73,6 +74,8 @@ namespace MonsterTests
 			testGame->InitializeGraphics();
 			testGame->InitializeClasses();
 			sig::Animation::InitializeAnimations();
+			Monster::InitializeStrategies();
+			MonsterData::InitializeMonsterData();
 			testGame->InitializeDefaultKeybinds();
 			testGame->InitializePlayer();
 			sig::Animation::SetupPlayerAnimations();
@@ -82,6 +85,7 @@ namespace MonsterTests
 
 			GameState::Initialize();
 			GameState::STATE=GameState::states.at(States::State::GAME_RUN);
+			testGame->ResetLevelStates();
 			
 			#pragma region Setup a fake test map
 				game->MAP_DATA["CAMPAIGN_1_1"];
@@ -106,8 +110,10 @@ namespace MonsterTests
 			SetupTestMonster();
 			SetupMockMap();
 		}
-		~MonsterTest(){
-			testGame.release();
+		TEST_METHOD_CLEANUP(MonsterTestCleanup){
+			testGame->EndGame();
+			testGame->OnUserUpdate(0.f);
+			testGame.reset();
 		}
 		TEST_METHOD(DisplayNameCheck){
 			Assert::AreEqual("Test Monster",MONSTER_DATA["TestName"].GetDisplayName().c_str());
@@ -404,8 +410,7 @@ namespace MonsterTests
 		TEST_METHOD(TrapperMarkTest){
 			MonsterData testMonsterData{"TestName","Test Monster",30,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
 			game->SpawnMonster({},testMonsterData);
-			game->SetElapsedTime(0.1f);
-			game->OnUserUpdate(0.1f); //A monster that is spawned needs to be added to the monster list in the next tick.
+			Game::Update(0.1f); //A monster that is spawned needs to be added to the monster list in the next tick.
 			std::weak_ptr<Monster>testMonster{MONSTER_LIST.front()};
 
 			Assert::AreEqual(uint8_t(0),testMonster.lock()->GetMarkStacks(),L"Monster has 0 marks initially.");
@@ -456,5 +461,99 @@ namespace MonsterTests
 
 			Assert::AreEqual(uint8_t(0),testMonster.lock()->GetMarkStacks(),L"The marks should have expired after 10 seconds.");
 		}
+		TEST_METHOD(HurtFailsWhenDead){
+			MonsterData testMonsterData{"TestName","Test Monster",30,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+			Monster&m{game->SpawnMonster({},testMonsterData)};
+			m.Hurt(50,m.OnUpperLevel(),m.GetZ());
+			Assert::IsTrue(m.IsDead(),L"Monster is considered dead.");
+			Assert::IsTrue(!m.IsAlive(),L"Monster is considered dead.");
+
+			Assert::IsFalse(m.Hurt(50,m.OnUpperLevel(),m.GetZ()),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+			Assert::IsFalse(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::DOT),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+			Assert::IsFalse(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::PLAYER_ABILITY),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+			Assert::IsFalse(m._DealTrueDamage(50),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+			Assert::IsFalse(m._DealTrueDamage(50,HurtFlag::DOT),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+			Assert::IsFalse(m._DealTrueDamage(50,HurtFlag::PLAYER_ABILITY),L"When hurting a dead monster, it should not take any damage and should not be triggering anything else.");
+		}
+		TEST_METHOD(HurtSucceedsWhenAlive){
+			MonsterData testMonsterData{"TestName","Test Monster",3000,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+			Monster&m{game->SpawnMonster({},testMonsterData)};
+			m.Hurt(50,m.OnUpperLevel(),m.GetZ());
+			Assert::IsTrue(!m.IsDead(),L"Monster is considered alive.");
+			Assert::IsTrue(m.IsAlive(),L"Monster is considered alive.");
+
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ()),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::DOT),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::PLAYER_ABILITY),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+			Assert::IsTrue(m._DealTrueDamage(50),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+			Assert::IsTrue(m._DealTrueDamage(50,HurtFlag::DOT),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+			Assert::IsTrue(m._DealTrueDamage(50,HurtFlag::PLAYER_ABILITY),L"When hurting a monster that is alive, it should take damage and should be triggering like normal.");
+		}
+		TEST_METHOD(HurtSucceedsWhenDyingWithExactHealth){
+			MonsterData testMonsterData{"TestName","Test Monster",50,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
+			Monster&m{game->SpawnMonster({},testMonsterData)};
+			m.Hurt(50,m.OnUpperLevel(),m.GetZ());
+			Assert::IsTrue(m.IsDead(),L"Monster is considered dead.");
+			Assert::IsTrue(!m.IsAlive(),L"Monster is considered dead.");
+			m.Heal(50);
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ()),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+			m.Heal(50);
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::DOT),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+			m.Heal(50);
+			Assert::IsTrue(m.Hurt(50,m.OnUpperLevel(),m.GetZ(),HurtFlag::PLAYER_ABILITY),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+			m.Heal(50);
+			Assert::IsTrue(m._DealTrueDamage(50),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+			m.Heal(50);
+			Assert::IsTrue(m._DealTrueDamage(50,HurtFlag::DOT),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+			m.Heal(50);
+			Assert::IsTrue(m._DealTrueDamage(50,HurtFlag::PLAYER_ABILITY),L"When hurting a monster that was alive and takes enough damage to die, it should still take damage and should be triggering like normal.");
+		}
+		TEST_METHOD(UnconsciousMonsterTest){
+			Monster&parrot{game->SpawnMonster({},MONSTER_DATA.at("Parrot"))};
+			Game::Update(1.f);
+			Assert::IsFalse(parrot.IsUnconscious(),L"Parrot should not be immediately unconscious.");
+			parrot.Hurt(1,parrot.OnUpperLevel(),parrot.GetZ());
+			Assert::IsFalse(parrot.IsUnconscious(),L"Parrot should not be unconscious after taking 1 damage.");
+			parrot.Hurt(parrot.GetMaxHealth(),parrot.OnUpperLevel(),parrot.GetZ());
+			Assert::IsTrue(parrot.IsUnconscious(),L"Parrot should now be unconscious.");
+			Assert::IsTrue(parrot.IsDead(),L"Parrot is considered dead.");
+			Assert::IsTrue(parrot.InUndamageableState(parrot.OnUpperLevel(),parrot.GetZ()),L"Parrot should be in an undamageable state. Hopefully for obvious reasons.");
+			Game::Update(MONSTER_DATA.at("Parrot").UnconsciousTime()/2);
+			Assert::IsTrue(parrot.IsUnconscious(),L"Parrot should still be unconscious.");
+			Assert::IsTrue(parrot.IsDead(),L"Parrot should still be considered dead.");
+			Assert::IsTrue(parrot.InUndamageableState(parrot.OnUpperLevel(),parrot.GetZ()),L"Parrot should still be in an undamageable state.");
+			Game::Update(MONSTER_DATA.at("Parrot").UnconsciousTime()/2);
+			Assert::IsTrue(!parrot.IsUnconscious(),L"Parrot should no longer be unconscious.");
+			Assert::IsTrue(parrot.IsAlive(),L"Parrot should be alive.");
+			Assert::IsTrue(!parrot.InUndamageableState(parrot.OnUpperLevel(),parrot.GetZ()),L"Parrot should not be in an undamageable state.");
+		}
+		TEST_METHOD(UnconsciousMonsterHurtTest){
+			Monster&parrot{game->SpawnMonster({},MONSTER_DATA.at("Parrot"))};
+			Game::Update(1.f);
+			parrot.Hurt(parrot.GetMaxHealth(),parrot.OnUpperLevel(),parrot.GetZ());
+			Assert::IsTrue(parrot.IsUnconscious(),L"Parrot should now be unconscious.");
+		}
+		TEST_METHOD(MonsterCollisionRadiusTest){
+			Monster&parrot{game->SpawnMonster({},MONSTER_DATA.at("Parrot"))};
+			Game::Update(1.f);
+			Game::Update(1.f);
+			Assert::AreEqual(parrot.GetOriginalCollisionRadius(),parrot.GetCollisionRadius(),L"Parrot collision radius should be normal.");
+
+			Assert::AreEqual(int(game->GetPlayer()->GetMaxHealth()-parrot.GetCollisionDamage()),game->GetPlayer()->GetHealth(),L"Player should take collision damage from the parrot.");
+			parrot.SetCollisionRadius(0.f);
+			Assert::AreEqual(0.f,parrot.GetCollisionRadius(),L"Parrot collision radius should now be zero.");
+			game->GetPlayer()->Heal(game->GetPlayer()->GetMaxHealth());
+			game->GetPlayer()->_SetIframes(0.f);
+			parrot.SetPos({});
+			game->GetPlayer()->ForceSetPos({});
+			Game::Update(1.f);
+			Assert::AreEqual(game->GetPlayer()->GetMaxHealth(),game->GetPlayer()->GetHealth(),L"Player should be full health.");
+			parrot.SetCollisionRadius(parrot.GetOriginalCollisionRadius());
+			Game::Update(1.f);
+			Assert::AreEqual(int(game->GetPlayer()->GetMaxHealth()-parrot.GetCollisionDamage()),game->GetPlayer()->GetHealth(),L"Player should take collision damage from the parrot.");
+		}
+		TEST_METHOD(MonsterCollisionRadiusSizeTest){
+			Monster&parrot{game->SpawnMonster({},MONSTER_DATA.at("Parrot"))};
+		}
 	};
 }

Adventures in Lestoria Tests/PlayerTests.cpp

@@ -43,6 +43,7 @@ All rights reserved.
 #include "ItemDrop.h"
 #include "DamageNumber.h"
 #include <ranges>
+#include "GameHelper.h"
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 using namespace olc::utils;
@@ -88,6 +89,7 @@ namespace PlayerTests
 				MonsterData testMonsterData{"TestName","Test Monster",1000,10,5,{MonsterDropData{"Health Potion",100.f,1,1}},200.f};
 				MONSTER_DATA["TestName"]=testMonsterData;
 			#pragma endregion
+			testGame->ResetLevelStates();
 
 			player=testGame->GetPlayer();
 			//Setup key "0" as a test input
@@ -102,6 +104,7 @@ namespace PlayerTests
 		TEST_METHOD_CLEANUP(CleanupTests){
 			testGame->EndGame();
 			testGame->OnUserUpdate(0.f);
+			testGame.reset();
 		}
 		TEST_METHOD(PlayerAlive){
 			Assert::IsTrue(player->IsAlive());
@@ -319,11 +322,11 @@ namespace PlayerTests
 			Assert::AreEqual(1000+player->GetBaseStat("Health"),float(player->GetMaxHealth()),L"Max Health stat should be increased from 100 to 1100.");
 		}
 		TEST_METHOD(HealthStatUpBuffCheck){
-			player->AddBuff(BuffType::STAT_UP,5.f,1000.f,{"Health"});
+			Game::AddBuffToPlayer(BuffType::STAT_UP,5.f,1000.f,{"Health"});
 			Assert::AreEqual(1000+player->GetBaseStat("Health"),float(player->GetMaxHealth()),L"Max Health stat should be increased from 100 to 1100.");
 		}
 		TEST_METHOD(HealthPctStatUpBuffCheck){
-			player->AddBuff(BuffType::STAT_UP,5.f,1000.0_Pct,{"Health %"});
+			Game::AddBuffToPlayer(BuffType::STAT_UP,5.f,1000.0_Pct,{"Health %"});
 			Assert::AreEqual(1000+player->GetBaseStat("Health"),float(player->GetMaxHealth()),L"Max Health stat should be increased from 100 to 1100.");
 		}
 		TEST_METHOD(IllegalCritRateStatUpBuffCheck){
@@ -591,6 +594,7 @@ namespace PlayerTests
 			Assert::AreEqual(0.f,player->GetAttackRecoveryRateReduction(),L"Attack rate cooldown starts with being reduced by 0 seconds.");
 			testKey->bHeld=true; //Force the key to be held down for testing purposes.
 			player->CheckAndPerformAbility(player->GetAbility3(),testKeyboardInput);
+			Game::Update(0.f);
 			Assert::IsTrue(player->GetBuffs(BuffType::ADRENALINE_RUSH).size()>0,L"After using Adrenaline Rush, player has the Adrenaline Rush buff.");
 			Assert::AreEqual(1.1f,player->GetMoveSpdMult(),L"Move Speed Multiplier increased by 10% to x1.1");
 			Assert::AreEqual(0.105f,player->GetAttackRecoveryRateReduction(),L"Attack Recovery Rate reduced by 30%, or 0.105s");
@@ -627,17 +631,17 @@ namespace PlayerTests
 		TEST_METHOD(HasEnchantCheck){
 			std::weak_ptr<Item>slimeKingRing{Inventory::AddItem("Ring of the Slime King"s)};
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING1);
-			slimeKingRing.lock()->EnchantItem("Emergency Recovery");
+			slimeKingRing.lock()->_EnchantItem("Emergency Recovery"sv);
 			Assert::IsTrue(player->HasEnchant("Emergency Recovery"));
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING2);
 			Assert::IsTrue(player->HasEnchant("Emergency Recovery"));
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING1);
-			slimeKingRing.lock()->EnchantItem("Reaper of Souls");
+			slimeKingRing.lock()->_EnchantItem("Reaper of Souls"sv);
 			Assert::IsTrue(player->HasEnchant("Reaper of Souls"));
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING2);
 			Assert::IsTrue(player->HasEnchant("Reaper of Souls"));
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING1);
-			slimeKingRing.lock()->EnchantItem("Attack Boost");
+			slimeKingRing.lock()->_EnchantItem("Attack Boost"sv);
 			Assert::IsTrue(player->HasEnchant("Attack Boost"));
 			Inventory::EquipItem(slimeKingRing,EquipSlot::RING2);
 			Assert::IsTrue(player->HasEnchant("Attack Boost"));
@@ -656,18 +660,18 @@ namespace PlayerTests
 			Inventory::EquipItem(leatherShoes,EquipSlot::SHOES);
 			Inventory::EquipItem(woodenSword,EquipSlot::WEAPON);
 
-			leatherHelmet.lock()->EnchantItem("Wizard's Soul");
+			leatherHelmet.lock()->_EnchantItem("Wizard's Soul"sv);
 			Assert::IsTrue(player->HasEnchant("Wizard's Soul"));
-			leatherArmor.lock()->EnchantItem("Ability Haste");
+			leatherArmor.lock()->_EnchantItem("Ability Haste"sv);
 			Assert::IsTrue(player->HasEnchant("Ability Haste"));
-			leatherPants.lock()->EnchantItem("Improved Ground Slam");
+			leatherPants.lock()->_EnchantItem("Improved Ground Slam"sv);
 			Assert::IsTrue(player->HasEnchant("Improved Ground Slam"));
-			leatherGloves.lock()->EnchantItem("Battle Shout");
+			leatherGloves.lock()->_EnchantItem("Battle Shout"sv);
 			Assert::IsTrue(player->HasEnchant("Battle Shout")); 
-			leatherShoes.lock()->EnchantItem("Attack Boost");
+			leatherShoes.lock()->_EnchantItem("Attack Boost"sv);
 			Inventory::UnequipItem(EquipSlot::RING2);
 			Assert::IsTrue(player->HasEnchant("Attack Boost"));
-			woodenSword.lock()->EnchantItem("Mana Pool");
+			woodenSword.lock()->_EnchantItem("Mana Pool"sv);
 			Assert::IsTrue(player->HasEnchant("Mana Pool"));
 			
 			Inventory::UnequipItem(EquipSlot::HELMET);
@@ -742,12 +746,58 @@ namespace PlayerTests
 			player->GetAbility3().cooldown=player->GetAbility3().GetCooldownTime();
 			std::weak_ptr<Item>nullRing{Inventory::AddItem("Null Ring"s)};
 			Inventory::EquipItem(nullRing,EquipSlot::RING1);
-			nullRing.lock()->EnchantItem("Multi-Multishot");
+			nullRing.lock()->_EnchantItem("Multi-Multishot"sv);
 			testKey->bHeld=true; //Force the key to be held down for testing purposes.
 			Assert::AreEqual(player->GetAbility3().GetCooldownTime(),oldCooldownTime-oldCooldownTime*"Multi-Multishot"_ENC["COOLDOWN REDUCTION PCT"]/100.f,L"Old cooldown time with multishot cooldown reduction pct matches.");
 			testGame->SetElapsedTime(0.f);
 			testGame->OnUserUpdate(0.f);
 			Assert::AreEqual(player->GetAbility3().GetCooldownTime(),player->GetAbility3().cooldown,L"Cooldown now matches the new reduced amount.");
 		}
+		TEST_METHOD(PlayerGetShieldCheck){
+			player=testGame->GetPlayer();
+			Assert::AreEqual(0U,player->GetShield(),L"Player should have no shields at first.");
+		}
+		TEST_METHOD(PlayerAddShieldCheck){
+			player=testGame->GetPlayer();
+			player->AddShield(60U,5.f,PlayerTimerType::ADVANCE_SHIELD_TIMER);
+			Assert::AreEqual(60U,player->GetShield(),L"Player has 60 shield points.");
+			testGame->SetElapsedTime(5.f);
+			testGame->OnUserUpdate(5.f);
+			Assert::AreEqual(0U,player->GetShield(),L"Player should lose the shield after 5 seconds.");
+		}
+		TEST_METHOD(PlayerMultiShieldCheck){
+			player=testGame->GetPlayer();
+			player->AddShield(60U,5.f,PlayerTimerType::ADVANCE_SHIELD_TIMER);
+			player->AddShield(100U,2.f,PlayerTimerType::PLAYER_OUTLINE_TIMER);
+			Assert::AreEqual(160U,player->GetShield(),L"Player has 160 shield points.");
+			testGame->SetElapsedTime(2.f);
+			testGame->OnUserUpdate(2.f);
+			Assert::AreEqual(60U,player->GetShield(),L"Player has 60 shield points.");
+			testGame->SetElapsedTime(3.f);
+			testGame->OnUserUpdate(3.f);
+			Assert::AreEqual(0U,player->GetShield(),L"Player should lose the shield after 5 seconds.");
+		}
+		TEST_METHOD(PlayerSubtractShieldCheck){
+			player=testGame->GetPlayer();
+			player->AddShield(60U,5.f,PlayerTimerType::ADVANCE_SHIELD_TIMER);
+			Assert::AreEqual(60U,player->GetShield(),L"Player has 60 shield points.");
+			player->SubtractShield(40U);
+			Assert::AreEqual(20U,player->GetShield(),L"Player has 20 shield points.");
+			player->SubtractShield(200U);
+			Assert::AreEqual(0U,player->GetShield(),L"Player should have 0 shield points.");
+		}
+		TEST_METHOD(PlayerDamageShieldCheck){
+			player=testGame->GetPlayer();
+			player->AddShield(60U,5.f,PlayerTimerType::ADVANCE_SHIELD_TIMER);
+			Assert::AreEqual(60U,player->GetShield(),L"Player has 60 shield points.");
+			player->Hurt(20U,player->OnUpperLevel(),player->GetZ());
+			Assert::AreEqual(40U,player->GetShield(),L"Player has 40 shield points.");
+			Assert::AreEqual(player->GetMaxHealth(),player->GetHealth(),L"Player should still be full health.");
+			player->Hurt(200U,player->OnUpperLevel(),player->GetZ());
+			Assert::AreEqual(0U,player->GetShield(),L"Player has 0 shield points.");
+			Assert::AreEqual(player->GetMaxHealth(),player->GetHealth(),L"Player should still be full health.");
+			player->Hurt(10U,player->OnUpperLevel(),player->GetZ());
+			Assert::AreEqual(player->GetMaxHealth()-10,player->GetHealth(),L"Player now takes damage with 0 shield.");
+		}
 	};
 }

Adventures in Lestoria/Ability.cpp

@@ -57,3 +57,7 @@ Ability::Ability(std::string name,std::string shortName,std::string description,
 const float Ability::GetCooldownTime()const{
 	return COOLDOWN_TIME;
 }
+
+const bool Ability::operator==(const Ability&a)const{
+	return name==a.name&&isOriginalAbility==a.isOriginalAbility;
+}

Adventures in Lestoria/Ability.h

@@ -76,12 +76,14 @@ struct Ability{
 	bool actionPerformedDuringCast=false;
 	bool waitForRelease=false;
 	bool keyReleaseRequiredToReactivate{false}; //When the player presses an ability, they cannot use it again until they have released the key to press it down again. So this gets set to true everytime an ability activates, and set to false once the player releases that key.
+	bool isOriginalAbility{false};
 	//Ability action function, returns true if the ability can be casted, otherwise returns false.
 	//	Argument 1: Player* - player pointer
 	//  Argument 2: vf2d - The returned precast target position (if the ability needs to be aimed, otherwise {})
 	std::function<bool(Player*,vf2d)>action=[](Player*,vf2d){return false;};
 	static InputGroup DEFAULT;
 	const float GetCooldownTime()const;
+	const bool operator==(const Ability&a)const;
 	Ability();
 	//NOTE: icon expects the actual name relative to the "Ability Icons" directory for this constructor!
 	Ability(std::string name,std::string shortName,std::string description,float cooldownTime,int manaCost,InputGroup*input,std::string icon,Pixel barColor1=VERY_DARK_RED,Pixel barColor2=DARK_RED,PrecastData precastInfo={},bool canCancelCast=false);

Adventures in Lestoria/Adventures in Lestoria.tiled-project

@@ -29,6 +29,24 @@
                 "object"
             ]
         },
+        {
+            "id": 43,
+            "name": "AudioEvent",
+            "storageType": "string",
+            "type": "enum",
+            "values": [
+                "LowHealth",
+                "TitleScreenLoaded",
+                "BlacksmithUnlock",
+                "Chapter2Unlock",
+                "Chapter3Unlock",
+                "BossFanfare",
+                "BossDefeated",
+                "PreBossPhase",
+                "Default Volume"
+            ],
+            "valuesAsFlags": false
+        },
         {
             "id": 30,
             "name": "Backdrop",
@@ -53,7 +71,10 @@
                 "overworld",
                 "foresty_boss",
                 "base_camp",
-                "mountain"
+                "mountain",
+                "mountain_boss",
+                "beach",
+                "beach_boss"
             ],
             "valuesAsFlags": false
         },
@@ -176,7 +197,11 @@
                 "Birds2",
                 "Birds3",
                 "Birds4",
-                "Campfire"
+                "Campfire",
+                "Crashing Waves",
+                "Gull1",
+                "Gull2",
+                "Gull3"
             ],
             "valuesAsFlags": false
         },
@@ -280,14 +305,18 @@
                 "CAMPAIGN_3_6",
                 "CAMPAIGN_3_7",
                 "CAMPAIGN_3_8",
-                "CAMPAIGN_3_B1"
+                "CAMPAIGN_3_B1",
+                "BOSS_3",
+                "BOSS_3_B",
+                "STORY_3_1",
+                "STORY_3_2"
             ],
             "valuesAsFlags": false
         },
         {
             "id": 25,
             "name": "LevelType",
-            "storageType": "string",
+            "storageType": "int",
             "type": "enum",
             "values": [
                 "Dungeon",
@@ -330,6 +359,12 @@
             "drawFill": true,
             "id": 19,
             "members": [
+                {
+                    "name": "Audio Event",
+                    "propertyType": "AudioEvent",
+                    "type": "string",
+                    "value": "Default Volume"
+                },
                 {
                     "name": "Backdrop",
                     "propertyType": "Backdrop",
@@ -380,8 +415,8 @@
                 {
                     "name": "Level Type",
                     "propertyType": "LevelType",
-                    "type": "string",
-                    "value": "World Map"
+                    "type": "int",
+                    "value": 4
                 },
                 {
                     "name": "Optimize",

Adventures in Lestoria/Adventures in Lestoria.vcxproj

@@ -130,6 +130,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Desktop|x64'">
     <OutDir>$(SolutionDir)$(PlatformTarget)\Release</OutDir>
+    <CodeAnalysisRuleSet>..\CodeAnalysisRuleset.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <IncludePath>$(IncludePath)</IncludePath>
@@ -140,11 +141,19 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <IncludePath>$(VCInstallDir)Auxiliary\VS\UnitTest\include;$(IncludePath)</IncludePath>
     <LibraryPath>$(VCInstallDir)Auxiliary\VS\UnitTest\lib;$(LibraryPath)</LibraryPath>
+    <CodeAnalysisRuleSet>..\CodeAnalysisRuleset.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Unit Testing|x64'">
     <IncludePath>$(VCInstallDir)Auxiliary\VS\UnitTest\include;$(IncludePath)</IncludePath>
     <LibraryPath>$(VCInstallDir)Auxiliary\VS\UnitTest\lib;$(LibraryPath)</LibraryPath>
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <CodeAnalysisRuleSet>..\CodeAnalysisRuleset.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Emscripten|x64'">
+    <CodeAnalysisRuleSet>..\CodeAnalysisRuleset.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Emscripten Debug|x64'">
+    <CodeAnalysisRuleSet>..\CodeAnalysisRuleset.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -218,7 +227,7 @@
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
-      <AdditionalIncludeDirectories>C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;$(ProjectDir)steam;$(ProjectDir)discord-files;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <TreatSpecificWarningsAsErrors>4099;5030;4715;4172;4834</TreatSpecificWarningsAsErrors>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
@@ -242,8 +251,8 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <LanguageStandard>stdcpp20</LanguageStandard>
-      <AdditionalIncludeDirectories>C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>$(ProjectDir)steam;$(ProjectDir)discord-files;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <TreatSpecificWarningsAsErrors>4099;5030;4715;4172;4834</TreatSpecificWarningsAsErrors>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
@@ -273,7 +282,7 @@
       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
-      <AdditionalIncludeDirectories>C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;$(ProjectDir)steam;$(ProjectDir)discord-files;C:\Users\LabUser\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\LabUser\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\niconiconii\OneDrive\Documents\include;C:\Users\niconiconii\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\steam;C:\Users\sigon\source\repos\AdventuresInLestoria\Adventures in Lestoria\discord-files;C:\Users\sigon\OneDrive\Documents\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
     </ClCompile>
     <Link>
@@ -365,6 +374,10 @@
     <ClInclude Include="Ability.h" />
     <ClInclude Include="AccessoryRowItemDisplay.h" />
     <ClInclude Include="Animation.h" />
+    <ClInclude Include="Arc.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="Attributable.h" />
     <ClInclude Include="AttributableStat.h">
       <SubType>
@@ -378,6 +391,10 @@
       <SubType>
       </SubType>
     </ClInclude>
+    <ClInclude Include="BlackHole.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="BombBoom.h">
       <SubType>
       </SubType>
@@ -387,6 +404,14 @@
       <SubType>
       </SubType>
     </ClInclude>
+    <ClInclude Include="DynamicMenuLabel.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
+    <ClInclude Include="Entity.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="HurtDamageInfo.h">
       <SubType>
       </SubType>
@@ -508,12 +533,20 @@
       <SubType>
       </SubType>
     </ClInclude>
+    <ClInclude Include="MenuDecal.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="MenuDefinitions.h" />
     <ClInclude Include="MenuItemLabel.h">
       <SubType>
       </SubType>
     </ClInclude>
     <ClInclude Include="MenuItemLoadoutButton.h" />
+    <ClInclude Include="MenuRefineLabel.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="MenuType.h">
       <SubType>
       </SubType>
@@ -524,6 +557,10 @@
     </ClInclude>
     <ClInclude Include="MonsterData.h" />
     <ClInclude Include="olcPGEX_SplashScreen.h" />
+    <ClInclude Include="Oscillator.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="Overlay.h">
       <SubType>
       </SubType>
@@ -713,6 +750,10 @@
       <SubType>
       </SubType>
     </ClInclude>
+    <ClInclude Include="TrailEffect.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
     <ClInclude Include="Tutorial.h" />
     <ClInclude Include="VisualNovel.h" />
     <ClInclude Include="Test.h" />
@@ -731,11 +772,11 @@
   <ItemGroup>
     <ClCompile Include="Ability.cpp" />
     <ClCompile Include="Animation.cpp" />
-    <ClCompile Include="Arrow.cpp" />
-    <ClCompile Include="ArtificerDisassembleConfirmWindow.cpp">
+    <ClCompile Include="Arc.cpp">
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="Arrow.cpp" />
     <ClCompile Include="ArtificerDisassembleWindow.cpp">
       <SubType>
       </SubType>
@@ -748,7 +789,7 @@
       <SubType>
       </SubType>
     </ClCompile>
-    <ClCompile Include="ArtificerRefineConfirmWindow.cpp">
+    <ClCompile Include="ArtificerRefineResultWindow.cpp">
       <SubType>
       </SubType>
     </ClCompile>
@@ -797,10 +838,41 @@
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="BurstBullet.cpp" />
+    <ClCompile Include="Crab.cpp" />
+    <ClCompile Include="Entity.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="ExplosiveTrap.cpp">
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="FadeInOutEffect.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="GhostSaber.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="GhostOfPirateCaptain.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="GiantCrab.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="GiantOctopus.cpp" />
+    <ClCompile Include="HomingBullet.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="HubPauseMenu.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="IBullet.cpp" />
     <ClCompile Include="BuyItemWindow.cpp">
       <SubType>
@@ -923,6 +995,14 @@
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="Ink.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="InkBullet.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="InputHelper.cpp">
       <SubType>
       </SubType>
@@ -954,7 +1034,15 @@
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="ItemHubLoadout.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="ItemLoadoutWindow.cpp" />
+    <ClCompile Include="ItemScript.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="Key.cpp" />
     <ClCompile Include="LargeStone.cpp" />
     <ClCompile Include="LargeTornado.cpp">
@@ -1010,6 +1098,7 @@
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="OctopusArm.cpp" />
     <ClCompile Include="Overlay.cpp">
       <SubType>
       </SubType>
@@ -1020,15 +1109,35 @@
       </SubType>
     </ClCompile>
     <ClCompile Include="packkey.cpp" />
+    <ClCompile Include="Parrot.cpp" />
     <ClCompile Include="PauseMenu.cpp">
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="PiratesTreasure.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="Pirate_Buccaneer.cpp" />
+    <ClCompile Include="Pirate_Captain.cpp" />
+    <ClCompile Include="Pirate_Marauder.cpp" />
     <ClCompile Include="Pixel.cpp" />
     <ClCompile Include="PoisonBottle.cpp">
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="RotateBullet.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="ThrownProjectile.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
+    <ClCompile Include="PoisonPool.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
     <ClCompile Include="PurpleEnergyBall.cpp">
       <SubType>
       </SubType>
@@ -1047,6 +1156,7 @@
     <ClCompile Include="PulsatingFire.cpp" />
     <ClCompile Include="Ranger.cpp" />
     <ClCompile Include="RUN_STRATEGY.cpp" />
+    <ClCompile Include="Sandworm.cpp" />
     <ClCompile Include="SaveFile.cpp">
       <SubType>
       </SubType>
@@ -1055,6 +1165,7 @@
       <SubType>
       </SubType>
     </ClCompile>
+    <ClCompile Include="Seagull.cpp" />
     <ClCompile Include="SellItemWindow.cpp">
       <SubType>
       </SubType>
@@ -1078,7 +1189,7 @@
       <SubType>
       </SubType>
     </ClCompile>
-    <ClCompile Include="FallingStone.cpp">
+    <ClCompile Include="FallingBullet.cpp">
       <SubType>
       </SubType>
     </ClCompile>
@@ -1164,7 +1275,23 @@
     <ClCompile Include="Zephy.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <None Include="..\commit.bat" />
+    <None Include="..\debug.sh" />
+    <None Include="..\debugGame.sh" />
+    <None Include="..\distribute.ps1" />
+    <None Include="..\distribute.sh" />
+    <None Include="..\emscripten_build.ps1" />
+    <None Include="..\emscripten_build.sh" />
+    <None Include="..\emscripten_debug_build.ps1" />
+    <None Include="..\emscripten_debug_build.sh" />
+    <None Include="..\emscripten_run.ps1" />
+    <None Include="..\emscripten_run.sh" />
     <None Include="..\read_debug_log.ps1" />
+    <None Include="..\release.sh" />
+    <None Include="..\runGame - NO STEAM.bat" />
+    <None Include="..\runGame.bat" />
+    <None Include="..\runGame.sh" />
+    <None Include="..\unit-testing-prebuild.ps1" />
     <None Include="ClassDiagram.cd" />
     <None Include="ClassDiagram2.cd" />
     <None Include="cpp.hint" />
@@ -1172,6 +1299,7 @@
     <None Include="steam\steam_api.json" />
   </ItemGroup>
   <ItemGroup>
+    <Text Include="..\x64\Unit Testing\debug.log" />
     <Text Include="assets\config\Achievements.txt" />
     <Text Include="assets\config\audio\audio.txt" />
     <Text Include="assets\config\audio\bgm.txt" />
@@ -1222,6 +1350,7 @@
     <Text Include="Chapter_1_Creatures_Part_2.txt" />
     <Text Include="Chapter_2_Boss.txt" />
     <Text Include="Chapter_2_Monsters.txt" />
+    <Text Include="Chapter_3_FinalBoss.txt" />
     <Text Include="Chapter_3_Monsters.txt" />
     <Text Include="characters.txt" />
     <Text Include="ConsoleCommands.txt" />
@@ -1233,6 +1362,7 @@
     <Text Include="Merchant%27s Items.txt" />
     <Text Include="NewClasses.txt" />
     <Text Include="InitialConcept.txt" />
+    <Text Include="Oktopus boss.txt" />
     <Text Include="Slime_King_Encounter.txt" />
     <Text Include="StatCalculations.txt" />
     <Text Include="TODO.txt" />

Adventures in Lestoria/Adventures in Lestoria.vcxproj.filters

@@ -100,6 +100,12 @@
     <Filter Include="Documentation\Admin">
       <UniqueIdentifier>{e565fb16-43e6-4d18-a450-af7474df70b9}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Scripts">
+      <UniqueIdentifier>{eba9dd86-1d5d-4c68-8dcb-760c759099c0}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Debug">
+      <UniqueIdentifier>{c4119802-3fc8-4555-9013-a7a3ac9b204d}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="olcPixelGameEngine.h">
@@ -684,6 +690,30 @@
     <ClInclude Include="Timer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="BlackHole.h">
+      <Filter>Source Files\Effects</Filter>
+    </ClInclude>
+    <ClInclude Include="TrailEffect.h">
+      <Filter>Source Files\Effects</Filter>
+    </ClInclude>
+    <ClInclude Include="Oscillator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="MenuDecal.h">
+      <Filter>Header Files\Interface</Filter>
+    </ClInclude>
+    <ClInclude Include="MenuRefineLabel.h">
+      <Filter>Header Files\Interface</Filter>
+    </ClInclude>
+    <ClInclude Include="DynamicMenuLabel.h">
+      <Filter>Header Files\Interface</Filter>
+    </ClInclude>
+    <ClInclude Include="Arc.h">
+      <Filter>Header Files\Utils</Filter>
+    </ClInclude>
+    <ClInclude Include="Entity.h">
+      <Filter>Header Files\Utils</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Player.cpp">
@@ -1142,7 +1172,7 @@
     <ClCompile Include="RockLaunch.cpp">
       <Filter>Source Files\Effects</Filter>
     </ClCompile>
-    <ClCompile Include="FallingStone.cpp">
+    <ClCompile Include="FallingBullet.cpp">
       <Filter>Source Files\Bullet Types</Filter>
     </ClCompile>
     <ClCompile Include="ShineEffect.cpp">
@@ -1166,7 +1196,7 @@
     <ClCompile Include="PurpleEnergyBall.cpp">
       <Filter>Source Files\Bullet Types</Filter>
     </ClCompile>
-    <ClCompile Include="PoisonBottle.cpp">
+    <ClCompile Include="ThrownProjectile.cpp">
       <Filter>Source Files\Bullet Types</Filter>
     </ClCompile>
     <ClCompile Include="State_Dialog.cpp">
@@ -1178,15 +1208,9 @@
     <ClCompile Include="ArtificerRefineWindow.cpp">
       <Filter>Source Files\Interface</Filter>
     </ClCompile>
-    <ClCompile Include="ArtificerRefineConfirmWindow.cpp">
-      <Filter>Source Files\Interface</Filter>
-    </ClCompile>
     <ClCompile Include="ArtificerDisassembleWindow.cpp">
       <Filter>Source Files\Interface</Filter>
     </ClCompile>
-    <ClCompile Include="ArtificerDisassembleConfirmWindow.cpp">
-      <Filter>Source Files\Interface</Filter>
-    </ClCompile>
     <ClCompile Include="ArtificerEnchantWindow.cpp">
       <Filter>Source Files\Interface</Filter>
     </ClCompile>
@@ -1202,6 +1226,87 @@
     <ClCompile Include="Timer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="FadeInOutEffect.cpp">
+      <Filter>Source Files\Effects</Filter>
+    </ClCompile>
+    <ClCompile Include="PoisonPool.cpp">
+      <Filter>Source Files\Effects</Filter>
+    </ClCompile>
+    <ClCompile Include="ArtificerRefineResultWindow.cpp">
+      <Filter>Source Files\Interface</Filter>
+    </ClCompile>
+    <ClCompile Include="Pirate_Marauder.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Crab.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Parrot.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Pirate_Buccaneer.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Pirate_Captain.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Sandworm.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Seagull.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="GiantCrab.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="ItemScript.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="PoisonBottle.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="GiantOctopus.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="OctopusArm.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="Arc.cpp">
+      <Filter>Source Files\Utils</Filter>
+    </ClCompile>
+    <ClCompile Include="BurstBullet.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Entity.cpp">
+      <Filter>Source Files\Utils</Filter>
+    </ClCompile>
+    <ClCompile Include="RotateBullet.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="InkBullet.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Ink.cpp">
+      <Filter>Source Files\Effects</Filter>
+    </ClCompile>
+    <ClCompile Include="HomingBullet.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="HubPauseMenu.cpp">
+      <Filter>Source Files\Interface</Filter>
+    </ClCompile>
+    <ClCompile Include="ItemHubLoadout.cpp">
+      <Filter>Source Files\Interface</Filter>
+    </ClCompile>
+    <ClCompile Include="GhostOfPirateCaptain.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
+    <ClCompile Include="GhostSaber.cpp">
+      <Filter>Source Files\Bullet Types</Filter>
+    </ClCompile>
+    <ClCompile Include="PiratesTreasure.cpp">
+      <Filter>Source Files\Monster Strategies</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="cpp.hint" />
@@ -1214,6 +1319,54 @@
       <Filter>Header Files\steam</Filter>
     </None>
     <None Include="..\read_debug_log.ps1" />
+    <None Include="..\commit.bat">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\debug.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\debugGame.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\distribute.ps1">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\distribute.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_build.ps1">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_build.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_debug_build.ps1">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_debug_build.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_run.ps1">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\emscripten_run.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\release.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\runGame - NO STEAM.bat">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\runGame.bat">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\runGame.sh">
+      <Filter>Scripts</Filter>
+    </None>
+    <None Include="..\unit-testing-prebuild.ps1">
+      <Filter>Scripts</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="InitialConcept.txt">
@@ -1406,6 +1559,15 @@
     <Text Include="ConsoleCommands.txt">
       <Filter>Documentation\Admin</Filter>
     </Text>
+    <Text Include="..\x64\Unit Testing\debug.log">
+      <Filter>Debug</Filter>
+    </Text>
+    <Text Include="Oktopus boss.txt">
+      <Filter>Documentation\Mechanics</Filter>
+    </Text>
+    <Text Include="Chapter_3_FinalBoss.txt">
+      <Filter>Documentation\Mechanics</Filter>
+    </Text>
   </ItemGroup>
   <ItemGroup>
     <Image Include="assets\heart.ico">

Adventures in Lestoria/AdventuresInLestoria.h

@@ -60,6 +60,12 @@ All rights reserved.
 #include "Overlay.h"
 #include <variant>
 
+#undef KEY_MENU
+#undef KEY_SELECT
+#undef KEY_SCROLLDOWN
+#undef KEY_SCROLLUP
+#undef KEY_ENTER
+
 class SteamKeyboardCallbackHandler;
 class SteamStatsReceivedHandler;
 
@@ -70,14 +76,12 @@ INCLUDE_BULLET_LIST
 #define EndBullet )).get()))
 
 using HurtReturnValue=bool;
-using HurtList=std::vector<std::pair<std::variant<Monster*,Player*>,HurtReturnValue>>;
+using HurtListItem=std::pair<std::variant<Monster*,Player*>,HurtReturnValue>;
+using HurtList=std::vector<HurtListItem>;
 using StackCount=uint8_t;
 using MarkTime=float;
-
-enum class HurtType{
-	PLAYER=0b01,
-	MONSTER=0b10,
-};
+using ForegroundWrapper=std::reference_wrapper<Effect>;
+using BackgroundWrapper=std::reference_wrapper<Effect>;
 
 enum class KnockbackCondition{
 	KNOCKBACK_HURT_TARGETS, //Knockback only targets that took damage.
@@ -97,9 +101,23 @@ class AiL : public olc::PixelGameEngine
 	friend class sig::Animation;
 	friend class Audio;
 	friend class Minimap;
+	friend class MiniAudio;
+	friend class Arc;
 	std::unique_ptr<Player>player;
 	SplashScreen splash;
 public:
+	class Notification{
+		std::string message;
+		float time;
+		Pixel col;
+	public:
+		#undef GetMessage
+		Notification(const std::string_view message,const float time,const Pixel col);
+		void Update(const float fElapsedTime);
+		const bool Expired()const;
+		const bool operator==(const Notification&n)const;
+		void Draw(PixelGameEngine&pge);
+	};
 	enum MusicChange{
 		NO_MUSIC_CHANGE,
 		PLAY_LEVEL_MUSIC,
@@ -150,11 +168,11 @@ public:
 	double levelTime=0.;
 	Camera2D camera;
 	std::map<MapName,Map>MAP_DATA;
+
+	ResourcePack gamepack;
 private:
     std::vector<std::unique_ptr<Effect>>foregroundEffects,backgroundEffects,foregroundEffectsToBeInserted,backgroundEffectsToBeInserted;
 	std::vector<TileRenderData*>tilesWithCollision,tilesWithoutCollision;
-	std::vector<int>dropsBeforeLower,dropsAfterLower,dropsBeforeUpper,dropsAfterUpper;
-	std::vector<ZoneData>endZones,upperEndZones;
 	std::vector<vf2d>circleCooldownPoints;
 	std::vector<vf2d>squareCircleCooldownPoints;
 	std::map<std::string,TilesetData>MAP_TILESETS;
@@ -170,9 +188,6 @@ private:
 	int bridgeLayerIndex=-1;
 	float bridgeFadeFactor=0.f;
 	int DEBUG_PATHFINDING=0;
-	std::vector<Monster*>monstersBeforeLower,monstersAfterLower,monstersBeforeUpper,monstersAfterUpper;
-	std::vector<IBullet*>bulletsLower,bulletsUpper;
-	std::vector<Effect*>backgroundEffectsLower,backgroundEffectsUpper,foregroundEffectsLower,foregroundEffectsUpper;
 	float reflectionUpdateTimer=0;
 	float reflectionStepTime=0;
 	std::set<vi2d>visibleTiles;
@@ -196,13 +211,14 @@ private:
 	bool disableFadeIn=false;
 	DynamicCounter healthCounter;
 	DynamicCounter manaCounter;
+	DynamicCounter shieldCounter;
+	int playerShieldDisplayAmt{};
 	Pixel worldColor=WHITE;
 	std::function<Pixel(vi2d)>worldColorFunc=[](vi2d pos){return WHITE;};
 	std::map<std::string,std::vector<::ZoneData>>ZONE_LIST;
 	float lastMouseMovement=0.f; //Amount of time since the last time the cursor was moved or interacted with.
 	vi2d lastMousePos={};
 	bool gameInitialized=false;
-	ResourcePack gamepack;
 	uint8_t mosaicEffectTransition=1U;
 	float saveGameDisplayTime=0.f;
 	float loadingWaitTime=0.f;
@@ -234,6 +250,7 @@ private:
 	void AdminConsole();
 	virtual bool OnConsoleCommand(const std::string& sCommand)override final;
 	Pixel vignetteOverlayCol{"Interface.Vignette Color"_Pixel};
+	std::vector<Notification>notifications;
 public:
 	AiL(bool testingMode=false);
 	bool OnUserCreate() override;
@@ -258,9 +275,10 @@ public:
 	void RenderHud();
 	void RenderMenu();
 	bool MenuClicksDeactivated()const;
-	void AddEffect(std::unique_ptr<Effect>foreground,std::unique_ptr<Effect>background);
+	std::pair<ForegroundWrapper,BackgroundWrapper>AddEffect(std::unique_ptr<Effect>foreground,std::unique_ptr<Effect>background);
 	//If back is true, places the effect in the background
-	void AddEffect(std::unique_ptr<Effect>foreground,bool back=false);
+	Effect&AddEffect(std::unique_ptr<Effect>foreground,bool back=false);
+	const std::vector<Effect*>GetEffect(EffectType type);
 	const HurtList Hurt(vf2d pos,float radius,int damage,bool upperLevel,float z,const HurtType hurtTargets,HurtFlag::HurtFlag hurtFlags=HurtFlag::NONE)const;
 	const HurtList HurtMonsterType(vf2d pos,float radius,int damage,bool upperLevel,float z,const std::string_view monsterName,HurtFlag::HurtFlag hurtFlags=HurtFlag::NONE)const;
 	//NOTE: This function will also add any enemies that were hit into the hit list!
@@ -341,7 +359,7 @@ public:
 	int GetLoadoutSize()const;
 	void RestockLoadoutItems();
 	//Returns true if the item can be used (we have >0 of it)
-	bool UseLoadoutItem(int slot);
+	bool UseLoadoutItem(int slot,const std::optional<vf2d>targetingPos={});
 	//Blanks out this loadout item.
 	void ClearLoadoutItem(int slot);
 	void RenderFadeout();
@@ -393,6 +411,9 @@ public:
 	void InitializeClasses();
 	void _SetCurrentLevel(const MapName map); //NOTE: This will modify the currentLevel variable without triggering anything else in-game, this will normally mess up the state in the game. Ideally this is only used when initializing a test level.
 	void InitializeCamera();
+	void AddNotification(const Notification&n);
+
+	void ResetLevelStates();
 
 	std::vector<Effect*>GetForegroundEffects()const;
 	std::vector<Effect*>GetBackgroundEffects()const;

Adventures in Lestoria/Animation.cpp

@@ -48,7 +48,6 @@ INCLUDE_GFX
 
 void sig::Animation::InitializeAnimations(){
 	ANIMATION_DATA.Reset();
-
 	auto CreateStillAnimation=[&](std::string imgName,vf2d size,AnimationData data={}){
 		Animate2D::FrameSequence anim(data.frameDuration,data.style);
 		anim.AddFrame({&GFX[imgName],{{0,0},size}});
@@ -347,6 +346,28 @@ void sig::Animation::InitializeAnimations(){
 	ANIMATION_DATA["WITCH_TRANSFORM_W"]=pl_witch_transform_w;
 	ANIMATION_DATA["WITCH_TRANSFORM_E"]=pl_witch_transform_e;
 
+	
+	Animate2D::FrameSequence pl_witch_cat_walk_s(0.2f);
+	for(int i=0;i<2;i++){
+		pl_witch_cat_walk_s.AddFrame({&GFX["nico-witch.png"],{vi2d{0+i,4}*24,{24,24}}});
+	}
+	ANIMATION_DATA["WITCH_CAT_WALK_S"]=pl_witch_cat_walk_s;
+	Animate2D::FrameSequence pl_witch_cat_walk_n(0.2f);
+	for(int i=0;i<2;i++){
+		pl_witch_cat_walk_n.AddFrame({&GFX["nico-witch.png"],{vi2d{0+i,5}*24,{24,24}}});
+	}
+	ANIMATION_DATA["WITCH_CAT_WALK_N"]=pl_witch_cat_walk_n;
+	Animate2D::FrameSequence pl_witch_cat_walk_w(0.2f);
+	for(int i=0;i<2;i++){
+		pl_witch_cat_walk_w.AddFrame({&GFX["nico-witch.png"],{vi2d{0+i,6}*24,{24,24}}});
+	}
+	ANIMATION_DATA["WITCH_CAT_WALK_W"]=pl_witch_cat_walk_w;
+	Animate2D::FrameSequence pl_witch_cat_walk_e(0.2f);
+	for(int i=0;i<2;i++){
+		pl_witch_cat_walk_e.AddFrame({&GFX["nico-witch.png"],{vi2d{0+i,7}*24,{24,24}}});
+	}
+	ANIMATION_DATA["WITCH_CAT_WALK_E"]=pl_witch_cat_walk_e;
+
 	CreateHorizontalAnimationSequence("ground-slam-attack-back.png",5,{64,64},{0.02f,Animate2D::Style::OneShot});
 	CreateHorizontalAnimationSequence("ground-slam-attack-front.png",5,{64,64},{0.02f,Animate2D::Style::OneShot});
 	CreateHorizontalAnimationSequence("battlecry_effect.png",5,{84,84},{0.02f,Animate2D::Style::OneShot});
@@ -380,6 +401,9 @@ void sig::Animation::InitializeAnimations(){
 	CreateHorizontalAnimationSequence("bomb_boom.png",5,{36,36},AnimationData{.frameDuration{0.2f},.style{Animate2D::Style::OneShot}});
 	CreateHorizontalAnimationSequence("tornado2.png",4,{24,48},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::Repeat}});
 	CreateHorizontalAnimationSequence("large_tornado.png",4,{72,144},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::Repeat}});
+	CreateHorizontalAnimationSequence("sand_suction.png",4,{72,72},AnimationData{.frameDuration{0.2f},.style{Animate2D::Style::Repeat}});
+	CreateHorizontalAnimationSequence("bomb.png",4,{24,24},AnimationData{.frameDuration{0.2f},.style{Animate2D::Style::OneShot}});
+	CreateHorizontalAnimationSequence("ghost_dagger.png",3,{24,24},{0.1f,Animate2D::Style::PingPong});
 
 	CreateStillAnimation("meteor.png",{192,192});
 
@@ -412,6 +436,14 @@ void sig::Animation::InitializeAnimations(){
 		ANIMATION_DATA[std::format("GOBLIN_BOW_ATTACK_{}",animationIndex)]=mountShootAnimation;
 	}
 	
+	Animate2D::FrameSequence parrot_sit_n,parrot_sit_e,parrot_sit_s,parrot_sit_w;
+	//Idle sequences for the sitting parrot.
+	for(int animationIndex=0;animationIndex<4;animationIndex++){
+		Animate2D::FrameSequence mountAnimation{0.6f};
+		mountAnimation.AddFrame(Animate2D::Frame{&GFX["monsters/commercial_assets/Parrot_foreground.png"],{{0,animationIndex*48},{48,48}}});
+		ANIMATION_DATA[std::format("PARROT_MOUNTED_{}",animationIndex)]=mountAnimation;
+	}
+	
 	#pragma region Trapper Target Mark Debuff
 		AnimationData targetAnimData{.frameDuration{0.1f},.style{Animate2D::Style::Repeat}};
 		Animate2D::FrameSequence targetAnim(targetAnimData.frameDuration,targetAnimData.style);
@@ -430,7 +462,17 @@ void sig::Animation::InitializeAnimations(){
 	CreateHorizontalAnimationSequence("bear_trap.png",3,{24,24},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::PingPong}});
 	CreateHorizontalAnimationSequence("explosive_trap.png",4,{48,48},AnimationData{.frameDuration{0.06f},.style{Animate2D::Style::PingPong}});
 	CreateHorizontalAnimationSequence("explosionframes.png",21,{24,24},AnimationData{.frameDuration{0.02f},.style{Animate2D::Style::OneShot}});
+	CreateHorizontalAnimationSequence("fire_ring.png",5,{60,60},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::Repeat}});
+
+	CreateHorizontalAnimationSequence("portal.png",8,{24,24},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::Repeat}});
+
+	CreateHorizontalAnimationSequence("burstbullet.png",4,{24,24},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::OneShot}});
+	CreateHorizontalAnimationSequence("inkbubble_explode.png",4,{24,24},AnimationData{.frameDuration{0.1f},.style{Animate2D::Style::OneShot}});
 
+	//!!!!!WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	//DO NOT CREATE MORE ANIMATION SEQUENCES UNDERNEATH HERE AS THE NEXT BLOCK WILL CREATE DEFAULT ANIMATIONS
+	//FOR ALL NON-SPECIFIED ANIMATION SEQUENCES!
+	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 	for(auto&dat:GFX){
 		std::string imgFile=dat.first;
 		if(!ANIMATION_DATA.count(imgFile)){

Adventures in Lestoria/Arc.cpp

@@ -0,0 +1,79 @@
+#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 "Arc.h"
+#include "AdventuresInLestoria.h"
+
+INCLUDE_game
+
+Arc::Arc(const vf2d pos,const float radius,const float pointingAngle,const float sweepAngle)
+:pos(pos),radius(radius),pointingAngle(pointingAngle),sweepAngle(sweepAngle){
+	if(sweepAngle<0.f)ERR(std::format("WARNING! Sweep angle must be greater than or equal to 0! Provided Sweep Angle: {}",sweepAngle));
+	GenerateArc();
+}
+void Arc::Draw(AiL*game,const Pixel col){
+	game->SetDecalStructure(DecalStructure::FAN);
+	game->view.DrawPolygonDecal(nullptr,poly.pos,poly.pos,col);
+}
+const bool Arc::overlaps(const vf2d checkPos)const{
+	return geom2d::overlaps(checkPos,poly);
+}
+void Arc::GrowRadius(const float growAmt){
+	radius+=growAmt;
+	GenerateArc();
+}
+void Arc::GenerateArc(){
+	poly.pos.clear();
+	//Use cut-off point between two angles
+	poly.pos.emplace_back(pos); //Always add 0,0
+	float smallestAng{util::radToDeg(pointingAngle-sweepAngle)+90};
+	float largestAng{util::radToDeg(pointingAngle+sweepAngle)+90};
+	while(smallestAng<0.f)smallestAng+=360;
+	while(largestAng<0.f)largestAng+=360;
+	int startInd{int(std::fmod(smallestAng/4+1,90))};
+	int endInd{int(std::fmod(largestAng/4+1,90))};
+	if(startInd>endInd){
+		startInd=(startInd+3)%90;
+	}else{
+		endInd=(endInd+3)%90;
+	}
+	for(int i=startInd;i!=endInd;i=(i+1)%game->circleCooldownPoints.size()){
+		poly.pos.emplace_back(pos+game->circleCooldownPoints[i]*radius);
+	}
+	poly.pos.emplace_back(pos); //Connect back to itself.
+}

Adventures in Lestoria/Arc.h

@@ -0,0 +1,59 @@
+#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 "olcUTIL_Geometry2D.h"
+#include "Pixel.h"
+
+class AiL;
+
+class Arc{
+public:
+	//Define a sweep angle such that each direction will arc that way. Example: PI/2 means a sweep angle from -PI/2 to PI/2. MUST BE POSITIVE
+	Arc(const vf2d pos,const float radius,const float pointingAngle,const float sweepAngle);
+	void Draw(AiL*game,const Pixel col);
+	const bool overlaps(const vf2d checkPos)const;
+	void GrowRadius(const float growAmt);
+	const vf2d pos;
+	const float pointingAngle;
+	const float sweepAngle;
+	float radius;
+	geom2d::polygon<float>poly;
+private:
+	void GenerateArc();
+};

Adventures in Lestoria/ArtificerDisassembleWindow.cpp

@@ -38,15 +38,112 @@ All rights reserved.
 
 #include "Menu.h"
 #include "AdventuresInLestoria.h"
+#include "RowInventoryScrollableWindowComponent.h"
+#include "InventoryCreator.h"
+#include "MenuItemItemButton.h"
+#include "RowItemDisplay.h"
+#include "MenuDecal.h"
+#include "SoundEffect.h"
 
 INCLUDE_game
 
 void Menu::InitializeArtificerDisassembleWindow(){
-	Menu*artificerDisassembleWindow=CreateMenu(ARTIFICER_DISASSEMBLE,CENTERED,vi2d{144,144});
+	Menu*artificerDisassembleWindow=CreateMenu(ARTIFICER_DISASSEMBLE,CENTERED,game->GetScreenSize()-vi2d{52,52});
+	
+	const auto ResetDisassemblyDisplay=[artificerDisassembleWindow](){
+		MenuType menuType{artificerDisassembleWindow->GetType()};
+		Component<MenuDecal>(menuType,"Down Arrow")->Disable();
+		Component<MenuIconButton>(menuType,"Disassembly Result")->Disable();
+		Component<MenuLabel>(menuType,"Disassembly Result Title")->Disable();
+		Component<MenuLabel>(menuType,"Fragment Total Count")->Disable();
+		Component<MenuComponent>(menuType,"Disassemble Button")->Disable();
+	};
+	const auto EnableDisassemblyDisplay=[artificerDisassembleWindow](){
+		MenuType menuType{artificerDisassembleWindow->GetType()};
+		Component<MenuDecal>(menuType,"Down Arrow")->Enable();
+		Component<MenuIconButton>(menuType,"Disassembly Result")->Enable();
+		Component<MenuLabel>(menuType,"Disassembly Result Title")->Enable();
+		Component<MenuLabel>(menuType,"Fragment Total Count")->Enable();
+		Component<MenuComponent>(menuType,"Disassemble Button")->Enable();
+	};
+
+	auto disassemblyTitleLabel{artificerDisassembleWindow->ADD("Disassembly Title Label",MenuLabel)(geom2d::rect<float>{{},{artificerDisassembleWindow->size.x,24.f}},"Accessory Disassembly",2.f,ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::BACKGROUND)END};
+
+	auto inventoryLabel=artificerDisassembleWindow->ADD("Accessory List Label",MenuLabel)(geom2d::rect<float>{{0.f,28.f},{180.f,12.f}},"Choose Accessory:",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END;
+
+	auto itemIcon{artificerDisassembleWindow->ADD("Item Icon",MenuItemItemButton)(geom2d::rect<float>({artificerDisassembleWindow->size.x/2+4.f,44.f},{48,48}),Item::BLANK,DO_NOTHING,"","Item Description",IconButtonAttr::NOT_SELECTABLE)END};
+	itemIcon->SetIconScale({2.f,2.f});
+	itemIcon->SetCompactDescriptions(true);
+
+	auto accessoryDescription{artificerDisassembleWindow->ADD("Item Description",MenuLabel)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+56.f,44.f},{artificerDisassembleWindow->size.x/2-56.f,72.f}},"",0.5f,ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+
+	auto downArrow{artificerDisassembleWindow->ADD("Down Arrow",MenuDecal)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+4.f,92.f},{48,48}},GFX.at("downarrow.png"),DO_NOTHING,DO_NOTHING)END};
+
+	auto disassemblyResult{artificerDisassembleWindow->ADD("Disassembly Result",MenuIconButton)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+4.f,141.f},{48,48}},nullptr,DO_NOTHING,IconButtonAttr::NOT_SELECTABLE)END};
+
+	auto disassemblyResultTitle{artificerDisassembleWindow->ADD("Disassembly Result Title",MenuLabel)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+56.f,141.f},{artificerDisassembleWindow->size.x/2-56.f,24.f}},"",2.f,ComponentAttr::BACKGROUND|ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::FIT_TO_LABEL)END};
+
+	auto disassemblyTotalCount{artificerDisassembleWindow->ADD("Fragment Total Count",MenuLabel)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+56.f,127.f},{artificerDisassembleWindow->size.x/2-56.f,12.f}},"",0.85f,ComponentAttr::RIGHT_ALIGN|ComponentAttr::SHADOW|ComponentAttr::FIT_TO_LABEL)END};
+
+	auto disassembleButton{artificerDisassembleWindow->ADD("Disassemble Button",MenuComponent)(geom2d::rect<float>{{artificerDisassembleWindow->size.x/2+72.f,171.f},{artificerDisassembleWindow->size.x/2-72.f,16.f}},"Disassemble",[ResetDisassemblyDisplay](MenuFuncData data){
+		auto it{Component<MenuItemItemButton>(data.menu.type,"Item Icon")->GetItem()};
+		if(Inventory::Disassemble(it)==Inventory::DisassembleResult::SUCCESS){
+			SoundEffect::PlaySFX("Disassemble Item",SoundEffect::CENTERED);
+			Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(Item::BLANK);
+			Component<MenuIconButton>(data.menu.type,"Disassembly Result")->SetIcon(nullptr);
+			Component<MenuLabel>(data.menu.type,"Disassembly Result Title")->SetLabel("");
+			Component<MenuLabel>(data.menu.type,"Fragment Total Count")->SetLabel("");
+			ResetDisassemblyDisplay();
+		}else{
+			SoundEffect::PlaySFX("Locked Item",SoundEffect::CENTERED);
+			game->AddNotification(AiL::Notification{"Cannot disassemble locked accessory!",5.f,RED});
+		}
+		return true;
+	})END};
+	
+	auto inventoryDisplay=artificerDisassembleWindow->ADD("Accessory List",RowInventoryScrollableWindowComponent)(geom2d::rect<float>{{0.f,44.f},{artificerDisassembleWindow->size.x/2-4.f,artificerDisassembleWindow->size.y-60}},"","",[](MenuFuncData data){
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->SelectChild(DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component));
+			return true;
+		},[EnableDisassemblyDisplay](MenuFuncData data){
+			EnableDisassemblyDisplay();
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem().lock());
+			Component<MenuIconButton>(data.menu.type,"Disassembly Result")->SetIcon(item.GetItem().lock()->Icon().Decal());
+			Component<MenuLabel>(data.menu.type,"Disassembly Result Title")->SetLabel(item.GetItem().lock()->FragmentName());
+			Component<MenuLabel>(data.menu.type,"Fragment Total Count")->SetLabel(std::format("Currently Owned: {}",Inventory::GetItemCount(item.GetItem().lock()->FragmentName())));
+			return true;	
+		},[ResetDisassemblyDisplay,EnableDisassemblyDisplay](MenuFuncData data){
+			ResetDisassemblyDisplay();
+			auto childComponent{DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->GetSelectedChild()};
+			if(childComponent){
+				RowItemDisplay&item{childComponent.value().get()};
+				Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem().lock());
+				Component<MenuIconButton>(data.menu.type,"Disassembly Result")->SetIcon(item.GetItem().lock()->Icon().Decal());
+				Component<MenuLabel>(data.menu.type,"Disassembly Result Title")->SetLabel(item.GetItem().lock()->FragmentName());
+				Component<MenuLabel>(data.menu.type,"Fragment Total Count")->SetLabel(std::format("Currently Owned: {}",Inventory::GetItemCount(item.GetItem().lock()->FragmentName())));
+				EnableDisassemblyDisplay();
+			}
+			return true;
+		},
+		InventoryCreator::RowPlayer_InventoryUpdate,
+		InventoryWindowOptions{.padding=1,.size={artificerDisassembleWindow->size.x/2-5.f-12.f,28}})END;
+
+	auto backButton=artificerDisassembleWindow->ADD("Back",MenuComponent)(geom2d::rect<float>{{0.f,artificerDisassembleWindow->size.y-12.f},{96.f,16.f}},"Back",[](MenuFuncData data){
+		Menu::CloseMenu();
+		return true;
+	})END;
+
+	Menu::AddInventoryListener(inventoryDisplay,"Accessories");
+
+	ResetDisassemblyDisplay();
 
 	artificerDisassembleWindow->SetupKeyboardNavigation(
 	[](MenuType type,Data&returnData){ //On Open
-		returnData="";
+		auto&items{Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents()};
+		if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+		else if(items.size()>0)returnData=items[0];
+		else returnData="Back";
 	},
 	{ //Button Key
 		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
@@ -54,12 +151,49 @@ void Menu::InitializeArtificerDisassembleWindow(){
 			Menu::CloseMenu();
 		}}},
 		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+		{{game->KEY_SHOULDER2,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_SHOULDER,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_FASTSCROLLUP,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->DecreaseSelectionIndex(3.f);
+		}}},
+		{{game->KEY_FASTSCROLLDOWN,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->IncreaseSelectionIndex(3.f);
+		}}},
 	}
 	,{ //Button Navigation Rules
-		{"Sample Button",{
-			.up="",
-			.down="",
-			.left="",
-			.right="",}},
-	});
+		{"Accessory List",{
+			.up=[&](MenuType type,Data&returnData){
+				Menu::ScrollUp(type,"Accessory List",returnData,"Back");
+			},
+			.down=[&](MenuType type,Data&returnData){
+				Menu::ScrollDown(type,"Accessory List",returnData,"Back");
+			},
+			.left="Back",
+			.right=[&](MenuType type,Data&returnData){
+				Menu::menus[type]->GetSelection().lock()->Click();
+				returnData="Disassemble Button";
+			},}},
+		{"Back",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left="Disassemble Button",
+			.right="Disassemble Button",}},
+		{"Disassemble Button",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left=[&](MenuType type,Data&returnData){
+				if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+				else returnData="Back";
+			},
+			.right="Back",}},
+	}
+	);
 }

Adventures in Lestoria/ArtificerEnchantConfirmWindow.cpp

@@ -38,28 +38,81 @@ All rights reserved.
 
 #include "Menu.h"
 #include "AdventuresInLestoria.h"
+#include "MenuIconButton.h"
+#include "MenuItemLabel.h"
+#include "SoundEffect.h"
 
 INCLUDE_game
 
 void Menu::InitializeArtificerEnchantConfirmWindow(){
-	Menu*artificerEnchantConfirmWindow=CreateMenu(ARTIFICER_ENCHANT_CONFIRM,CENTERED,vi2d{144,144});
+	Menu*artificerEnchantConfirmWindow=CreateMenu(ARTIFICER_ENCHANT_CONFIRM,CENTERED,vi2d{240,144});
+
+	auto enchantSuccessLabel{artificerEnchantConfirmWindow->ADD("Enchant Success Label",MenuLabel)(geom2d::rect<float>{{0.f,-14.f},vf2d{artificerEnchantConfirmWindow->size.x,12.f}},"Enchantment Success!",1.f,ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::BACKGROUND)END};
+
+	auto chooseResultLabel{artificerEnchantConfirmWindow->ADD("Choose Result Label",MenuLabel)(geom2d::rect<float>{vf2d{0.f,0.f},vf2d{artificerEnchantConfirmWindow->size.x,12.f}},"Choose a Result",1.f,ComponentAttr::SHADOW)END};
+
+	auto backgroundOld{artificerEnchantConfirmWindow->ADD("Old Background",MenuLabel)(geom2d::rect<float>{{-2.f,12.f},{artificerEnchantConfirmWindow->size.x/2.f-4.f,124.f}},"",1.f,ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE)END};
+	auto backgroundNew{artificerEnchantConfirmWindow->ADD("New Background",MenuLabel)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/2.f-2.f+8.f,12.f},{artificerEnchantConfirmWindow->size.x/2.f-4.f,124.f}},"",1.f,ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE)END};
+
+	const float oldLabelTextWidth{game->GetTextSize("OLD").x*2.f};
+	auto oldLabel{artificerEnchantConfirmWindow->ADD("Old Item Label",MenuLabel)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/4.f-oldLabelTextWidth/2-4.f,14.f},vf2d{oldLabelTextWidth+8.f,24.f}},"OLD",2.f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND)END};
+
+	const float newLabelTextWidth{game->GetTextSize("NEW").x*2.f};
+	auto newLabel{artificerEnchantConfirmWindow->ADD("New Item Label",MenuLabel)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/2.f+artificerEnchantConfirmWindow->size.x/4.f-oldLabelTextWidth/2+2.f,14.f},vf2d{oldLabelTextWidth+8.f,24.f}},"NEW",2.f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND)END};
+	
+	auto oldIcon{artificerEnchantConfirmWindow->ADD("Old Item Icon",MenuIconButton)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/4.f-16.f,42.f},{24,24}},nullptr,DO_NOTHING,IconButtonAttr::NOT_SELECTABLE|IconButtonAttr::NO_OUTLINE)END};
+	auto newIcon{artificerEnchantConfirmWindow->ADD("New Item Icon",MenuIconButton)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/2.f+artificerEnchantConfirmWindow->size.x/4.f-16.f+4.f,42.f},{24,24}},nullptr,DO_NOTHING,IconButtonAttr::NOT_SELECTABLE|IconButtonAttr::NO_OUTLINE)END};
+
+	auto oldItemDescription{artificerEnchantConfirmWindow->ADD("Old Item Description",MenuItemLabel)(geom2d::rect<float>{{0.f,74.f},{artificerEnchantConfirmWindow->size.x/2.f-8.f,60.f}},Item::BLANK,ItemLabelDescriptionType::ITEM_DESCRIPTION,0.5f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::LEFT_ALIGN)END};
+	auto newItemDescription{artificerEnchantConfirmWindow->ADD("New Item Description",MenuItemLabel)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/2.f+8.f,74.f},{artificerEnchantConfirmWindow->size.x/2.f-8.f,60.f}},Item::BLANK,ItemLabelDescriptionType::ITEM_DESCRIPTION,0.5f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::LEFT_ALIGN)END};
+
+	const float takeOldTextWidth{float(game->GetTextSize("Take Old").x)*2.f};
+	auto takeOldButton{artificerEnchantConfirmWindow->ADD("Take Old Button",MenuComponent)(geom2d::rect<float>{{artificerEnchantConfirmWindow->size.x/4.f-takeOldTextWidth/2.f,138.f},{takeOldTextWidth-8.f,20.f}},"Take Old",[](MenuFuncData data){
+		onClick:
+		std::any&oldEnchant{Menu::menus[ARTIFICER_ENCHANT]->ANY(A::ENCHANT)};
+		std::weak_ptr<Item>newItem{std::get<std::weak_ptr<Item>>(Component<MenuItemLabel>(data.menu.GetType(),"New Item Description")->GetItem())}; //NOTE: We're making an assumption here that the new item description holds a weak pointer. This should be true because the only way to get here was to set it up through clicking the Enchant button in Artificer Enchant Window.
+		if(oldEnchant.has_value())newItem.lock()->_EnchantItem(std::any_cast<ItemEnchant&>(oldEnchant));
+		else newItem.lock()->RemoveEnchant();
+		Component<MenuComponent>(ARTIFICER_ENCHANT,"Fragment Enchant Button")->SetGrayedOut(!newItem.lock()->CanBeEnchanted());
+		const std::string_view fragmentName{newItem.lock()->FragmentName()};
+		const Pixel fragmentItemDisplayCol{Inventory::GetItemCount(fragmentName)>="Fragment Enchant Cost"_i[0]?WHITE:RED};
+		const Pixel moneyCostDisplayCol{game->GetPlayer()->GetMoney()>="Fragment Enchant Cost"_i[1]?WHITE:RED};
+		Component<MenuLabel>(ARTIFICER_ENCHANT,"Fragment Label")->SetLabel(std::format("{}{} x{} ({})",fragmentItemDisplayCol.toHTMLColorCode(),fragmentName,"Fragment Enchant Cost"_i[0],Inventory::GetItemCount(fragmentName)));
+		Component<MenuLabel>(ARTIFICER_ENCHANT,"Fragment Money Cost Label")->SetLabel(std::format("{}{} gold",moneyCostDisplayCol.toHTMLColorCode(),"Fragment Enchant Cost"_i[1]));
+		SoundEffect::PlaySFX("Take Enchant",SoundEffect::CENTERED);
+		Menu::CloseMenu();
+		return true;
+	},vf2d{2.f,2.f})END};
+	
+	const float takeNewTextWidth{float(game->GetTextSize("Take New").x)*2.f};
+	auto takeNewButton{artificerEnchantConfirmWindow->ADD("Take New Button",MenuComponent)(geom2d::rect<float>{vf2d{artificerEnchantConfirmWindow->size.x/2.f+8.f+artificerEnchantConfirmWindow->size.x/4.f-takeNewTextWidth/2.f,138.f},{takeNewTextWidth-8.f,20.f}},"Take New",[](MenuFuncData data){
+		onClick:
+		std::weak_ptr<Item>newItem{std::get<std::weak_ptr<Item>>(Component<MenuItemLabel>(data.menu.GetType(),"New Item Description")->GetItem())};
+		Component<MenuComponent>(ARTIFICER_ENCHANT,"Fragment Enchant Button")->SetGrayedOut(!newItem.lock()->CanBeEnchanted());
+		const std::string_view fragmentName{newItem.lock()->FragmentName()};
+		const Pixel fragmentItemDisplayCol{Inventory::GetItemCount(fragmentName)>="Fragment Enchant Cost"_i[0]?WHITE:RED};
+		const Pixel moneyCostDisplayCol{game->GetPlayer()->GetMoney()>="Fragment Enchant Cost"_i[1]?WHITE:RED};
+		Component<MenuLabel>(ARTIFICER_ENCHANT,"Fragment Label")->SetLabel(std::format("{}{} x{} ({})",fragmentItemDisplayCol.toHTMLColorCode(),fragmentName,"Fragment Enchant Cost"_i[0],Inventory::GetItemCount(fragmentName)));
+		Component<MenuLabel>(ARTIFICER_ENCHANT,"Fragment Money Cost Label")->SetLabel(std::format("{}{} gold",moneyCostDisplayCol.toHTMLColorCode(),"Fragment Enchant Cost"_i[1]));
+		SoundEffect::PlaySFX("Take Enchant",SoundEffect::CENTERED);
+		Menu::CloseMenu();
+		return true;
+	},vf2d{2.f,2.f})END};
 	
 	artificerEnchantConfirmWindow->SetupKeyboardNavigation(
 	[](MenuType type,Data&returnData){ //On Open
-		returnData="";
+		returnData="Take New Button";
 	},
 	{ //Button Key
 		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
-		{game->KEY_BACK,{"Stay",[](MenuType type){
-			Menu::CloseMenu();
-		}}},
 		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
 	}
 	,{ //Button Navigation Rules
-		{"Sample Button",{
-			.up="",
-			.down="",
-			.left="",
-			.right="",}},
+		{"Take Old Button",{
+			.left="Take New Button",
+			.right="Take New Button",}},
+		{"Take New Button",{
+			.left="Take Old Button",
+			.right="Take Old Button",}},
 	});
 }

Adventures in Lestoria/ArtificerEnchantWindow.cpp

@@ -38,15 +38,144 @@ All rights reserved.
 
 #include "Menu.h"
 #include "AdventuresInLestoria.h"
+#include "RowInventoryScrollableWindowComponent.h"
+#include "MenuItemItemButton.h"
+#include "MenuItemLabel.h"
+#include "MenuDecal.h"
+#include "PlayerMoneyLabel.h"
+#include "SoundEffect.h"
 
 INCLUDE_game
 
 void Menu::InitializeArtificerEnchantWindow(){
-	Menu*artificerEnchantWindow=CreateMenu(ARTIFICER_ENCHANT,CENTERED,vi2d{144,144});
+	Menu*artificerEnchantWindow=CreateMenu(ARTIFICER_ENCHANT,CENTERED,game->GetScreenSize()-vi2d{52,52});
+
+	auto enchantingTitleLabel{artificerEnchantWindow->ADD("Enchanting Title Label",MenuLabel)(geom2d::rect<float>{{0.f,-16.f},{artificerEnchantWindow->size.x,24.f}},"Accessory Enchanting",2.f,ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::BACKGROUND)END};
+
+	auto inventoryLabel{artificerEnchantWindow->ADD("Accessory List Label",MenuLabel)(geom2d::rect<float>{{0.f,12.f},{180.f,12.f}},"Choose Accessory:",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+
+	auto itemIcon{artificerEnchantWindow->ADD("Item Icon",MenuItemItemButton)(geom2d::rect<float>({artificerEnchantWindow->size.x/2+4.f,16.f},{48,48}),Item::BLANK,DO_NOTHING,"","Item Description",IconButtonAttr::NOT_SELECTABLE)END};
+	itemIcon->SetIconScale({2.f,2.f});
+	itemIcon->SetCompactDescriptions(true);
+
+	auto accessoryDescription{artificerEnchantWindow->ADD("Item Description",MenuLabel)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+56.f,16.f},{artificerEnchantWindow->size.x/2-40.f,72.f}},"",0.5f,ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+	
+	const auto ResetEnchantDisplay{[artificerEnchantWindow](){
+		MenuType menuType{artificerEnchantWindow->GetType()};
+		Component<MenuItemItemButton>(menuType,"Item Icon")->SetItem(Item::BLANK);
+		Component<ScrollableWindowComponent>(menuType,"Enchant Container")->Disable();
+		Component<MenuLabel>(menuType,"Enchant List Header")->Disable();
+		Component<MenuLabel>(menuType,"Enchant Cost Label")->Disable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->Disable();
+		Component<MenuLabel>(menuType,"Fragment Label")->Disable();
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->Disable();
+		Component<MenuComponent>(menuType,"Fragment Enchant Button")->Disable();
+	}};
+	const auto EnableEnchantDisplay{[artificerEnchantWindow](){
+		MenuType menuType{artificerEnchantWindow->GetType()};
+		const std::weak_ptr<Item>&selectedItem{Component<MenuItemItemButton>(menuType,"Item Icon")->GetItem()};
+		std::vector<ItemEnchantInfo>availableEnchants{ItemEnchant::GetAvailableEnchants()};
+		std::sort(availableEnchants.begin(),availableEnchants.end(),[](const ItemEnchantInfo&enchant1,const ItemEnchantInfo&enchant2){
+			return enchant1.Category()!=enchant2.Category()?int(enchant1.Category())<int(enchant2.Category()):enchant1.Name()<enchant2.Name();
+		});
+		std::string enchantList{std::accumulate(availableEnchants.begin(),availableEnchants.end(),""s,[](const std::string&acc,const ItemEnchantInfo&enchant){
+			return std::format("{}{}{}#FFFFFF\n",acc,enchant.DisplayCol().toHTMLColorCode(),enchant.Name());
+		})};
+		Component<ScrollableWindowComponent>(menuType,"Enchant Container")->Enable();
+		Component<MenuLabel>(menuType,"Enchant List")->SetLabel(enchantList);
+		Component<MenuLabel>(menuType,"Enchant List Header")->Enable();
+		Component<MenuLabel>(menuType,"Enchant Cost Label")->Enable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->Enable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->SetImage(GFX.at(selectedItem.lock()->FragmentIcon().value()));
+		Component<MenuLabel>(menuType,"Fragment Label")->Enable();
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->Enable();
+		Component<MenuComponent>(menuType,"Fragment Enchant Button")->Enable();
+		Component<MenuComponent>(menuType,"Fragment Enchant Button")->SetGrayedOut(!selectedItem.lock()->CanBeEnchanted());
+
+		const std::string_view fragmentName{selectedItem.lock()->FragmentName()};
+		const Pixel fragmentItemDisplayCol{Inventory::GetItemCount(fragmentName)>="Fragment Enchant Cost"_i[0]?WHITE:RED};
+		const Pixel moneyCostDisplayCol{game->GetPlayer()->GetMoney()>="Fragment Enchant Cost"_i[1]?WHITE:RED};
+		Component<MenuLabel>(menuType,"Fragment Label")->SetLabel(std::format("{}{} x{} ({})",fragmentItemDisplayCol.toHTMLColorCode(),fragmentName,"Fragment Enchant Cost"_i[0],Inventory::GetItemCount(fragmentName)));
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->SetLabel(std::format("{}{} gold",moneyCostDisplayCol.toHTMLColorCode(),"Fragment Enchant Cost"_i[1]));
+	}};
+
+	auto inventoryDisplay{artificerEnchantWindow->ADD("Accessory List",RowInventoryScrollableWindowComponent)(geom2d::rect<float>{{0.f,28.f},{artificerEnchantWindow->size.x/2-4.f,artificerEnchantWindow->size.y-44}},"","",[](MenuFuncData data){
+			OnClick:
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->SelectChild(DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component));
+			return true;
+		},[EnableEnchantDisplay](MenuFuncData data){OnHover:
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem());
+			EnableEnchantDisplay();
+			return true;
+		},[ResetEnchantDisplay,EnableEnchantDisplay](MenuFuncData data){OnMouseOut:
+			ResetEnchantDisplay();
+			auto childComponent{DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->GetSelectedChild()};
+			if(childComponent){
+				RowItemDisplay&item{childComponent.value().get()};
+				Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem());
+				EnableEnchantDisplay();
+			}
+			return true;
+		},
+		InventoryCreator::RowPlayer_InventoryUpdate,
+		InventoryWindowOptions{.padding=1,.size={artificerEnchantWindow->size.x/2-5.f-12.f,28}})END};
+	
+	auto enchantListHeaderLabel{artificerEnchantWindow->ADD("Enchant List Header",MenuLabel)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+4.f,92.f},{artificerEnchantWindow->size.x/2+12.f,12.f}},"Possible Enchantments:",1.f,ComponentAttr::FIT_TO_LABEL|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::SHADOW)END};
+
+	auto enchantContainer{artificerEnchantWindow->ADD("Enchant Container",ScrollableWindowComponent)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+4.f,104.f},{artificerEnchantWindow->size.x/2+12.f,44.f}})END};
+	auto enchantList{enchantContainer->ADD("Enchant List",MenuLabel)(geom2d::rect<float>{{0.f,2.f},{enchantContainer->GetSize().x-12.f,0.f}},"",1.f,ComponentAttr::CENTER|ComponentAttr::SHADOW)END};
+	
+	auto enchantCostLabel{artificerEnchantWindow->ADD("Enchant Cost Label",MenuLabel)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+4.f,152.f},{64.f,20.f}},"Enchant Cost:",1.f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE)END};
+
+	auto fragmentCostIcon{artificerEnchantWindow->ADD("Fragment Cost Icon",MenuDecal)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+68.f,152.f},{12.f,12.f}})END};
+	auto fragmentDisplayLabel{artificerEnchantWindow->ADD("Fragment Label",MenuLabel)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+80.f,152.f},{artificerEnchantWindow->size.x/2-60.f,12.f}},"",1.f,ComponentAttr::SHADOW|ComponentAttr::FIT_TO_LABEL|ComponentAttr::LEFT_ALIGN)END};
+	auto fragmentMoneyCostLabel{artificerEnchantWindow->ADD("Fragment Money Cost Label",MenuLabel)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+80.f,164.f},{artificerEnchantWindow->size.x/2-60.f,12.f}},"",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+
+	auto fragmentEnchantButton{artificerEnchantWindow->ADD("Fragment Enchant Button",MenuComponent)(geom2d::rect<float>{{artificerEnchantWindow->size.x/2+96.f,180.f},{artificerEnchantWindow->size.x/2-80.f,12.f}},"Enchant",[EnableEnchantDisplay](MenuFuncData data){
+		onClick:
+		EnableEnchantDisplay(); //Refresh the current display contents.
+		SoundEffect::PlaySFX("Enchant Item",SoundEffect::CENTERED);
+		std::weak_ptr<Item>item{Component<MenuItemItemButton>(data.menu.type,"Item Icon")->GetItem()};
+		std::optional<ItemEnchant>previousEnchant{item.lock()->GetEnchant()};
+		data.menu.ANY(A::ENCHANT)={};
+		if(previousEnchant.has_value())data.menu.ANY(A::ENCHANT)=previousEnchant.value();
+		Component<MenuIconButton>(ARTIFICER_ENCHANT_CONFIRM,"Old Item Icon")->SetIcon(item.lock()->Icon().Decal());
+		Component<MenuItemLabel>(ARTIFICER_ENCHANT_CONFIRM,"Old Item Description")->SetItem(*item.lock());
+
+		item.lock()->ApplyRandomEnchant();
+		const ItemEnchant&newEnchant{item.lock()->GetEnchant().value()};
+		Component<MenuIconButton>(ARTIFICER_ENCHANT_CONFIRM,"New Item Icon")->SetIcon(item.lock()->Icon().Decal());
+		Component<MenuItemLabel>(ARTIFICER_ENCHANT_CONFIRM,"New Item Description")->SetItem(item.lock());
+
+		Menu::OpenMenu(ARTIFICER_ENCHANT_CONFIRM,true);
+		return true;
+	})END};
+
+	#pragma region Money Display
+		vf2d moneyIconPos{artificerEnchantWindow->size.x/2-28.f,artificerEnchantWindow->size.y-12.f};
+		auto moneyIcon=artificerEnchantWindow->ADD("Money Icon",MenuIconButton)(geom2d::rect<float>{moneyIconPos,{24,24}},GFX["money.png"].Decal(),DO_NOTHING,IconButtonAttr::NOT_SELECTABLE|IconButtonAttr::NO_OUTLINE|IconButtonAttr::NO_BACKGROUND)END;
+		std::string moneyText=std::to_string(game->GetPlayer()->GetMoney());
+		vf2d moneyTextSize=game->GetTextSizeProp(moneyText)*2;
+		auto moneyDisplay=artificerEnchantWindow->ADD("Money Label",PlayerMoneyLabel)(geom2d::rect<float>{moneyIconPos+vf2d{26.f,4.f},moneyTextSize},2,1.85f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN|ComponentAttr::FIT_TO_LABEL)END;
+		Player::AddMoneyListener(moneyDisplay);
+	#pragma endregion
+
+	auto backButton{artificerEnchantWindow->ADD("Back",MenuComponent)(geom2d::rect<float>{{0.f,artificerEnchantWindow->size.y-12.f},{96.f,16.f}},"Back",[](MenuFuncData data){
+		Menu::CloseMenu();
+		return true;
+	})END};
+
+	ResetEnchantDisplay();
+	Menu::AddInventoryListener(inventoryDisplay,"Accessories");
 
 	artificerEnchantWindow->SetupKeyboardNavigation(
 	[](MenuType type,Data&returnData){ //On Open
-		returnData="";
+		auto&items{Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents()};
+		if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+		else if(items.size()>0)returnData=items[0];
+		else returnData="Back";
 	},
 	{ //Button Key
 		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
@@ -54,12 +183,52 @@ void Menu::InitializeArtificerEnchantWindow(){
 			Menu::CloseMenu();
 		}}},
 		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+		{{game->KEY_SHOULDER2,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_SHOULDER,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_FASTSCROLLUP,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->DecreaseSelectionIndex(3.f);
+		}}},
+		{{game->KEY_FASTSCROLLDOWN,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->IncreaseSelectionIndex(3.f);
+		}}},
+		{{game->KEY_SCROLLVERT_R,Analog,InputEngageGroup::NOT_VISIBLE},{"Scroll Enchants",[](MenuType type){
+			Component<ScrollableWindowComponent>(type,"Enchant Container")->Scroll(game->KEY_SCROLLVERT.Analog());
+		}}},
 	}
 	,{ //Button Navigation Rules
-		{"Sample Button",{
-			.up="",
-			.down="",
-			.left="",
-			.right="",}},
-	});
+		{"Accessory List",{
+			.up=[&](MenuType type,Data&returnData){
+				Menu::ScrollUp(type,"Accessory List",returnData,"Back");
+			},
+			.down=[&](MenuType type,Data&returnData){
+				Menu::ScrollDown(type,"Accessory List",returnData,"Back");
+			},
+			.left="Back",
+			.right=[&](MenuType type,Data&returnData){
+				Menu::menus[type]->GetSelection().lock()->Click();
+				returnData="Fragment Enchant Button";
+			},}},
+		{"Back",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left="Fragment Enchant Button",
+			.right="Fragment Enchant Button",}},
+		{"Fragment Enchant Button",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left=[&](MenuType type,Data&returnData){
+				if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+				else returnData="Back";
+			},
+			.right="Back",}},
+	}
+	);
 }

Adventures in Lestoria/ArtificerRefineResultWindow.cpp

@@ -0,0 +1,75 @@
+#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 "Menu.h"
+#include "AdventuresInLestoria.h"
+#include "MenuItemItemButton.h"
+#include "DynamicMenuLabel.h"
+
+INCLUDE_game
+
+void Menu::InitializeArtificerRefineResultWindow(){
+	Menu*artificerRefineResultWindow=CreateMenu(ARTIFICER_REFINE_RESULT,CENTERED,vi2d{144,144});
+
+	auto itemIcon{artificerRefineResultWindow->ADD("Item Icon",MenuItemItemButton)(geom2d::rect<float>{{artificerRefineResultWindow->size.x/2.f-24.f,0.f},{48.f,48.f}},Item::BLANK,DO_NOTHING,"","",IconButtonAttr::NOT_SELECTABLE)END};
+	itemIcon->SetIconScale({2.f,2.f});
+
+	auto refineItemTextdisplay{artificerRefineResultWindow->ADD("Refine Item Text Display",MenuLabel)(geom2d::rect<float>{vf2d{0.f,artificerRefineResultWindow->size.y/2.f},vf2d{artificerRefineResultWindow->size.x,12.f}},"",1.f,ComponentAttr::SHADOW)END};
+
+	auto refineResultDisplay{artificerRefineResultWindow->ADD("Refine Result",DynamicMenuLabel)(geom2d::rect<float>{vf2d{0.f,artificerRefineResultWindow->size.y/2.f+artificerRefineResultWindow->size.y*0.33f},vf2d{artificerRefineResultWindow->size.x,12.f}},[](){return "";},1.f,ComponentAttr::SHADOW)END};
+
+	auto continueButton{artificerRefineResultWindow->ADD("Continue Button",MenuComponent)(geom2d::rect<float>{vf2d{artificerRefineResultWindow->size.x/4.f,artificerRefineResultWindow->size.y-6.f},{artificerRefineResultWindow->size.x/2.f,12.f}},"Continue",[](MenuFuncData data){
+		onClick:
+		Menu::CloseMenu();
+		return true;
+	})END};
+	
+	artificerRefineResultWindow->SetupKeyboardNavigation(
+	[](MenuType type,Data&returnData){ //On Open
+		returnData="Continue Button";
+	},
+	{ //Button Key
+		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
+		{game->KEY_BACK,{"Stay",[](MenuType type){
+			Menu::CloseMenu();
+		}}},
+		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+	}
+	,{ //Button Navigation Rules
+	});
+}

Adventures in Lestoria/ArtificerRefineWindow.cpp

@@ -39,31 +39,128 @@ All rights reserved.
 #include "Menu.h"
 #include "AdventuresInLestoria.h"
 #include "RowInventoryScrollableWindowComponent.h"
-#include "MenuLabel.h"
+#include "MenuItemItemButton.h"
+#include "MenuRefineLabel.h"
+#include "PlayerMoneyLabel.h"
+#include "MenuDecal.h"
+#include "SoundEffect.h"
+#include "DynamicMenuLabel.h"
 
 INCLUDE_game
 
 void Menu::InitializeArtificerRefineWindow(){
-	Menu*artificerRefineWindow=CreateMenu(ARTIFICER_REFINE,CENTERED,game->GetScreenSize()-vi2d{52,52});
+	Menu*const artificerRefineWindow{CreateMenu(ARTIFICER_REFINE,CENTERED,game->GetScreenSize()-vi2d{52,52})};
 
-	auto inventoryLabel=artificerRefineWindow->ADD("Accessory List Label",MenuLabel)(geom2d::rect<float>{{},{180.f,12.f}},"Choose Accessory:",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END;
+	auto refiningTitleLabel{artificerRefineWindow->ADD("Refining Title Label",MenuLabel)(geom2d::rect<float>{{0.f,-16.f},{artificerRefineWindow->size.x,24.f}},"Accessory Refinement",2.f,ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::BACKGROUND)END};
 
-	auto inventoryDisplay=artificerRefineWindow->ADD("Accessory List",RowInventoryScrollableWindowComponent)(geom2d::rect<float>{{0.f,16.f},{artificerRefineWindow->size.x/2-4.f,artificerRefineWindow->size.y-32}},"","",[](MenuFuncData data){
+	auto inventoryLabel{artificerRefineWindow->ADD("Accessory List Label",MenuLabel)(geom2d::rect<float>{{0.f,12.f},{180.f,12.f}},"Choose Accessory:",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+
+	auto itemIcon{artificerRefineWindow->ADD("Item Icon",MenuItemItemButton)(geom2d::rect<float>({artificerRefineWindow->size.x/2+4.f,28.f},{48,48}),Item::BLANK,DO_NOTHING,"","Item Description",IconButtonAttr::NOT_SELECTABLE)END};
+	itemIcon->SetIconScale({2.f,2.f});
+	itemIcon->SetCompactDescriptions(true);
+
+	auto accessoryDescription{artificerRefineWindow->ADD("Item Description",MenuLabel)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+56.f,28.f},{artificerRefineWindow->size.x/2-40.f,72.f}},"",0.5f,ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE|ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+	
+	const auto ResetRefineDisplay{[artificerRefineWindow](){
+		MenuType menuType{artificerRefineWindow->GetType()};
+		Component<MenuItemItemButton>(menuType,"Item Icon")->SetItem(Item::BLANK);
+		Component<MenuRefineLabel>(menuType,"Stats Block")->Disable();
+		Component<MenuLabel>(menuType,"Refine Cost Label")->Disable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->Disable();
+		Component<MenuLabel>(menuType,"Fragment Label")->Disable();
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->Disable();
+		Component<MenuComponent>(menuType,"Fragment Refine Button")->Disable();
+	}};
+	const auto EnableRefineDisplay{[artificerRefineWindow](){
+		MenuType menuType{artificerRefineWindow->GetType()};
+		const std::weak_ptr<Item>&selectedItem{Component<MenuItemItemButton>(menuType,"Item Icon")->GetItem()};
+		Component<MenuRefineLabel>(menuType,"Stats Block")->SetItem(selectedItem);
+		Component<MenuRefineLabel>(menuType,"Stats Block")->Enable();
+		Component<MenuLabel>(menuType,"Refine Cost Label")->Enable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->Enable();
+		Component<MenuDecal>(menuType,"Fragment Cost Icon")->SetImage(GFX.at(selectedItem.lock()->FragmentIcon().value()));
+		Component<MenuLabel>(menuType,"Fragment Label")->Enable();
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->Enable();
+		Component<MenuComponent>(menuType,"Fragment Refine Button")->Enable();
+		Component<MenuComponent>(menuType,"Fragment Refine Button")->SetGrayedOut(!selectedItem.lock()->CanBeRefined());
+
+		const std::string_view fragmentName{selectedItem.lock()->FragmentName()};
+		const Pixel fragmentItemDisplayCol{Inventory::GetItemCount(fragmentName)>="Fragment Refine Cost"_i[0]?WHITE:RED};
+		const Pixel moneyCostDisplayCol{game->GetPlayer()->GetMoney()>="Fragment Refine Cost"_i[1]?WHITE:RED};
+		Component<MenuLabel>(menuType,"Fragment Label")->SetLabel(std::format("{}{} x{} ({})",fragmentItemDisplayCol.toHTMLColorCode(),fragmentName,"Fragment Refine Cost"_i[0],Inventory::GetItemCount(fragmentName)));
+		Component<MenuLabel>(menuType,"Fragment Money Cost Label")->SetLabel(std::format("{}{} gold",moneyCostDisplayCol.toHTMLColorCode(),"Fragment Refine Cost"_i[1]));
+	}};
+
+	auto inventoryDisplay{artificerRefineWindow->ADD("Accessory List",RowInventoryScrollableWindowComponent)(geom2d::rect<float>{{0.f,28.f},{artificerRefineWindow->size.x/2-4.f,artificerRefineWindow->size.y-44}},"","",[](MenuFuncData data){
+			OnClick:
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->SelectChild(DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component));
+			return true;
+		},[EnableRefineDisplay](MenuFuncData data){OnHover:
+			RowItemDisplay&item{*DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component)};
+			Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem());
+			EnableRefineDisplay();
+			return true;
+		},[ResetRefineDisplay,EnableRefineDisplay](MenuFuncData data){OnMouseOut:
+			ResetRefineDisplay();
+			auto childComponent{DYNAMIC_POINTER_CAST<RowInventoryScrollableWindowComponent>(data.parentComponent.lock())->GetSelectedChild()};
+			if(childComponent){
+				RowItemDisplay&item{childComponent.value().get()};
+				Component<MenuItemItemButton>(data.menu.type,"Item Icon")->SetItem(item.GetItem());
+				EnableRefineDisplay();
+			}
 			return true;
-		},DO_NOTHING,DO_NOTHING,
+		},
 		InventoryCreator::RowPlayer_InventoryUpdate,
-		InventoryWindowOptions{.padding=1,.size={artificerRefineWindow->size.x/2-5.f,28}})END;
+		InventoryWindowOptions{.padding=1,.size={artificerRefineWindow->size.x/2-5.f-12.f,28}})END};
+
+	auto statsBlock{artificerRefineWindow->ADD("Stats Block",MenuRefineLabel)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+4.f,104.f},{artificerRefineWindow->size.x/2+12.f,44.f}},Item::BLANK,1.f,ComponentAttr::BACKGROUND|ComponentAttr::SHADOW|ComponentAttr::OUTLINE|ComponentAttr::FIXED_WIDTH_FONT|ComponentAttr::FIT_TO_LABEL|ComponentAttr::LEFT_ALIGN)END};
+	
+	auto refineCostLabel{artificerRefineWindow->ADD("Refine Cost Label",MenuLabel)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+4.f,152.f},{64.f,20.f}},"Refine Cost:",1.f,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE)END};
+
+	auto fragmentCostIcon{artificerRefineWindow->ADD("Fragment Cost Icon",MenuDecal)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+68.f,152.f},{12.f,12.f}})END};
+	auto fragmentDisplayLabel{artificerRefineWindow->ADD("Fragment Label",MenuLabel)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+80.f,152.f},{artificerRefineWindow->size.x/2-60.f,12.f}},"",1.f,ComponentAttr::SHADOW|ComponentAttr::FIT_TO_LABEL|ComponentAttr::LEFT_ALIGN)END};
+	auto fragmentMoneyCostLabel{artificerRefineWindow->ADD("Fragment Money Cost Label",MenuLabel)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+80.f,164.f},{artificerRefineWindow->size.x/2-60.f,12.f}},"",1.f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN)END};
+
+	auto fragmentRefineButton{artificerRefineWindow->ADD("Fragment Refine Button",MenuComponent)(geom2d::rect<float>{{artificerRefineWindow->size.x/2+96.f,180.f},{artificerRefineWindow->size.x/2-80.f,12.f}},"Refine",[EnableRefineDisplay](MenuFuncData data){
+		onClick:
+		SoundEffect::PlaySFX("Refine Item",SoundEffect::CENTERED);
+		std::weak_ptr<Item>item{Component<MenuItemItemButton>(data.menu.type,"Item Icon")->GetItem()};
+		RefineResult result{item.lock()->Refine()};
+		Component<MenuItemItemButton>(ARTIFICER_REFINE_RESULT,"Item Icon")->SetItem(item);
+		Component<DynamicMenuLabel>(ARTIFICER_REFINE_RESULT,"Refine Result")->SetLabelUpdateFunction([result](){
+			const Pixel shimmeringColor{PixelLerp(WHITE,{220,220,220},sin((70*game->GetRunTime())/2.f+0.5f))};
+			return std::format("{} -> {}+{}{}  #FFFF00UP!",result.first.Name(),shimmeringColor.toHTMLColorCode(),result.second,result.first.DisplayAsPercent()?"%":"");
+		});
+		Component<MenuLabel>(ARTIFICER_REFINE_RESULT,"Refine Item Text Display")->SetLabel(std::format("#FFFF00{} has been refined!",item.lock()->DisplayName()));
+		EnableRefineDisplay(); //Refresh the current display contents.
+		Menu::OpenMenu(ARTIFICER_REFINE_RESULT,true);
+		return true;
+	})END};
+
+	#pragma region Money Display
+		vf2d moneyIconPos{artificerRefineWindow->size.x/2-28.f,artificerRefineWindow->size.y-12.f};
+		auto moneyIcon=artificerRefineWindow->ADD("Money Icon",MenuIconButton)(geom2d::rect<float>{moneyIconPos,{24,24}},GFX["money.png"].Decal(),DO_NOTHING,IconButtonAttr::NOT_SELECTABLE|IconButtonAttr::NO_OUTLINE|IconButtonAttr::NO_BACKGROUND)END;
+		std::string moneyText=std::to_string(game->GetPlayer()->GetMoney());
+		vf2d moneyTextSize=game->GetTextSizeProp(moneyText)*2;
+		auto moneyDisplay=artificerRefineWindow->ADD("Money Label",PlayerMoneyLabel)(geom2d::rect<float>{moneyIconPos+vf2d{26.f,4.f},moneyTextSize},2,1.85f,ComponentAttr::SHADOW|ComponentAttr::LEFT_ALIGN|ComponentAttr::FIT_TO_LABEL)END;
+		Player::AddMoneyListener(moneyDisplay);
+	#pragma endregion
 
-	auto backButton=artificerRefineWindow->ADD("Back",MenuComponent)(geom2d::rect<float>{{0.f,artificerRefineWindow->size.y-12.f},{120.f,12.f}},"Back",[](MenuFuncData data){
+	auto backButton{artificerRefineWindow->ADD("Back",MenuComponent)(geom2d::rect<float>{{0.f,artificerRefineWindow->size.y-12.f},{96.f,16.f}},"Back",[](MenuFuncData data){
 		Menu::CloseMenu();
 		return true;
-	})END;
+	})END};
+
 
 	Menu::AddInventoryListener(inventoryDisplay,"Accessories");
 
 	artificerRefineWindow->SetupKeyboardNavigation(
 	[](MenuType type,Data&returnData){ //On Open
-		returnData="";
+		auto&items{Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents()};
+		if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+		else if(items.size()>0)returnData=items[0];
+		else returnData="Back";
 	},
 	{ //Button Key
 		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
@@ -71,12 +168,49 @@ void Menu::InitializeArtificerRefineWindow(){
 			Menu::CloseMenu();
 		}}},
 		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+		{{game->KEY_SHOULDER2,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_SHOULDER,Pressed},{"Scroll Up/Down",[](MenuType type){}}},
+		{{game->KEY_FASTSCROLLUP,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->DecreaseSelectionIndex(3.f);
+		}}},
+		{{game->KEY_FASTSCROLLDOWN,PressedDAS},{"Scroll",[](MenuType type){
+			Menu::menus[type]->GetSelection().lock()->parentComponent.lock()->IncreaseSelectionIndex(3.f);
+		}}},
 	}
 	,{ //Button Navigation Rules
-		{"Sample Button",{
-			.up="",
-			.down="",
-			.left="",
-			.right="",}},
-	});
+		{"Accessory List",{
+			.up=[&](MenuType type,Data&returnData){
+				Menu::ScrollUp(type,"Accessory List",returnData,"Back");
+			},
+			.down=[&](MenuType type,Data&returnData){
+				Menu::ScrollDown(type,"Accessory List",returnData,"Back");
+			},
+			.left="Back",
+			.right=[&](MenuType type,Data&returnData){
+				Menu::menus[type]->GetSelection().lock()->Click();
+				returnData="Fragment Refine Button";
+			},}},
+		{"Back",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left="Fragment Refine Button",
+			.right="Fragment Refine Button",}},
+		{"Fragment Refine Button",{
+			.up=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().back().lock()->GetName();
+			},
+			.down=[&](MenuType type,Data&returnData){
+				returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetComponents().front().lock()->GetName();
+			},
+			.left=[&](MenuType type,Data&returnData){
+				if(Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild())returnData=Component<RowInventoryScrollableWindowComponent>(type,"Accessory List")->GetSelectedChild().value().get().GetName();
+				else returnData="Back";
+			},
+			.right="Back",}},
+	}
+	);
 }

Adventures in Lestoria/ArtificerWindow.cpp

@@ -43,22 +43,26 @@ All rights reserved.
 #include "Unlock.h"
 #include "MenuLabel.h"
 #include "VisualNovel.h"
+#include "RowInventoryScrollableWindowComponent.h"
 
 INCLUDE_game
 
 void Menu::InitializeArtificerWindow(){
 	Menu*artificerWindow=CreateMenu(ARTIFICER,CENTERED,vi2d{144,144});
 	
-	artificerWindow->ADD("Refine Button",MenuComponent)(geom2d::rect<float>{{0.f,4.f},{144.f,24.f}},"Refine",[](MenuFuncData data){
-		Menu::OpenMenu(MenuType::ARTIFICER_REFINE);
+	artificerWindow->ADD("Disassemble Button",MenuComponent)(geom2d::rect<float>{{0.f,4.f},{144.f,24.f}},"Disassemble",[](MenuFuncData data){
+		Menu::OpenMenu(MenuType::ARTIFICER_DISASSEMBLE);
+		Component<RowInventoryScrollableWindowComponent>(MenuType::ARTIFICER_DISASSEMBLE,"Accessory List")->ClearSelectedChild();
 		return true;
 	},vf2d{2.f,2.f},ButtonAttr::FIT_TO_LABEL)END;
-	artificerWindow->ADD("Disassemble Button",MenuComponent)(geom2d::rect<float>{{0.f,32.f},{144.f,24.f}},"Disassemble",[](MenuFuncData data){
-		Menu::OpenMenu(MenuType::ARTIFICER_DISASSEMBLE);
+	artificerWindow->ADD("Refine Button",MenuComponent)(geom2d::rect<float>{{0.f,32.f},{144.f,24.f}},"Refine",[](MenuFuncData data){
+		Menu::OpenMenu(MenuType::ARTIFICER_REFINE);
+		Component<RowInventoryScrollableWindowComponent>(MenuType::ARTIFICER_REFINE,"Accessory List")->ClearSelectedChild();
 		return true;
 	},vf2d{2.f,2.f},ButtonAttr::FIT_TO_LABEL)END;
 	artificerWindow->ADD("Enchant Button",MenuComponent)(geom2d::rect<float>{{0.f,60.f},{144.f,24.f}},"Enchant",[](MenuFuncData data){
 		Menu::OpenMenu(MenuType::ARTIFICER_ENCHANT);
+		Component<RowInventoryScrollableWindowComponent>(MenuType::ARTIFICER_ENCHANT,"Accessory List")->ClearSelectedChild();
 		return true;
 	},vf2d{2.f,2.f},ButtonAttr::FIT_TO_LABEL)END;
 	artificerWindow->ADD("Help Button",MenuComponent)(geom2d::rect<float>{{0.f,88.f},{144.f,24.f}},"Help",[](MenuFuncData data){
@@ -72,7 +76,7 @@ void Menu::InitializeArtificerWindow(){
 
 	artificerWindow->SetupKeyboardNavigation(
 	[](MenuType type,Data&returnData){ //On Open
-		returnData="Refine Button";
+		returnData="Disassemble Button";
 	},
 	{ //Button Key
 		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
@@ -82,20 +86,20 @@ void Menu::InitializeArtificerWindow(){
 		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
 	}
 	,{ //Button Navigation Rules
-		{"Refine Button",{
-			.up="Leave Button",
-			.down="Disassemble Button",}},
 		{"Disassemble Button",{
-			.up="Refine Button",
+			.up="Leave Button",
+			.down="Refine Button",}},
+		{"Refine Button",{
+			.up="Disassemble Button",
 			.down="Enchant Button",}},
 		{"Enchant Button",{
-			.up="Disassemble Button",
+			.up="Refine Button",
 			.down="Help Button",}},
 		{"Help Button",{
 			.up="Enchant Button",
 			.down="Leave Button",}},
 		{"Leave Button",{
 			.up="Help Button",
-			.down="Refine Button",}},
+			.down="Disassemble Button",}},
 	});
 }

Adventures in Lestoria/Attributable.h

@@ -40,50 +40,58 @@ All rights reserved.
 #include "DEFINES.h"
 #include <variant>
 
+using namespace std::literals;
+
 class IAttributable{
 public:
 	inline virtual ~IAttributable(){};
-	std::map<Attribute,std::variant<VARIANTS>>attributes;
+	std::map<Attribute,std::any>attributes;
 	inline float&GetFloat(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=0.f;
 		}
-		return std::get<float>(attributes[a]);
+		return std::any_cast<float&>(attributes[a]);
 	};
 	inline int&GetInt(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=0;
 		}
-		return std::get<int>(attributes[a]);
+		return std::any_cast<int&>(attributes[a]);
 	};
 	inline std::string&GetString(Attribute a){
 		if(attributes.count(a)==0){
-			attributes[a]="";
+			attributes[a]=""s;
 		}
-		return std::get<std::string>(attributes[a]);
+		return std::any_cast<std::string&>(attributes[a]);
 	};
 	inline bool&GetBool(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=false;		
 		}
-		return std::get<bool>(attributes[a]);
+		return std::any_cast<bool&>(attributes[a]);
 	};
 	inline vf2d&GetVf2d(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=vf2d{};		
 		}
-		return std::get<vf2d>(attributes[a]);
+		return std::any_cast<vf2d&>(attributes[a]);
 	};
 	inline std::vector<std::any>&GetVec(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=std::vector<std::any>{};		
 		}
-		return std::get<std::vector<std::any>>(attributes[a]);
+		return std::any_cast<std::vector<std::any>&>(attributes[a]);
+	};
+	inline std::any&GetAny(Attribute a){
+		if(attributes.count(a)==0){
+			attributes[a]=std::any{};		
+		}
+		return attributes[a];
 	};
 	inline size_t&GetSizeT(Attribute a){
 		if(attributes.count(a)==0){
 			attributes[a]=size_t(0);		
 		}
-		return std::get<size_t>(attributes[a]);
+		return std::any_cast<size_t&>(attributes[a]);
 	};
 };

Adventures in Lestoria/AttributableStat.h

@@ -113,6 +113,9 @@ public:
 	inline auto end()const{
 		return attributes.end();
 	}
+	inline auto size()const{
+		return attributes.size();
+	}
 	inline void clear(){
 		attributes.clear();
 	}

Adventures in Lestoria/Audio.cpp

@@ -41,6 +41,7 @@ All rights reserved.
 #include "util.h"
 #include "LoadingScreen.h"
 #include "Menu.h"
+#include "SoundEffect.h"
 
 INCLUDE_game
 INCLUDE_DATA
@@ -70,7 +71,12 @@ void Audio::Initialize(){
 
 			while(data.HasProperty(std::format("channel[{}]",channelCounter))){
 				std::string channelName=data[std::format("channel[{}]",channelCounter)].GetString();
+				if(!game->gamepack.Loaded()){
                     if(!std::filesystem::exists("bgm_directory"_S+channelName))ERR(std::format("WARNING! Could not load file {} for track {}",channelName,songFileName));
+	                if("GENERATE_GAMEPACK"_B){
+		                game->gamepack.AddFile("bgm_directory"_S+channelName);
+	                }
+                }
 				bgm.AddChannel(channelName);
 				channelCounter++;
 			}
@@ -121,8 +127,8 @@ MiniAudio&Audio::Engine(){
 void Audio::Play(const std::string_view sound){
 	Engine().Play(std::string(sound));
 };
-const size_t Audio::LoadAndPlay(const std::string_view sound,const bool loop){
-	size_t soundID=Engine().LoadSound(std::string(sound));
+const size_t Audio::LoadAndPlaySFX(const std::string_view sound,const bool loop){
+	size_t soundID=Engine().LoadSound(std::string(sound),MiniAudio::SFX);
 	Engine().Play(soundID,loop);
 	return soundID;
 };
@@ -379,6 +385,7 @@ void Audio::SetBGMVolume(float vol){
 	UpdateBGMVolume();
 }
 void Audio::SetBGMPitch(float pitch){
+	if(game->TestingModeEnabled())return;
 	BGM&track=Self().bgm[Self().playParams.sound];
 	for(int channelListIndex=0;int trackID:track.GetChannelIDs()){
 		Engine().SetPitch(trackID,pitch);
@@ -410,8 +417,11 @@ float Audio::GetCalculatedBGMVolume(const float channelVol){
 	}
 	return channelVol*GetBGMVolume()*GetMuteMult()*pauseMult;
 }
-float Audio::GetCalculatedSFXVolume(const float vol){
-	return vol*GetSFXVolume()*GetMuteMult();
+float Audio::GetCalculatedSFXVolume(const SoundEffect&sfx){
+	return sfx.TreatAsBPM()?Audio::GetCalculatedBGMVolume(sfx.GetVolume()):sfx.GetVolume()*GetSFXVolume()*GetMuteMult();
+}
+float Audio::GetCalculatedSFXVolume(const float sfxVol){
+	return sfxVol*GetSFXVolume()*GetMuteMult();
 }
 float Audio::GetMuteMult(){
 	if(muted)return 0.f;

Adventures in Lestoria/Audio.h

@@ -49,6 +49,8 @@ using ChannelIDList=std::vector<ChannelID>;
 using Volume=float;
 using VolumeList=std::vector<Volume>;
 
+class SoundEffect;
+
 class Audio{
 	friend class AiL;
 public:
@@ -59,7 +61,7 @@ public:
 	static void UpdateLoop();
 	static void Play(const std::string_view sound);
 	[[nodiscard]]
-	static const size_t LoadAndPlay(const std::string_view sound,const bool loop=true);
+	static const size_t LoadAndPlaySFX(const std::string_view sound,const bool loop=true);
 	//Prepares a BGM for loading. This means we call UpdateLoop() repeatedly until the loading of the music is complete. Names are found in bgm.txt configuration file.
 	static void PrepareBGM(const std::string_view sound,const bool loop=true);
 	//Play immediately a BGM given a name found in bgm.txt configuration file.
@@ -80,7 +82,8 @@ public:
 	//This will get a prepared BGM loop iteration count which is useful for loading stages.
 	static int GetPrepareBGMLoopIterations(std::string_view sound);
 	static float GetCalculatedBGMVolume(const float channelVol);
-	static float GetCalculatedSFXVolume(const float vol);
+	static float GetCalculatedSFXVolume(const SoundEffect&sfx);
+	static float GetCalculatedSFXVolume(const float sfxVol); //NOTE: This is a more manually invoked function! If you are trying to play a specific sound effect from an event, use the SoundEffect version instead!! This accounts for any additional flags related to volume.
 private:
 	bool trackLoadStarted=false;
 	bool trackLoadComplete=false;

Adventures in Lestoria/Bear.cpp

@@ -52,11 +52,11 @@ INCLUDE_MONSTER_DATA
 using A=Attribute;
 
 void Monster::STRATEGY::BEAR(Monster&m,float fElapsedTime,std::string strategy){
-	switch(m.I(A::PHASE)){
+	switch(PHASE()){
 		case 0:{
 			float distToPlayer=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).length();
 			if(distToPlayer<operator""_Pixels(ConfigFloat("Attack Range"))){
-				m.I(A::PHASE)=1;
+				SETPHASE(1);
 				m.PerformShootAnimation();
 				m.F(A::CASTING_TIMER)=ConfigFloat("Chargeup Time");
 				//The bear slam attack indicator will move with the bear, and the LOCKON_POS variable will hold a polar coordinate indicating distance and angle for where it should be attacking relative to its position.
@@ -75,7 +75,7 @@ void Monster::STRATEGY::BEAR(Monster&m,float fElapsedTime,std::string strategy){
 		case 1:{
 			m.F(A::CASTING_TIMER)=std::max(0.f,m.F(A::CASTING_TIMER)-fElapsedTime);
 			if(m.F(A::CASTING_TIMER)==0.f){
-				m.I(A::PHASE)=2;
+				SETPHASE(2);
 				m.F(A::CASTING_TIMER)=ConfigFloat("Attack Animation Wait Time");
 				m.PerformAnimation("SLAM");
 			}
@@ -85,7 +85,7 @@ void Monster::STRATEGY::BEAR(Monster&m,float fElapsedTime,std::string strategy){
 			if(m.F(A::CASTING_TIMER)==0.f){
 				float distToPlayer=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).length();
 				SoundEffect::PlaySFX("Bear Slam Attack",m.GetPos()+m.V(A::LOCKON_POS).cart());
-				m.I(A::PHASE)=0;
+				SETPHASE(0);
 				m.I(A::BEAR_STOMP_COUNT)++;
 				geom2d::circle<float>attackCircle={m.GetPos()+m.V(A::LOCKON_POS).cart(),float(operator""_Pixels(ConfigFloat("Smash Attack Diameter"))/2.f)};
 				if(geom2d::overlaps(attackCircle,game->GetPlayer()->Hitbox())){

Adventures in Lestoria/BlackHole.h

@@ -0,0 +1,59 @@
+#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 "AdventuresInLestoria.h"
+#include "util.h"
+#include "Effect.h"
+
+INCLUDE_MONSTER_LIST
+
+struct BlackHole:FadeInOutEffect{
+	inline BlackHole(Oscillator<vf2d>pos,const std::string&img,float lifetime,bool onUpperLevel,Oscillator<vf2d>size,vf2d spd,Oscillator<Pixel>col,float rotation,float rotationSpd,bool additiveBlending=false,float particleSpawnFreq=0.f,const std::function<Effect(const Effect&self)>&particleGenerator={})
+	:FadeInOutEffect(pos,img,lifetime,onUpperLevel,size,spd,col,rotation,rotationSpd,additiveBlending,particleSpawnFreq,particleGenerator){}
+	
+	inline bool Update(float fElapsedTime){
+		for(std::shared_ptr<Monster>&m:MONSTER_LIST){
+			float distToMonster{util::distance(pos,m->GetPos())};
+			if(!m->IsSolid()&&m->OnUpperLevel()==OnUpperLevel()&&m->GetZ()<1.f&&distToMonster<="Black Hole"_ENC["PULL IN RADIUS"]/100.f*24){
+				float pullInForce{util::map_range<float>(distToMonster,0,"Black Hole"_ENC["PULL IN RADIUS"]/100.f*24,"Black Hole"_ENC["PULL IN FORCE MAX"],"Black Hole"_ENC["PULL IN FORCE MIN"])};
+				m->AddAddedVelocity(util::pointTo(m->GetPos(),pos)*pullInForce);
+			}
+		}
+		return FadeInOutEffect::Update(fElapsedTime);
+	}
+};

Adventures in Lestoria/Boar.cpp

@@ -57,7 +57,7 @@ void Monster::STRATEGY::BOAR(Monster&m,float fElapsedTime,std::string strategy){
 		RECOVERY,
 	};
 
-	switch(m.phase){
+	switch(PHASE()){
 		case PhaseName::MOVE:{
 			float distToPlayer=m.GetDistanceFrom(game->GetPlayer()->GetPos());
 			if(m.canMove&&distToPlayer>=ConfigInt("Closein Range")/100.f*24){
@@ -75,7 +75,7 @@ void Monster::STRATEGY::BOAR(Monster&m,float fElapsedTime,std::string strategy){
 			ScratchPhaseTransition:
 				m.PerformAnimation("SCRATCH");
 				m.F(A::CASTING_TIMER)=ConfigInt("Ground Scratch Count")*m.GetCurrentAnimation().GetTotalAnimationDuration();
-				m.phase=PhaseName::SCRATCH;
+				SETPHASE(PhaseName::SCRATCH);
 
 				vf2d chargeTargetPoint=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).rpoint(ConfigFloat("Charge Distance")/100.f*24);
 				float distanceToChargePoint=geom2d::line<float>(m.GetPos(),chargeTargetPoint).length();
@@ -89,7 +89,7 @@ void Monster::STRATEGY::BOAR(Monster&m,float fElapsedTime,std::string strategy){
 			m.F(A::CASTING_TIMER)-=fElapsedTime;
 			if(m.F(A::CASTING_TIMER)<=0.f){
 				m.PerformShootAnimation();
-				m.phase=PhaseName::CHARGE;
+				SETPHASE(PhaseName::CHARGE);
 
 				m.AddBuff(BuffType::SPEEDBOOST,INFINITE,ConfigFloat("Charge Movespeed")/100.f-1);
 
@@ -102,7 +102,7 @@ void Monster::STRATEGY::BOAR(Monster&m,float fElapsedTime,std::string strategy){
 			float distToTarget=geom2d::line<float>(m.GetPos(),m.target).length();
 
 			auto TransitionToRecoveryPhase=[&](){
-				m.phase=PhaseName::RECOVERY;
+				SETPHASE(PhaseName::RECOVERY);
 				m.F(A::CHARGE_COOLDOWN)=ConfigFloat("Charge Recovery Time");
 				m.PerformIdleAnimation();
 			};
@@ -120,7 +120,7 @@ void Monster::STRATEGY::BOAR(Monster&m,float fElapsedTime,std::string strategy){
 			m.F(A::CHARGE_COOLDOWN)-=fElapsedTime;
 			m.targetAcquireTimer=0.f;
 			m.RemoveBuff(BuffType::SPEEDBOOST);
-			if(m.F(A::CHARGE_COOLDOWN)<=0)m.phase=PhaseName::MOVE;
+			if(m.F(A::CHARGE_COOLDOWN)<=0)SETPHASE(PhaseName::MOVE);
 		}break;
 	}
 }

Adventures in Lestoria/Bomb.cpp

@@ -103,7 +103,7 @@ BulletDestroyState Bomb::MonsterHit(Monster&monster,const uint8_t markStacksBefo
 
 void Bomb::Draw(const Pixel blendCol)const{
 	Bullet::Draw(blendCol);
-	game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},bomb_animation.GetFrame(animation).GetSourceImage()->Decal(),rotates?atan2(vel.y,vel.x)-PI/2:0,bomb_animation.GetFrame(animation).GetSourceRect().size/2,bomb_animation.GetFrame(animation).GetSourceRect().pos,bomb_animation.GetFrame(animation).GetSourceRect().size,scale,fadeOutTime==0?col:Pixel{col.r,col.g,col.b,uint8_t(util::lerp(col.a,0,1-((fadeOutTime-GetFadeoutTimer())/fadeOutTime)))});		
+	game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},bomb_animation.GetFrame(animation).GetSourceImage()->Decal(),rotates?atan2(vel.y,vel.x)-PI/2:0,bomb_animation.GetFrame(animation).GetSourceRect().size/2,bomb_animation.GetFrame(animation).GetSourceRect().pos,bomb_animation.GetFrame(animation).GetSourceRect().size,scale,fadeOutTime==0?col:Pixel{col.r,col.g,col.b,uint8_t(util::lerp(col.a,uint8_t(0),1-((fadeOutTime-GetFadeoutTimer())/fadeOutTime)))});		
 }
 
 void Bomb::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/BreakingPillar.cpp

@@ -56,11 +56,11 @@ void Monster::STRATEGY::BREAKING_PILLAR(Monster&m,float fElapsedTime,std::string
 		m.animation.ModifyDisplaySprite(m.internal_animState,ConfigString("Break Phase 1 Animation Name"));
 	}else m.animation.ModifyDisplaySprite(m.internal_animState,ConfigString("Break Phase 2 Animation Name"));
 
-	switch(m.phase){
+	switch(PHASE()){
 		case INITIALIZE:{
 			m.F(A::BREAK_TIME)=ConfigFloat("Break Time");
 			m.F(A::SHAKE_TIMER)=0.2f;
-			m.phase=RUN;
+			SETPHASE(RUN);
 
 			m.SetStrategyDeathFunction([&](GameEvent&deathEvent,Monster&m,const std::string&strategy){
 				m.lifetime=0.01f;

Adventures in Lestoria/Buff.cpp

@@ -41,7 +41,13 @@ All rights reserved.
 #include "Monster.h"
 
 Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity)
-		:attachedTarget(attachedTarget),type(type),duration(duration),intensity(intensity),originalDuration(this->duration){}
+	:Buff(attachedTarget,type,duration,intensity,[](std::weak_ptr<Monster>m,Buff&b){}){}
+
+Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,PlayerBuffExpireCallbackFunction expireCallbackFunc)
+:attachedTarget(attachedTarget),type(type),duration(duration),intensity(intensity),originalDuration(this->duration),playerBuffCallbackFunc(expireCallbackFunc){}
+Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,MonsterBuffExpireCallbackFunction expireCallbackFunc)
+:attachedTarget(attachedTarget),type(type),duration(duration),intensity(intensity),originalDuration(this->duration),monsterBuffCallbackFunc(expireCallbackFunc){}
+
 Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,std::set<ItemAttribute> attr)
 	:attachedTarget(attachedTarget),type(type),duration(duration),intensity(intensity),attr(attr),originalDuration(this->duration){}
 Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,std::set<std::string> attr)
@@ -112,6 +118,7 @@ Buff::Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType t
 	:attachedTarget(attachedTarget),type(type),restorationType(restorationType),duration(duration),intensity(intensity),nextTick(timeBetweenTicks),timeBetweenTicks(timeBetweenTicks),overTimeType(overTimeType),originalDuration(this->duration){}
 
 void Buff::Update(AiL*game,float fElapsedTime){
+	if(!waitOneTick){
 		duration-=fElapsedTime;
 		lifetime+=fElapsedTime;
 		if(enabled&&overTimeType.has_value()&&lifetime>=nextTick){
@@ -119,6 +126,8 @@ void Buff::Update(AiL*game,float fElapsedTime){
 			nextTick+=timeBetweenTicks;
 			if(restorationType==BuffRestorationType::ONE_OFF)enabled=false;
 		}
+	}
+	waitOneTick=false;
 }
 
 void Buff::BuffTick(AiL*game,float fElapsedTime){

Adventures in Lestoria/Buff.h

@@ -61,6 +61,13 @@ enum BuffType{
 	DAMAGE_AMPLIFICATION, //Multiplies all incoming damage by this amount.
 	LETHAL_TEMPO,
 	BURNING_ARROW_BURN,
+	SWORD_ENCHANTMENT,
+	CURSE_OF_PAIN,
+	CURSE_OF_DEATH,
+	AFFECTED_BY_LIGHTNING_BOLT, //Intensity indicates number of repeats remaining.
+	INK_SLOWDOWN, //Intensity indicates % movespd slowdown.
+	PIRATE_GHOST_CAPTAIN_CURSE, //A coin icon appears above the player's head.
+	PIRATE_GHOST_CAPTAIN_CURSE_DOT, //The same as above, but now is a damage over time as well.
 };
 enum class BuffRestorationType{
 	ONE_OFF, //This is used as a hack fix for the RestoreDuringCast Item script since they require us to restore 1 tick immediately. Over time buffs do not apply a tick immediately.
@@ -70,11 +77,11 @@ enum class BuffRestorationType{
 namespace BuffOverTimeType{
 	enum BuffOverTimeType{
 		HP_RESTORATION,
-		HP_PCT_RESTORATION,
+		HP_PCT_RESTORATION, //Percentage should be the raw percentage, NOT % form! (So 1 for 1%, not 0.01)
 		MP_RESTORATION,
-		MP_PCT_RESTORATION,
+		MP_PCT_RESTORATION, //Percentage should be the raw percentage, NOT % form! (So 1 for 1%, not 0.01)
 		HP_DAMAGE_OVER_TIME,
-		HP_PCT_DAMAGE_OVER_TIME,
+		HP_PCT_DAMAGE_OVER_TIME, //Percentage should be the raw percentage, NOT % form! (So 1 for 1%, not 0.01)
 	};
 };
 
@@ -85,7 +92,7 @@ struct Buff{
 	using MonsterBuffExpireCallbackFunction=std::function<void(std::weak_ptr<Monster>attachedTarget,Buff&b)>;
 
 	BuffType type;
-	BuffRestorationType restorationType;
+	BuffRestorationType restorationType{BuffRestorationType::ONE_OFF};
 	float duration=1;
 	float timeBetweenTicks=1;
 	float intensity=1;
@@ -100,6 +107,8 @@ struct Buff{
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity);
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,std::set<ItemAttribute> attr);
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,std::set<std::string> attr);
+	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,PlayerBuffExpireCallbackFunction expireCallbackFunc);
+	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffType type,float duration,float intensity,MonsterBuffExpireCallbackFunction expireCallbackFunc);
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffRestorationType restorationType,BuffOverTimeType::BuffOverTimeType overTimeType,float duration,float intensity,float timeBetweenTicks);
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffRestorationType restorationType,BuffOverTimeType::BuffOverTimeType overTimeType,float duration,float intensity,float timeBetweenTicks,PlayerBuffExpireCallbackFunction expireCallbackFunc);
 	Buff(std::variant<Player*,std::weak_ptr<Monster>>attachedTarget,BuffRestorationType restorationType,BuffOverTimeType::BuffOverTimeType overTimeType,float duration,float intensity,float timeBetweenTicks,MonsterBuffExpireCallbackFunction expireCallbackFunc);
@@ -109,6 +118,7 @@ struct Buff{
 
 	void Update(AiL*game,float fElapsedTime);
 private:
+	bool waitOneTick{true};
 	bool enabled{true}; //This is only turned off because the ONE_OFF effect. See BuffType::ONE_OFF for more details.
 	std::optional<BuffOverTimeType::BuffOverTimeType>overTimeType;
 	void BuffTick(AiL*game,float fElapsedTime);

Adventures in Lestoria/Bullet.cpp

@@ -41,6 +41,6 @@ All rights reserved.
 Bullet::Bullet(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col,vf2d scale,float image_angle)
 :IBullet(pos,vel,radius,damage,upperLevel,friendly,col,scale,image_angle){}
 //Initializes a bullet with an animation.
-Bullet::Bullet(vf2d pos,vf2d vel,float radius,int damage,std::string animation,bool upperLevel,bool hitsMultiple,float lifetime,bool rotatesWithAngle,bool friendly,Pixel col,vf2d scale,float image_angle,std::string_view hitSound)
+Bullet::Bullet(vf2d pos,vf2d vel,float radius,int damage,const std::string&animation,bool upperLevel,bool hitsMultiple,float lifetime,bool rotatesWithAngle,bool friendly,Pixel col,vf2d scale,float image_angle,std::string_view hitSound)
 :IBullet(pos,vel,radius,damage,animation,upperLevel,hitsMultiple,lifetime,rotatesWithAngle,friendly,col,scale,image_angle,hitSound){}
 void Bullet::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/Bullet.h

@@ -43,7 +43,7 @@ class Bullet:public IBullet{
 public:
 	Bullet(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f);
 	//Initializes a bullet with an animation.
-	Bullet(vf2d pos,vf2d vel,float radius,int damage,std::string animation,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool rotatesWithAngle=false,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f,std::string_view hitSound="");
+	Bullet(vf2d pos,vf2d vel,float radius,int damage,const std::string&animation,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool rotatesWithAngle=false,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f,std::string_view hitSound="");
 protected:
 	virtual void ModifyOutgoingDamageData(HurtDamageInfo&data);
 };

Adventures in Lestoria/BulletTypes.h

@@ -39,6 +39,10 @@ All rights reserved.
 #include "Bullet.h"
 #include "Direction.h"
 #include "Effect.h"
+#include "TrailEffect.h"
+#include "Entity.h"
+#include <variant>
+#include <memory>
 
 struct EnergyBolt:public Bullet{
 	float lastParticleSpawn=0;
@@ -56,15 +60,24 @@ struct FireBolt:public Bullet{
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
 	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
 	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	std::optional<std::reference_wrapper<TrailEffect>>flameTrail;
 };
 
 struct LightningBolt:public Bullet{
+	enum ChainLightningStatus{//Any other number represents something not defined here, the number of hits remaining.
+		ORIGINAL_BOLT=-1,
+		NO_MORE_HITS=0,
+	};
 	float lastParticleSpawn=0;
 	LightningBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
 	void Update(float fElapsedTime)override;
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
 	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
 	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	/*chainLightningRepeatCount - Set to higher amount to indicate when this monster instead affects monsters due to the enchantment, which changes which shock count variable we look at and will be used for counting down shock times.*/
+	static void ApplyLightningShock(const Monster&monster,const bool onUpperLevel,const ChainLightningStatus chainLightningRepeatCount=ORIGINAL_BOLT);
 };
 
 struct Arrow:public Bullet{
@@ -88,10 +101,13 @@ struct Arrow:public Bullet{
 struct ChargedArrow:public Bullet{
 	vf2d lastLaserPos;
 	ChargedArrow(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
+	ChargedArrow(const std::string&shotArrowGraphic,const std::string&laserGraphic,vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE);
 	void Update(float fElapsedTime)override;
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
 	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
 	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	std::string laserGraphic;
 };
 
 struct FrogTongue:public Bullet{
@@ -138,7 +154,7 @@ struct DaggerStab:public Bullet{
 	float daggerStabDistance;
 	float knockbackAmt;
 	DirectionOffsets daggerPositionOffsets;
-	DaggerStab(Monster&sourceMonster,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerStabDistance,const DirectionOffsets offsets,bool friendly=false,Pixel col=WHITE);
+	DaggerStab(Monster&sourceMonster,const std::string&image,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerStabDistance,const DirectionOffsets offsets,bool friendly=false,Pixel col=WHITE);
 	void Update(float fElapsedTime)override;
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
 	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
@@ -151,7 +167,7 @@ struct DaggerSlash:public Bullet{
 	float frameDuration;
 	float daggerSlashDistance;
 	float knockbackAmt;
-	DaggerSlash(Monster&sourceMonster,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerSlashDistance,bool friendly=false,Pixel col=WHITE);
+	DaggerSlash(Monster&sourceMonster,const std::string&image,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerSlashDistance,bool friendly=false,Pixel col=WHITE);
 	void Update(float fElapsedTime)override;
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
 	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
@@ -266,9 +282,9 @@ private:
 	const float knockbackAmt;
 };
 
-struct FallingStone:public Bullet{
-	//The position for this bullet represents where the falling stone should land.
-	FallingStone(vf2d targetPos,vf2d vel,float zVel,float indicatorDisplayTime,float radius,int damage,bool upperLevel,bool hitsMultiple=false,float knockbackAmt=0.f,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f,float spellCircleRotation=0.f,float spellCircleRotationSpd=0.f,Pixel insigniaCol=WHITE,float insigniaRotation=0.f,float insigniaRotationSpd=0.f);
+struct FallingBullet:public Bullet{
+	//The position for this bullet represents where the falling bullet should land.
+	FallingBullet(const std::string&imgName,vf2d targetPos,vf2d vel,float zVel,float indicatorDisplayTime,float radius,int damage,bool upperLevel,bool hitsMultiple=false,float knockbackAmt=0.f,float lifetime=INFINITE,bool friendly=false,Pixel spellCircleCol=WHITE,vf2d scale={1,1},float image_angle=0.f,float spellCircleRotation=0.f,float spellCircleRotationSpd=0.f,Pixel insigniaCol=WHITE,float insigniaRotation=0.f,float insigniaRotationSpd=0.f);
 protected:
 	void Update(float fElapsedTime)override;
 	void Draw(const Pixel blendCol)const override;
@@ -280,6 +296,7 @@ private:
 	SpellCircle indicator;
 	const float knockbackAmt;
 	float lastTrailEffect{};
+	const float collisionRadius{};
 };
 
 //While not a bullet directly, the DeadlyDash class generates a bunch of afterimages and collision checks.
@@ -318,11 +335,13 @@ private:
 	float automaticDetonationTime{};
 	float activationWaitTime{};
 	float lastBeepTime{};
+	int explosionCount{1};
+	float rearmTime{};
 	uint8_t beepCount{1U};
 };
 
 struct PurpleEnergyBall:public Bullet{
-	PurpleEnergyBall(vf2d pos,float radius,float homingRadius,int damage,bool upperLevel,vf2d speed,bool hitsMultiple=false,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1});
+	PurpleEnergyBall(vf2d pos,float radius,float homingRadius,int damage,bool upperLevel,vf2d speed,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1});
 	void Update(float fElapsedTime)override;
 	void Draw(const Pixel blendCol)const override;
 	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
@@ -330,20 +349,115 @@ struct PurpleEnergyBall:public Bullet{
 private:
 	const vf2d initialScale;
 	const float homingRadius;
+	int bounceCount{1};
+	float lastHitTimer{0.f};
+	std::optional<std::weak_ptr<Monster>>lastHitTarget;
 	std::optional<std::weak_ptr<Monster>>homingTarget;
 };
 
-struct PoisonBottle:public Bullet{
-	PoisonBottle(vf2d pos,vf2d targetPos,float explodeRadius,float z,float totalFallTime,float totalRiseZAmt,int damage,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle={0.f});
+struct ThrownProjectile:public Bullet{
+	ThrownProjectile(vf2d pos,vf2d targetPos,const std::string&img,float explodeRadius,float z,float totalFallTime,float totalRiseZAmt,int damage,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle={0.f},const std::optional<Effect>explodeEffect={},const std::optional<std::string>explodeSoundEffect={},const std::optional<LingeringEffect>lingeringEffect={});
 	void Update(float fElapsedTime)override;
 	void ModifyOutgoingDamageData(HurtDamageInfo&data);
-private:
+	void _OnGroundLand();
+	virtual void OnGroundLand(); //This is called when the projectile lands, damage is not dealt yet, default behavior just deals damage in the area.
+protected:
 	const vf2d targetPos;
 	const vf2d startingPos;
 	const float totalFallTime;
-	const float originalRisingTime,originalFallingTime;
+	float originalRisingTime;
+	float originalFallingTime;
 	float risingTime,fallingTime;
 	const float initialZ;
 	const float totalRiseZAmt;
 	const float explodeRadius;
+	const std::optional<Effect>explodeEffect;
+	const std::optional<std::string>explodeSoundEffect;
+	const std::optional<LingeringEffect>lingeringEffect;
+	const std::string img;
+};
+
+struct PoisonBottle:public ThrownProjectile{
+	PoisonBottle(vf2d pos,vf2d targetPos,const std::string&img,float explodeRadius,float bounceExplodeRadius,float z,float totalFallTime,float totalRiseZAmt,int damage,int additionalBounceCount,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle={0.f});
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+	virtual void OnGroundLand()override final; //This is called when the projectile lands, damage is not dealt yet, default behavior just deals damage in the area.
+private:
+	const float bounceExplodeRadius;
+	int additionalBounceCount;
+};
+
+struct BurstBullet:public Bullet{
+	BurstBullet(vf2d pos,vf2d vel,const Entity target,const float explodeDist,const int extraBulletCount,const float extraBulletHeadingAngleChange,const float extraBulletRadius,const vf2d extraBulletScale,const float extraBulletStartSpeed,const float extraBulletAcc,float radius,int damage,bool upperLevel,bool friendly,Pixel col,vf2d scale);
+	void Update(float fElapsedTime)override;
+	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
+	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	void Explode();
+	const Entity target;
+	const float explodeDist;
+	Oscillator<vf2d>scaleOscillator;
+	bool activated{false};
+	float explodeTimer{0.f};
+	const int extraBulletCount;
+	const float extraBulletHeadingAngleChange; //In radians.
+	const float extraBulletRadius;
+	const vf2d extraBulletScale;
+	const float extraBulletAcc;
+	const float extraBulletStartSpeed;
+};
+
+struct RotateBullet:public Bullet{
+	//headingAngleChange determines how the startingAngle adjusts over time (in radians).
+	RotateBullet(vf2d pos,float startingAng,float startSpeed,float acc,float headingAngleChange,float radius,int damage,bool upperLevel,bool friendly,Pixel col);
+	void Update(float fElapsedTime)override;
+	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
+	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	const float headingAngleChange;
+};
+
+struct InkBullet:public Bullet{
+	InkBullet(const vf2d pos,const vf2d targetPos,const vf2d vel,const float inkExplosionRadius,const float inkPuddleLifetime,const float inkSlowdownDuration,const float inkSlowdownPct,const float inkPuddleRadius,const bool upperLevel,const bool friendly);
+	void Update(float fElapsedTime)override;
+	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
+	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	void Splat();
+	const vf2d targetPos;
+	const float inkExplosionRadius;
+	const float inkSlowdownPct;
+	const float inkSlowdownDuration;
+	const float inkPuddleLifetime;
+	const float inkPuddleRadius;
+};
+
+struct HomingBullet:public Bullet{
+	HomingBullet(const vf2d pos,const Entity target,const float rotateTowardsSpeed,const float rotateTowardsSpeedCoveredInInk,const float lifetime,const float speed,const float radius,const int damage,const bool upperLevel,const bool friendly=false,const Pixel col=WHITE,const vf2d scale={1,1},const float image_angle=0.f);
+	void Update(float fElapsedTime)override;
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	const Entity target;
+	const float rotateTowardsSpeed;
+	const float rotateTowardsSpeedCoveredInInk;
+};
+
+struct GhostSaber:public Bullet{
+	GhostSaber(const vf2d pos,const std::weak_ptr<Monster>target,const float lifetime,const float distFromTarget,const float knockbackAmt,const float initialRot,const float radius,const float expandSpd,const int damage,const bool upperLevel,const float rotSpd,const bool friendly=false,const Pixel col=WHITE,const vf2d scale={1,1},const float image_angle=0.f);
+	void Update(float fElapsedTime)override;
+	BulletDestroyState PlayerHit(Player*player)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _PlayerHit()!!
+	BulletDestroyState MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)override;//DO NOT CALL THIS DIRECTLY! INSTEAD USE _MonsterHit()!!
+	void ModifyOutgoingDamageData(HurtDamageInfo&data);
+private:
+	const std::weak_ptr<Monster>attachedMonster;
+	const float rotSpd;
+	float distFromTarget;
+	float rot;
+	const float knockbackAmt;
+	float particleTimer{};
+	float aliveTime{};
+	float expandSpd{};
+	Oscillator<uint8_t>alphaOscillator{128U,255U,0.6f};
 };

Adventures in Lestoria/BurstBullet.cpp

@@ -0,0 +1,104 @@
+#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 "BulletTypes.h"
+#include "Effect.h"
+#include "AdventuresInLestoria.h"
+#include "DEFINES.h"
+#include "util.h"
+#include "SoundEffect.h"
+#include "TrailEffect.h"
+#include <ranges>
+
+INCLUDE_game
+INCLUDE_MONSTER_LIST
+INCLUDE_ANIMATION_DATA
+
+BurstBullet::BurstBullet(vf2d pos,vf2d vel,const Entity target,const float explodeDist,const int extraBulletCount,const float extraBulletHeadingAngleChange,const float extraBulletRadius,const vf2d extraBulletScale,const float extraBulletStartSpeed,const float extraBulletAcc,float radius,int damage,bool upperLevel,bool friendly,Pixel col,vf2d scale)
+	:Bullet(pos,vel,radius,damage,"burstrotatebullet.png",upperLevel,false,INFINITE,true,friendly,col,scale),extraBulletStartSpeed(extraBulletStartSpeed),extraBulletAcc(extraBulletAcc),extraBulletRadius(extraBulletRadius),extraBulletScale(extraBulletScale),extraBulletHeadingAngleChange(extraBulletHeadingAngleChange),extraBulletCount(extraBulletCount),target(target),explodeDist(explodeDist),scaleOscillator({0.85f,0.85f},{1.f,1.f},0.3f){
+	animation.mult=0.f; //Prevent animating.
+}
+
+void BurstBullet::Explode(){
+	fadeOutTime=0.1f;
+	HurtType targets{friendly?HurtType::MONSTER:HurtType::PLAYER};
+	for(const auto&[target,isHurt]:game->Hurt(pos,radius,damage,OnUpperLevel(),GetZ(),targets)){
+		if(isHurt){
+			Entity ent{target};
+			ent.SetIframeTime(0.3f);
+		}
+	}
+	SoundEffect::PlaySFX("Burst Bullet Explode",pos);
+	for(int i:std::ranges::iota_view(0,extraBulletCount+1)){
+		const float angle{(360.f/extraBulletCount)*i};
+		const vf2d newPos{pos+vf2d{radius/2.f,angle}.cart()};
+		CreateBullet(RotateBullet)(newPos,angle,extraBulletStartSpeed,extraBulletAcc,extraBulletHeadingAngleChange,extraBulletRadius,damage,OnUpperLevel(),friendly,WHITE)EndBullet;
+	}
+	Deactivate();
+}
+
+void BurstBullet::Update(float fElapsedTime){
+	if(IsActivated()){
+		if(!activated){
+			scaleOscillator.Update(fElapsedTime);
+			if(util::distance(target.GetPos(),pos)<=explodeDist){
+				activated=true;
+				animation.mult=1.f;
+				explodeTimer=ANIMATION_DATA[animation.currentStateName].GetTotalAnimationDuration();
+			}
+		}else if(explodeTimer>0.f){
+			explodeTimer-=fElapsedTime;
+			if(explodeTimer<=0.f)Explode();
+		}
+	}
+}
+
+BulletDestroyState BurstBullet::PlayerHit(Player*player){
+	Explode();
+	player->ApplyIframes(0.2f);
+	return BulletDestroyState::KEEP_ALIVE;
+}
+
+BulletDestroyState BurstBullet::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit){
+	Explode();
+	monster.ApplyIframes(0.2f);
+	return BulletDestroyState::KEEP_ALIVE;
+}
+
+void BurstBullet::ModifyOutgoingDamageData(HurtDamageInfo&data){
+	data.damage=0; //Nullify the damage because proximity damage will occur instead.
+}

Adventures in Lestoria/Chapter_3_FinalBoss.txt

@@ -0,0 +1,49 @@
+Ghost of Pirate Captain
+
+60 000 HP
+Size 600%
+Movespeed 50%
+
+Damage:
+Canonshot 80 dmg
+Shrapnel 35 dmg
+Sabres 75 dmg
+Collision 50 dmg
+Curse nothing for first 15 seconds, after that 5 dmg per second.
+
+----------------------
+
+Skills:
+- Command Canons (2 Kinds of Attack, Big Canon Balls and spreaded shrapnel shot)
+- Spreading the curse (The Ghost Throws a Coin towards the Player, and the Player gets marked. starts getting dot damage after time if the coin doesnt get returned to the Pirate Treasure, which has a fixed position on the map)
+- Hide and Seek (The Ghost hides Behind a Rock, and Canons Bombard the area until player hits the Captain once)
+- Ghost Sabers (Spinning Ghost Swords)
+
+- 70%, 40% & 10% Curse + Hide - permanent Bombardment + Shrapnel Shot every 5 seconds.
+
+Once found on the 10% Hide and Seek Spawns a Cage around the Pirate Treasure, and Spreads the curse on the player again. (If player didnt cleanse the curse before finding the captain it just stays up.)
+Both kind of Canon attacks happen at all time now, 10 Ghost Sabers spawn that circle around the boss in different directions
+Boss stands still in the middle (maybe raising an arm animation wise or something to show that he is controlling the Sabers)
+
+----------------------
+Normal Fight
+
+Canon Shots happen with a 0,4 second delay. between shooting an impact is a 2.5 second delay.
+Canon have a 350 impact size
+
+Shrapnel shoots similar to small bolders from chapter 2 boss. 25 hits, 50 radius. Delay between shooting and impact also 2.5 seconds.
+
+its 8 canon shots, 2 second silence, 1 shrapnel shot, 2 second silence, repeat.
+
+the Canon shots can happen in one of the following patterns:
+- Bombardment: every shot is at a random location within 900 Range of the player. (This is also the move during hide and seek.)
+- precise Bombardment: same as before but within 700 range of the player.
+- Shooting in a line: the 4th or 5th hit would hit the player if the player doesnt move at all.
+- Sharpshooter: aiming directly at the player, skipping every 2nd shot. (only 4 instead of 8 shots)
+- prediction: shoots in the direction of the current or last players movement and predicts where the player would be in 2.8 seconds. (slightly further then where the player would be at impact. thats why 2.8 instead of 2.5 seconds)
+
+Boss spawns after the first Canon rotation ends.
+
+Boss constantly Slowly floats towards player, within 400 range it uses Ghost Sabers once every 4 seconds. (Throws them, Similar movement like Hammers of a Hammerdin in Diablo 2 - https://www.youtube.com/watch?v=jZfH4SY4Lsc - both the spinning animation and the flightpath are a good example. Sabre always spawn of oposite side towards player to give meeles time to dodge.)
+On Collision damage trigger a slash animation with its saber.
+

Adventures in Lestoria/CharacterMenuWindow.cpp

@@ -76,31 +76,9 @@ namespace CharacterMenuWindow{
 	std::shared_ptr<RowItemDisplay>GenerateItemDisplay(std::shared_ptr<ScrollableWindowComponent>parent,int invIndex,const std::weak_ptr<Item>it){
 		auto component=parent->ADD("Equip Item "+std::to_string(invIndex),T)(geom2d::rect<float>{{2,2+invIndex*29.f},{120-15,28}},it,
 			[&](MenuFuncData data){
-				const auto SelectedEquipIsDifferent=[](std::weak_ptr<RowItemDisplay>comp){
-					EquipSlot slot=EquipSlot(comp.lock()->I(Attribute::EQUIP_TYPE));
-					std::weak_ptr<Item>currentItem=Inventory::GetEquip(slot);
-
-					switch(slot){
-						case EquipSlot::RING1:
-						case EquipSlot::RING2:{
-							std::weak_ptr<Item>otherItem;
-
-							if(slot&EquipSlot::RING1)otherItem=Inventory::GetEquip(EquipSlot::RING2);
-							else
-							if(slot&EquipSlot::RING2)otherItem=Inventory::GetEquip(EquipSlot::RING1);
-							return ISBLANK(otherItem)||
-								(&*comp.lock()->GetItem().lock()!=&*otherItem.lock()&&
-								&*comp.lock()->GetItem().lock()!=&*currentItem.lock());
-						}break;
-						default:{
-							return &*comp.lock()->GetItem().lock()!=&*currentItem.lock();
-						}
-					}
-				};
-
 				std::weak_ptr<T>comp=DYNAMIC_POINTER_CAST<T>(data.component.lock());
 				if(!comp.expired()){
-					if(SelectedEquipIsDifferent(comp)){ //If we find that the opposite ring slot is equipped to us, this would be an item swap or the exact same ring, therefore no stat calculations apply.
+					if(Item::SelectedEquipIsDifferent(comp.lock()->GetItem(),EquipSlot(comp.lock()->I(Attribute::EQUIP_TYPE)))){ //If we find that the opposite ring slot is equipped to us, this would be an item swap or the exact same ring, therefore no stat calculations apply.
 						Inventory::EquipItem(comp.lock()->GetItem(),EquipSlot(comp.lock()->I(Attribute::EQUIP_TYPE)));
 
 						#pragma region Fully Decked Out Achievement
@@ -199,6 +177,10 @@ void Menu::InitializeCharacterMenuWindow(){
 		EquipSlot slot=EquipSlot(equipSlot);
 		auto equipmentSlot=characterMenuWindow->ADD("Equip Slot "+CharacterMenuWindow::slotNames[i],EquipSlotButton)(geom2d::rect<float>{{x,y+28},{24,24}},slot,
 			[&](MenuFuncData data){
+				if(game->GetCurrentMap().GetMapType()!=Map::MapType::HUB&&game->GetCurrentMap().GetMapType()!=Map::MapType::WORLD_MAP){
+					game->AddNotification(AiL::Notification{"Cannot change equipment in a stage!",5.f,YELLOW});
+					return false;
+				}
 				EquipSlot slot=EquipSlot(data.component.lock()->I(Attribute::EQUIP_TYPE));
 				data.menu.I(A::EQUIP_TYPE)=int(slot);
 
@@ -225,28 +207,6 @@ void Menu::InitializeCharacterMenuWindow(){
 					
 					equip->SetHoverFunc(
 						[&](MenuFuncData data){
-							const auto SelectedEquipIsDifferent=[](std::weak_ptr<RowItemDisplay>comp){
-								EquipSlot slot=EquipSlot(comp.lock()->I(Attribute::EQUIP_TYPE));
-								std::weak_ptr<Item>currentItem=Inventory::GetEquip(slot);
-
-								switch(slot){
-									case EquipSlot::RING1:
-									case EquipSlot::RING2:{
-										std::weak_ptr<Item>otherItem;
-
-										if(slot&EquipSlot::RING1)otherItem=Inventory::GetEquip(EquipSlot::RING2);
-										else
-										if(slot&EquipSlot::RING2)otherItem=Inventory::GetEquip(EquipSlot::RING1);
-										return ISBLANK(otherItem)||
-											(&*comp.lock()->GetItem().lock()!=&*otherItem.lock()&&
-											&*comp.lock()->GetItem().lock()!=&*currentItem.lock());
-									}break;
-									default:{
-										return &*comp.lock()->GetItem().lock()!=&*currentItem.lock();
-									}
-								}
-							};
-
 							if(!data.component.lock()->GetSubcomponentParent().expired())return true;
 							std::weak_ptr<RowItemDisplay>button=DYNAMIC_POINTER_CAST<RowItemDisplay>(data.component.lock());
 							if(!button.expired()){
@@ -265,7 +225,7 @@ void Menu::InitializeCharacterMenuWindow(){
 								if(slot&EquipSlot::RING1)otherItem=Inventory::GetEquip(EquipSlot::RING2);
 								else
 								if(slot&EquipSlot::RING2)otherItem=Inventory::GetEquip(EquipSlot::RING1);
-								if(SelectedEquipIsDifferent(button.lock())){ //If we find that the opposite ring slot is equipped to us, this would be an item swap or the exact same ring, therefore no stat calculations apply.
+								if(Item::SelectedEquipIsDifferent(button.lock()->GetItem(),slot)){ //If we find that the opposite ring slot is equipped to us, this would be an item swap or the exact same ring, therefore no stat calculations apply.
 									Inventory::EquipItem(buttonItem,slot);
 									for(int counter=0;const CharacterMenuWindow::AttributeData&attribute:CharacterMenuWindow::displayAttrs){
 										std::weak_ptr<StatLabel>statDisplayLabel=Component<StatLabel>(CHARACTER_MENU,"Attribute "+std::string(ItemAttribute::Get(attribute.attrName).Name())+" Label");
@@ -516,28 +476,10 @@ void Menu::InitializeCharacterMenuWindow(){
 	,{ //Button Navigation Rules
 		{"Equip List",{
 			.up=[](MenuType type,Data&returnData){
-				if(!Menu::menus[type]->GetSelection().expired()){
-					auto selection=Menu::menus[type]->GetSelection().lock();
-					size_t index=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponentIndex(selection);
-					index--;
-					if(index>=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponents().size()){
-						returnData="Equip Selection Select Button";
-					}else{
-						returnData=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponents()[index];
-					}
-				}
+				Menu::ScrollUp(type,"Equip List",returnData,"Equip Selection Select Button");
 			},
 			.down=[](MenuType type,Data&returnData){
-				if(!Menu::menus[type]->GetSelection().expired()){
-					auto selection=Menu::menus[type]->GetSelection().lock();
-					size_t index=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponentIndex(selection);
-					index++;
-					if(index>=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponents().size()){
-						returnData="Equip Selection Select Button";
-					}else{
-						returnData=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponents()[index];
-					}
-				}
+				Menu::ScrollDown(type,"Equip List",returnData,"Equip Selection Select Button");
 			},
 			.left=[](MenuType type,Data&returnData){
 				auto equipList=Component<ScrollableWindowComponent>(type,"Equip List")->GetComponents();

Adventures in Lestoria/ChargedArrow.cpp

@@ -45,9 +45,12 @@ All rights reserved.
 INCLUDE_game
 
 ChargedArrow::ChargedArrow(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col)
-	:lastLaserPos(pos),
-	Bullet(pos,vel,radius,damage,
-		"charged_shot_arrow.png",upperLevel,true,INFINITE,true,friendly,col){}
+	:lastLaserPos(pos),laserGraphic("laser.png"),
+	Bullet(pos,vel,radius,damage,"charged_shot_arrow.png",upperLevel,true,INFINITE,true,friendly,col){}
+
+ChargedArrow::ChargedArrow(const std::string&shotArrowGraphic,const std::string&laserGraphic,vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col)
+	:lastLaserPos(pos),laserGraphic(laserGraphic),
+	Bullet(pos,vel,radius,damage,shotArrowGraphic,upperLevel,true,INFINITE,true,friendly,col){}
 
 void ChargedArrow::Update(float fElapsedTime){
 	geom2d::line lineToCurrentPos(geom2d::line(lastLaserPos,pos));
@@ -55,10 +58,10 @@ void ChargedArrow::Update(float fElapsedTime){
 	if(dist>=1){
 		vf2d midpoint(lineToCurrentPos.rpoint(0.5));
 
-		const float normalBeamRadius{12*"Ranger.Ability 2.Radius"_F/100};
+		const float normalBeamRadius{12*"Ranger.Ability 2.Radius"_F/100/5};
 		float laserWidth{radius/normalBeamRadius};
 
-		game->AddEffect(std::make_unique<Effect>(midpoint,0.1f,"laser.png",upperLevel,vf2d{laserWidth,dist*2},0.3f,vf2d{},Pixel{192,128,238},atan2(pos.y-lastLaserPos.y,pos.x-lastLaserPos.x)+PI/2,0,true));
+		game->AddEffect(std::make_unique<Effect>(midpoint,0.1f,laserGraphic,upperLevel,vf2d{laserWidth,dist*2},0.3f,vf2d{},Pixel{192,128,238},atan2(pos.y-lastLaserPos.y,pos.x-lastLaserPos.x)+PI/2,0,true));
 		lastLaserPos=pos;
 	}
 }

Adventures in Lestoria/ClassSelectionWindow.cpp

@@ -50,6 +50,7 @@ All rights reserved.
 #endif
 
 INCLUDE_game
+INCLUDE_DEMO_BUILD
 using A=Attribute;
 
 void Menu::InitializeClassSelectionWindow(){
@@ -168,6 +169,12 @@ void Menu::InitializeClassSelectionWindow(){
 		
 		classSprite->S(A::CLASS_SELECTION)=className;
 
+		if(DEMO_BUILD&&i>2){ //Disable the three later classes in the demo build.
+			classLabel->SetGrayedOut(true);
+			classButton->SetGrayedOut(true);
+			classSprite->SetGrayedOut(true);
+		}
+
 		toggleGroup.push_back(classSprite);
 	}
 

Adventures in Lestoria/ConnectionPoint.cpp

@@ -55,6 +55,6 @@ void ConnectionPoint::ResetVisitedFlag(){
 	visited=false;
 }
 
-const bool ConnectionPoint::Visited()const{
+[[nodiscard]]const bool ConnectionPoint::Visited()const{
 	return visited;
 }

Adventures in Lestoria/Crab.cpp

@@ -0,0 +1,118 @@
+#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 "MonsterStrategyHelpers.h"
+#include "util.h"
+#include "AdventuresInLestoria.h"
+#include "SoundEffect.h"
+#include "BulletTypes.h"
+
+using A=Attribute;
+
+INCLUDE_game
+
+void Monster::STRATEGY::CRAB(Monster&m,float fElapsedTime,std::string strategy){
+	enum PhaseName{
+		INIT,
+		MOVE,
+		PREPARE_CHARGE,
+		CHARGE,
+	};
+
+	switch(PHASE()){
+		case INIT:{
+			m.B(A::RANDOM_DIRECTION)=util::random()%2;
+			m.F(A::RANDOM_RANGE)=util::random_range(ConfigPixelsArr("Random Direction Range",0),ConfigPixelsArr("Random Direction Range",1));
+			SETPHASE(MOVE);
+		}break;	
+		case MOVE:{
+			m.F(A::ATTACK_COOLDOWN)+=fElapsedTime;
+			m.F(A::LAST_JUMP_TIMER)+=fElapsedTime;
+
+			float distToPlayer=m.GetDistanceFrom(game->GetPlayer()->GetPos());
+
+			const bool outsideMaxShootingRange=distToPlayer>=ConfigPixelsArr("Stand Still and Shoot Range",1);
+
+			if(m.F(A::LAST_JUMP_TIMER)>=ConfigFloat("Stop Check Interval")){
+				if(util::random(100)<=ConfigFloat("Stop Percent")){
+					SETPHASE(PREPARE_CHARGE);
+					m.PerformAnimation("CHARGEUP",m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
+					m.F(A::CASTING_TIMER)=ConfigFloat("Charge Wait Time");
+					m.target=game->GetPlayer()->GetPos()+util::distance(m.GetPos(),game->GetPlayer()->GetPos())*util::pointTo(m.GetPos(),game->GetPlayer()->GetPos());
+				}else
+				if(util::random(100)<=ConfigFloat("Change Direction Chance"))m.B(A::RANDOM_DIRECTION)=!m.B(A::RANDOM_DIRECTION);
+				m.F(A::LAST_JUMP_TIMER)=0.f;
+			}else
+			if(outsideMaxShootingRange){
+				m.target=game->GetPlayer()->GetPos();
+				RUN_TOWARDS(m,fElapsedTime,"Run Towards");
+			}else
+			if(distToPlayer<ConfigPixels("Run Away Range")){
+				m.target=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).upoint(-1);
+				RUN_TOWARDS(m,fElapsedTime,"Run Towards");
+			}else
+			if(distToPlayer>=ConfigPixelsArr("Random Direction Range",0)&&distToPlayer<ConfigPixelsArr("Random Direction Range",1)){
+				#define CW true
+				#define CCW false
+				//We are going to walk in a circular direction either CW or CCW (determined in windup phase)
+				float dirFromPlayer=util::angleTo(game->GetPlayer()->GetPos(),m.GetPos());
+				float targetDir=m.B(A::RANDOM_DIRECTION)==CW?dirFromPlayer+PI/4:dirFromPlayer-PI/4;
+				m.target=game->GetPlayer()->GetPos()+vf2d{m.F(A::RANDOM_RANGE),targetDir}.cart();
+				RUN_TOWARDS(m,fElapsedTime,"Run Towards");		
+				m.F(A::CHASE_TIMER)=1.f;
+			}
+		}break;
+		case PREPARE_CHARGE:{
+			m.F(A::CASTING_TIMER)-=fElapsedTime;
+			if(m.F(A::CASTING_TIMER)<=0.f){
+				SETPHASE(CHARGE);
+				m.F(A::CHASE_TIMER)=ConfigFloat("Charge Max Time");
+				m.PerformAnimation("PINCER");
+			}
+		}break;
+		case CHARGE:{
+			m.F(A::CHASE_TIMER)-=fElapsedTime;
+			RUN_TOWARDS(m,fElapsedTime,"Run Towards");
+			if(m.F(A::CHASE_TIMER)<=0.f||m.ReachedTargetPos()){
+				SETPHASE(MOVE);
+				m.B(A::RANDOM_DIRECTION)=util::random()%2;
+				m.F(A::RANDOM_RANGE)=util::random_range(ConfigPixelsArr("Random Direction Range",0),ConfigPixelsArr("Random Direction Range",1));
+			}
+		}break;
+	}
+}

Adventures in Lestoria/CraftItemWindow.cpp

@@ -70,7 +70,7 @@ void Menu::InitializeCraftItemWindow(){
 				for(const auto&[name,amt]:consumedResources.GetItems()){
 					Inventory::RemoveItem(Inventory::GetItem(name)[0],amt);
 				}
-				game->GetPlayer()->SetMoney(game->GetPlayer()->GetMoney()-consumedResources.GetCost());
+				game->GetPlayer()->RemoveMoney(consumedResources.GetCost());
 
 				Inventory::UpdateBlacksmithInventoryLists();
 				SoundEffect::PlaySFX("Craft Equip",SoundEffect::CENTERED);

Adventures in Lestoria/Crawler_Artificer.txt

@@ -36,7 +36,7 @@ Artificer has 4 Dialog Options
 
 
 
-Enhancing Gear
+Refining Gear
 - increases the stats of an item.
 - Increases a random stat by a random amount that did not reach its cap. (cant go higher then 20% of its current amount in on Enhance attempt and cant go higher then the max stat value of the item)
 - Costs 1 piece of the Ring you want to enhance + 20g

Adventures in Lestoria/DEFINES.h

@@ -62,6 +62,8 @@ using MonsterSpawnerID=int;
 #define INCLUDE_WINDOW_SIZE extern vi2d WINDOW_SIZE;
 #define INCLUDE_ITEM_CONVERSIONS extern safemap<std::string,IT>ITEM_CONVERSIONS;
 #define INCLUDE_ADMIN_MODE extern bool ADMIN_MODE;
+#define INCLUDE_DEMO_BUILD extern bool DEMO_BUILD;
+#define INCLUDE_ITEM_SCRIPTS extern safemap<std::string,ItemScript>ITEM_SCRIPTS;
 
 #define INCLUDE_PACK_KEY extern std::string PACK_KEY;
 
@@ -79,6 +81,8 @@ using MonsterSpawnerID=int;
 #undef INFINITE
 #define INFINITE 999999
 
+#define MAX_BULLETS size_t(512)
+
 #define SETUP_CLASS(class) \
 class::class() \
     :Player::Player(){} \
@@ -86,11 +90,16 @@ class::class(Player*player) \
     :Player::Player(player){} \
 Class class::GetClass(){return cl;} \
 void class::CreateOriginalCopies(){ \
-original_rightClickAbility=rightClickAbility; \
-original_ability1=ability1; \
-original_ability2=ability2; \
-original_ability3=ability3; \
-original_ability4=ability4; \
+    original_rightClickAbility=rightClickAbility; \
+    original_ability1=ability1; \
+    original_ability2=ability2; \
+    original_ability3=ability3; \
+    original_ability4=ability4; \
+    original_rightClickAbility.isOriginalAbility=true; \
+    original_ability1.isOriginalAbility=true; \
+    original_ability2.isOriginalAbility=true; \
+    original_ability3.isOriginalAbility=true; \
+    original_ability4.isOriginalAbility=true; \
 } \
 void class::ResetToOriginalAbilities(){ \
 rightClickAbility.COOLDOWN_TIME=original_rightClickAbility.COOLDOWN_TIME; \
@@ -115,6 +124,19 @@ Ability&class::GetAbility1(){return ability1;}; \
 Ability&class::GetAbility2(){return ability2;}; \
 Ability&class::GetAbility3(){return ability3;}; \
 Ability&class::GetAbility4(){return ability4;}; \
+Ability&class::_GetOriginalAbility1(){return GetOriginalAbility1();}; \
+Ability&class::_GetOriginalAbility2(){return GetOriginalAbility2();}; \
+Ability&class::_GetOriginalAbility3(){return GetOriginalAbility2();}; \
+Ability&class::_GetOriginalRightClickAbility(){return GetOriginalRightClickAbility();}; \
+Ability&class::GetOriginalAbility1(){return original_ability1;}; \
+Ability&class::GetOriginalAbility2(){return original_ability2;}; \
+Ability&class::GetOriginalAbility3(){return original_ability3;}; \
+Ability&class::GetOriginalRightClickAbility(){return original_rightClickAbility;}; \
+void class::SetAbility4(const Ability&originalAbility){ \
+    auto it=std::find(Player::ABILITY_LIST.begin(),Player::ABILITY_LIST.end(),originalAbility); \
+    if(it==Player::ABILITY_LIST.end())ERR(std::format("WARNING! Could not find ability {} in original ability list! This function MUST be supplied with an original ability. Was original ability: {}",originalAbility.name,originalAbility.isOriginalAbility)); \
+    class::original_ability4=class::ability4=originalAbility; \
+} \
 std::string&class::GetWalkNAnimation(){return walk_n;}; \
 std::string&class::GetWalkEAnimation(){return walk_e;}; \
 std::string&class::GetWalkSAnimation(){return walk_s;}; \

Adventures in Lestoria/DaggerSlash.cpp

@@ -45,8 +45,8 @@ All rights reserved.
 INCLUDE_game
 INCLUDE_ANIMATION_DATA
 
-DaggerSlash::DaggerSlash(Monster&sourceMonster,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerSlashDistance,bool friendly,Pixel col)
-	:Bullet(sourceMonster.GetPos(),{},radius,damage,"goblin_sword_slash.png",upperLevel,false,daggerFrameDuration*ANIMATION_DATA["goblin_sword_slash.png"].GetFrameCountBasedOnAnimationStyle(),true,friendly,col),
+DaggerSlash::DaggerSlash(Monster&sourceMonster,const std::string&image,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerSlashDistance,bool friendly,Pixel col)
+	:Bullet(sourceMonster.GetPos(),{},radius,damage,image,upperLevel,false,daggerFrameDuration*ANIMATION_DATA["goblin_sword_slash.png"].GetFrameCountBasedOnAnimationStyle(),true,friendly,col),
 	sourceMonster(sourceMonster),frameDuration(daggerFrameDuration),daggerSlashDistance(daggerSlashDistance),facingDir(facingDir),knockbackAmt(knockbackAmt){}
 void DaggerSlash::Update(float fElapsedTime){
 	ANIMATION_DATA["goblin_sword_slash.png"].ChangeFrameDuration(frameDuration);

Adventures in Lestoria/DaggerStab.cpp

@@ -45,8 +45,8 @@ All rights reserved.
 INCLUDE_game
 INCLUDE_ANIMATION_DATA
 
-DaggerStab::DaggerStab(Monster&sourceMonster,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerStabDistance,const DirectionOffsets offsets,bool friendly,Pixel col)
-	:Bullet(sourceMonster.GetPos(),{},radius,damage,"dagger_stab.png",upperLevel,false,daggerFrameDuration*ANIMATION_DATA["dagger_stab.png"].GetFrameCountBasedOnAnimationStyle(),true,friendly,col),
+DaggerStab::DaggerStab(Monster&sourceMonster,const std::string&image,float radius,int damage,const float knockbackAmt,bool upperLevel,const Direction facingDir,const float daggerFrameDuration,const float daggerStabDistance,const DirectionOffsets offsets,bool friendly,Pixel col)
+	:Bullet(sourceMonster.GetPos(),{},radius,damage,image,upperLevel,false,daggerFrameDuration*ANIMATION_DATA["dagger_stab.png"].GetFrameCountBasedOnAnimationStyle(),true,friendly,col),
 	sourceMonster(sourceMonster),frameDuration(daggerFrameDuration),daggerStabDistance(daggerStabDistance),facingDir(facingDir),daggerPositionOffsets(offsets),knockbackAmt(knockbackAmt){}
 void DaggerStab::Update(float fElapsedTime){
 	ANIMATION_DATA["dagger_stab.png"].ChangeFrameDuration(frameDuration);

Adventures in Lestoria/DamageNumber.cpp

@@ -127,11 +127,15 @@ void DamageNumber::Draw(){
 		}break;
 		case DOT:{
 			std::string text=std::to_string(damage);
-			DrawDamageNumber(NormalNumber,text,{0xE1BEE7,0x1F083A},{0xDCE775,0x37320A});
+			DrawDamageNumber(NormalNumber,text,std::pair<Pixel,Pixel>{0xE1BEE7,0x1F083A},std::pair<Pixel,Pixel>{0xDCE775,0x37320A});
 		}break;
 		case BACKSTAB:{
 			std::string text=std::to_string(damage);
-			DrawDamageNumber(NumberScalesWithDamage,text,{0x888093,0x150035},{BLACK,{0,0,0,0}});
+			DrawDamageNumber(NumberScalesWithDamage,text,std::pair<Pixel,Pixel>{0x888093,0x150035},{BLACK,{0,0,0,0}});
+		}break;
+		case SHIELD_LOSS:{
+			std::string text=std::to_string(damage);
+			DrawDamageNumber(NumberScalesWithDamage,text,std::pair<Pixel,Pixel>{DARK_BLUE,0x68d7ef},std::pair<Pixel,Pixel>{BLUE,0x4141be});
 		}break;
 		default:ERR(std::format("Damage Number Type {} is not implemented! THIS SHOULD NOT BE HAPPENING!",int(type)));
 	}
@@ -139,8 +143,18 @@ void DamageNumber::Draw(){
 
 float DamageNumber::GetOriginalRiseSpd(){
 	float riseSpd{20.f};
-	if(type==INTERRUPT||type==MANA_GAIN)riseSpd=40.f;
-	if(type==DOT)riseSpd=-10.f;
+	switch(type){
+		case INTERRUPT:
+		case HEALTH_GAIN:{
+			riseSpd=40.f;
+		}break;
+		case MANA_GAIN:{
+			riseSpd=-20.f;
+		}break;
+		case DOT:{
+			riseSpd=-10.f;
+		}break;
+	}
 	return riseSpd;
 }
 

Adventures in Lestoria/DamageNumber.h

@@ -47,6 +47,7 @@ namespace DamageNumberType{
 		CRIT,
 		DOT,
 		BACKSTAB,
+		SHIELD_LOSS,
 	};
 }
 

Adventures in Lestoria/DeadlyDash.cpp

@@ -79,7 +79,7 @@ void DeadlyDash::Draw(const Pixel blendCol)const{
 	for(int i:std::ranges::iota_view(0,afterImageCount)){
 		const float fadeTimeBegins{(i+1)*afterImagesLingeringTime};
 		uint8_t alpha{255U};
-		if(GetAliveTime()>fadeTimeBegins)alpha=std::max(0.f,util::lerp(255,0,(GetAliveTime()-fadeTimeBegins)/afterImagesLingeringTime));
+		if(GetAliveTime()>fadeTimeBegins)alpha=std::max(0.f,float(util::lerp(255,0,(GetAliveTime()-fadeTimeBegins)/afterImagesLingeringTime)));
 		const Animate2D::FrameSequence&animation{ANIMATION_DATA[this->animation]};
 		const float animationFrameTimer{i*animation.m_fFrameDuration};
 

Adventures in Lestoria/DynamicMenuLabel.h

@@ -0,0 +1,57 @@
+#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 "MenuLabel.h"
+
+//A class holding a lambda function where you return an updated menu label that is declared on creation to reduce boilerplate for menu labels that just need to update text differently..
+class DynamicMenuLabel:public MenuLabel{
+public:
+    inline DynamicMenuLabel(geom2d::rect<float>rect,std::function<const std::string()>labelUpdateFunc,float scale=1,ComponentAttr attributes=ComponentAttr::NONE)
+        :labelUpdateFunc(labelUpdateFunc),MenuLabel(rect,"",scale,attributes){}
+    inline void SetLabelUpdateFunction(std::function<const std::string()>labelUpdateFunc){
+        this->labelUpdateFunc=labelUpdateFunc;
+    }
+protected:
+    inline virtual void Update(AiL*game)override{
+        SetLabel(labelUpdateFunc());
+	    MenuLabel::Update(game);
+    }
+private:
+    std::function<const std::string()>labelUpdateFunc;
+};

Adventures in Lestoria/Effect.cpp

@@ -44,17 +44,21 @@ INCLUDE_ANIMATION_DATA
 INCLUDE_game
 INCLUDE_GFX
 
-Effect::Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,float size,float fadeout,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
-	:Effect::Effect(pos,lifetime,imgFile,upperLevel,0.f,fadeout,vf2d{size,size},spd,col,rotation,rotationSpd,additiveBlending){}
+//Note: The fadeout time activates when the original lifetime of the bullet expires! It doesn't begin immediately.
+Effect::Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float size,float fadeout,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
+	:Effect(pos,lifetime,imgFile,upperLevel,0.f,fadeout,vf2d{size,size},spd,col,rotation,rotationSpd,additiveBlending){}
 
-Effect::Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size,float fadeout,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
-	:pos(pos),lifetime(lifetime),upperLevel(upperLevel),size(size),fadeout(fadeout),original_fadeOutTime(fadeout),spd(spd),col(col),rotation(rotation),rotationSpd(rotationSpd),additiveBlending(additiveBlending){
-	this->animation.AddState(imgFile,ANIMATION_DATA.at(imgFile));
-	this->animation.ChangeState(internal_animState,imgFile);
-}
+//Note: The fadeout time activates when the original lifetime of the bullet expires! It doesn't begin immediately.
+Effect::Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,vf2d size,float fadeout,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
+	:Effect(pos,lifetime,imgFile,upperLevel,0.f,fadeout,size,spd,col,rotation,rotationSpd,additiveBlending){}
+
+//Note: The fadeout time activates when the original lifetime of the bullet expires! It doesn't begin immediately.
+Effect::Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
+	:Effect(pos,lifetime,imgFile,upperLevel,fadein,fadeout,size,spd,EffectType::NONE,col,rotation,rotationSpd,additiveBlending){}
 
-Effect::Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
-	:pos(pos),lifetime(lifetime),upperLevel(upperLevel),size(size),fadein(fadein),original_fadeInTime(fadein),fadeout(fadeout),original_fadeOutTime(fadeout),spd(spd),col(col),rotation(rotation),rotationSpd(rotationSpd),additiveBlending(additiveBlending){
+//Note: The fadeout time activates when the original lifetime of the bullet expires! It doesn't begin immediately.
+Effect::Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,EffectType type,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
+	:pos(pos),lifetime(lifetime),upperLevel(upperLevel),size(size),fadein(fadein),original_fadeInTime(fadein),fadeout(fadeout),original_fadeOutTime(fadeout),spd(spd),col(col),rotation(rotation),rotationSpd(rotationSpd),additiveBlending(additiveBlending),type(type){
 	this->animation.AddState(imgFile,ANIMATION_DATA.at(imgFile));
 	this->animation.ChangeState(internal_animState,imgFile);
 }
@@ -80,7 +84,7 @@ bool Effect::Update(float fElapsedTime){
 	return true;
 }
 
-void Effect::Draw()const{
+void Effect::_Draw()const{
 	if(additiveBlending)game->SetDecalMode(DecalMode::ADDITIVE);
 	const bool FadeInFinished{original_fadeInTime==0||fadein==original_fadeInTime};
 	const bool HasFadeout{fadeout>0};
@@ -90,17 +94,22 @@ void Effect::Draw()const{
 		game->view.DrawDecal(pos-vf2d{3,3}*shadowScale/2+vf2d{0,12*size.y},GFX["circle.png"].Decal(),shadowScale,BLACK);
 	}
 
+	Pixel blendCol{col};
 	[[unlikely]]if(!FadeInFinished){
-		game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,{col.r,col.g,col.b,uint8_t(fadein/original_fadeInTime*col.a)});
+		blendCol={col.r,col.g,col.b,uint8_t(fadein/original_fadeInTime*col.a)};
 	}else
 	[[likely]]if(HasFadeout){
-		game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,{col.r,col.g,col.b,uint8_t(fadeout/original_fadeOutTime*col.a)});
-	}else{
-		game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,col);
+		blendCol={col.r,col.g,col.b,uint8_t(fadeout/original_fadeOutTime*col.a)};
 	}
+	Draw(blendCol);
+	
 	game->SetDecalMode(DecalMode::NORMAL);
 }
 
+void Effect::Draw(const Pixel blendCol)const{
+	game->view.DrawPartialRotatedDecal(pos-vf2d{0,GetZ()},GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,blendCol);
+}
+
 Animate2D::Frame Effect::GetFrame()const{
 	return animation.GetFrame(internal_animState);
 }
@@ -116,3 +125,11 @@ const EffectType Effect::GetType()const{
 const float Effect::GetZ()const{
 	return z;
 }
+
+void Effect::SetType(const EffectType type){
+	this->type=type;
+}
+
+const bool&Effect::OnUpperLevel()const{
+	return upperLevel;
+}

Adventures in Lestoria/Effect.h

@@ -37,8 +37,10 @@ All rights reserved.
 #pragma endregion
 #pragma once
 #include "Animation.h"
+#include "IBullet.h"
 #include <unordered_set>
 #include <variant>
+#include "Oscillator.h"
 class Monster;
 class Player;
 using HitList=std::unordered_set<std::variant<Monster*,Player*>>;
@@ -47,11 +49,13 @@ enum class EffectType{
 	NONE,
 	SPELL_CIRCLE,
 	MONSTER_SOUL,
+	BLINK_PORTAL,
+	TRAIL_OF_FIRE,
 };
 
 struct Effect{
 	friend class AiL;
-	friend struct FallingStone;
+	friend struct FallingBullet;
 	vf2d pos={0,0};
 	float lifetime=0;
 	float fadeout=0;
@@ -67,41 +71,62 @@ struct Effect{
 private:
 	bool dead=false;
 public:
-	Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,float size=1.0f,float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
-	Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
-	Effect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float size=1.0f,float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	Effect(vf2d pos,float lifetime,const std::string&imgFile,bool upperLevel,float fadein,float fadeout,vf2d size,vf2d spd,EffectType type,Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
 	virtual bool Update(float fElapsedTime);
 	Animate2D::Frame GetFrame()const;
-	virtual void Draw()const;
+	void _Draw()const;
+	virtual void Draw(const Pixel blendCol)const;
 	bool OnUpperLevel();
 	const EffectType GetType()const;
 	const float GetZ()const;
+	const bool&OnUpperLevel()const;
+	void SetType(const EffectType type);
 protected:
 	float original_fadeOutTime;
 	float original_fadeInTime{};
 	EffectType type{EffectType::NONE};
-private:
 	Animate2D::Animation<std::string>animation;
 	Animate2D::AnimationState internal_animState;
+private:
 	bool upperLevel=false;
 	double aliveTime{};
 };
 
 struct Meteor:Effect{
-	Meteor(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	enum MeteorSetting{
+		METEOR,
+		COMET,
+		SOLAR_FLARE,
+		COMET_FLARE,
+	};
+	Meteor(const vf2d pos,const float lifetime,const bool upperLevel,const MeteorSetting setting,const float fadeout=0.0f,const vf2d spd={},const Pixel col=WHITE,const float rotation=0,const float rotationSpd=0,const bool additiveBlending=false);
 	float startLifetime=0;
 	bool shakeField=false;
 	bool Update(float fElapsedTime)override;
-	void Draw()const override;
+	void Draw(const Pixel blendCol)const override;
+private:
+	int meteorImpactParticles{};
+	float randomColorTintR{};
+	float randomColorTintG{};
+	float randomColorTintB{};
+	float meteorRadius{};
+	float fallSpdMult{1.f};
+	float damageMult{1.f};
+	float fireRingLifetime{};
+	std::string meteorCrashSFX{};
 };
 
 struct PulsatingFire:Effect{
-	PulsatingFire(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
+	PulsatingFire(vf2d pos,float lifetime,const float radius,std::string imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
 	std::vector<float>pulsatingFireValues;
 	float lastParticleTimer=0;
 	float lastDamageTimer=0;
+	float radius;
 	bool Update(float fElapsedTime)override;
-	void Draw()const override;
+	void Draw(const Pixel blendCol)const override;
 };
 
 struct SwordSlash:Effect{
@@ -117,7 +142,7 @@ private:
 struct ForegroundEffect:Effect{
 	ForegroundEffect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,float size=1.0f,float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
 	ForegroundEffect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false);
-	virtual void Draw()const override final;
+	virtual void Draw(const Pixel blendCol)const override final;
 };
 
 struct SpellCircle:Effect{
@@ -125,7 +150,7 @@ struct SpellCircle:Effect{
 	SpellCircle(vf2d pos,float lifetime,std::string imgFile,std::string spellInsigniaFile,bool upperLevel,vf2d size={1,1},float fadeout=0.0f,vf2d spd={},Pixel col=WHITE,float rotation=0,float rotationSpd=0,bool additiveBlending=false,vf2d insigniaSize={1,1},float insigniaFadeout=0.0f,vf2d insigniaSpd={},Pixel insigniaCol=WHITE,float insigniaRotation=0,float insigniaRotationSpd=0,bool insigniaAdditiveBlending=false);
 	Effect spellInsignia{vf2d{},0.f,"spell_insignia.png",false,{}};
 	virtual bool Update(float fElapsedTime)override final;
-	virtual void Draw()const override final;
+	virtual void Draw(const Pixel blendCol)const override final;
 };
 
 struct RockLaunch:Effect{
@@ -150,7 +175,7 @@ private:
 struct MonsterSoul:Effect{
 	MonsterSoul(vf2d pos,float fadeoutTime,float size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending=false);
 	virtual bool Update(float fElapsedTime)override final;
-	virtual void Draw()const override final;
+	virtual void Draw(const Pixel blendCol)const override final;
 public:
 	enum Phase{
 		RISING,
@@ -162,3 +187,41 @@ public:
 	float moveSpd{24.f};
 	float fadeoutTime;
 };
+
+struct FadeInOutEffect:Effect{
+	//cycleSpd is how long it takes to get from fully opaque to fully transparent, and back to fully opaque
+	FadeInOutEffect(vf2d pos,const std::string&img,float lifetime,float cycleSpd,bool onUpperLevel,float size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending=false,float particleSpawnFreq=0.f,const std::function<Effect(const Effect&self)>&particleGenerator={});
+	//A version with oscillators for position and colors, for extra animation effects!
+	FadeInOutEffect(Oscillator<vf2d>pos,const std::string&img,float lifetime,bool onUpperLevel,Oscillator<vf2d>size,vf2d spd,Oscillator<Pixel>col,float rotation,float rotationSpd,bool additiveBlending=false,float particleSpawnFreq=0.f,const std::function<Effect(const Effect&self)>&particleGenerator={});
+	virtual bool Update(float fElapsedTime)override;
+	virtual void Draw(const Pixel blendCol)const override;
+	std::function<Effect(const Effect&self)>particleGenerator;
+	const float particleSpawnFreq;
+	Oscillator<vf2d>posOscillator;
+	Oscillator<vf2d>sizeOscillator;
+	Oscillator<Pixel>colOscillator;
+	float particleSpawnTimer{};
+	const float originalParticleSpawnTimer{};
+};
+
+struct LingeringEffect:FadeInOutEffect{
+	LingeringEffect(vf2d pos,const std::string&img,const std::string&soundEffect,float radius,int damage,float damageFreq,const HurtType friendly,float lifetime,float cycleSpd,bool onUpperLevel,float size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending=false,float particleSpawnFreq=0.f,const std::function<Effect(const Effect&self)>&particleGenerator={});
+	virtual bool Update(float fElapsedTime)override final;
+	const int damage;
+	float damageTimer{};
+	const float originalDamageTimer{};
+	const float radius;
+	HurtType friendly;
+	const size_t sfxID{};
+};
+
+struct Ink:Effect{
+	//NOTE: The way ink works is that every update frame, each ink stack will check for distance to player, and if the player collides with the radius of the ink it will add one to the ink debuff for the player.
+	//	At the end of AdventuresInLestoria::HandleUserInput(), the ink stack counter is reset after handling user input for moving the player.
+	Ink(vf2d pos,float radius,float lifetime,float inkSlowdownDuration,float inkSlowdownPct,float fadeinTime,float fadeoutTime,vf2d size,Pixel col,bool onUpperLevel,float rotation);
+	virtual bool Update(float fElapsedTime)override final;
+private:
+	const float radius;
+	const float inkSlowdownDuration;
+	const float inkSlowdownAmount;
+};

Adventures in Lestoria/EnergyBolt.cpp

@@ -45,7 +45,7 @@ INCLUDE_game
 
 EnergyBolt::EnergyBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col)
 :Bullet(pos,vel,radius,damage,
-	"energy_bolt.png",upperLevel,false,INFINITE,true,friendly,col){}
+	"energy_bolt.png",upperLevel,game->GetPlayer()->HasEnchant("Piercing Bolt")?true:false,INFINITE,true,friendly,col){}
 
 void EnergyBolt::Update(float fElapsedTime){
 	lastParticleSpawn=std::max(0.f,lastParticleSpawn-fElapsedTime);
@@ -67,8 +67,9 @@ BulletDestroyState EnergyBolt::PlayerHit(Player*player)
 
 BulletDestroyState EnergyBolt::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)
 {
-	fadeOutTime="Wizard.Auto Attack.BulletHitFadeoutTime"_F;
+	if(!game->GetPlayer()->HasEnchant("Piercing Bolt"))fadeOutTime="Wizard.Auto Attack.BulletHitFadeoutTime"_F;
 	game->AddEffect(std::make_unique<Effect>(monster.GetPos(),0,"splash_effect.png",upperLevel,monster.GetSizeMult(),"Wizard.Auto Attack.SplashEffectFadeoutTime"_F));
+	if(hitList.size()==1)damage=ceil(damage*"Piercing Bolt"_ENC["MULTI TARGET DAMAGE"]/100.f);
 	return BulletDestroyState::KEEP_ALIVE;
 }
 

Adventures in Lestoria/Entity.cpp

@@ -0,0 +1,60 @@
+#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 "Entity.h"
+#include "Player.h"
+
+#define is(type) std::holds_alternative<type>(entity)
+#define get(type) std::get<type>(entity)
+
+Entity::Entity(Player*player):entity(player){}
+Entity::Entity(Monster*monster):entity(monster){}
+Entity::Entity(const std::variant<Monster*,Player*>ent):entity(ent){}
+
+const vf2d Entity::GetPos()const{
+	if(is(Player*))return get(Player*)->GetPos();
+	if(is(Monster*))return get(Monster*)->GetPos();
+	ERR("Entity is not a valid type! THIS SHOULD NOT BE HAPPENING!");
+	return {}; //NOTE: Unreachable
+}
+
+void Entity::SetIframeTime(const float iframeTime){
+	if(is(Player*))get(Player*)->ApplyIframes(iframeTime);
+	else if(is(Monster*))get(Monster*)->ApplyIframes(iframeTime);
+	else ERR("Entity is not a valid type! THIS SHOULD NOT BE HAPPENING!");
+}

Adventures in Lestoria/Entity.h

@@ -0,0 +1,56 @@
+#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 "olcUTIL_Geometry2D.h"
+#include <variant>
+
+class Player;
+class Monster;
+
+//A helper class to connect multiple entity types based on their commonalities without using inheritance shenanigans.
+class Entity{
+public:
+	Entity(Player*player);
+	Entity(Monster*monster);
+	Entity(const std::variant<Monster*,Player*>ent);
+	const vf2d GetPos()const;
+	void SetIframeTime(const float iframeTime);
+private:
+	const std::variant<Monster*,Player*>entity;
+};

Adventures in Lestoria/EnvironmentalAudio.cpp

@@ -67,7 +67,8 @@ void EnvironmentalAudio::SetAudioName(const std::string_view audioName){
 }
 void EnvironmentalAudio::Activate(){
 	if(activated)return;
-	soundInstance=Audio::LoadAndPlay(operator""_SFX(SOUND_DATA[audioName].file.c_str(),SOUND_DATA[audioName].file.length()),true);
+	soundInstance=Audio::LoadAndPlaySFX(operator""_SFX(SOUND_DATA[audioName].file.c_str(),SOUND_DATA[audioName].file.length()),true);
+	Audio::Engine().SetPitch(soundInstance,util::random_range(0.9f,1.1f));
 	activated=true;
 }
 void EnvironmentalAudio::Deactivate(){

Adventures in Lestoria/EquipSlotButton.h

@@ -52,7 +52,7 @@ public:
     inline void OnEquipStatsUpdate()override{
         const std::weak_ptr<Item>equip=Inventory::GetEquip(slot);
         if(!ISBLANK(equip)){
-            icon=const_cast<Decal*>(equip.lock()->Decal());
+            icon=const_cast<Decal*>(equip.lock()->Icon().Decal());
             itemRef=equip;
         }else{
             icon=nullptr;

Adventures in Lestoria/Error.h

@@ -43,6 +43,7 @@ All rights reserved.
 #include <memory>
 #include <source_location>
 #include <fstream>
+#include <stacktrace>
 
 inline std::ofstream debugLogger;
 
@@ -80,7 +81,9 @@ inline std::ofstream debugLogger;
 		}
 		inline static void log(std::stringstream&str,std::source_location loc){
 			debugLogger<<loc.file_name()<<"("<<loc.line()<<":"<<loc.column()<<") "<<loc.function_name()<<": "<<str.str()<<std::endl;
+			debugLogger<<std::stacktrace::current()<<std::endl;
 			std::cout<<loc.file_name()<<"("<<loc.line()<<":"<<loc.column()<<") "<<loc.function_name()<<": "<<str.str()<<std::endl;
+			std::cout<<std::stacktrace::current()<<std::endl;
 			throw std::runtime_error{std::format("{}({}:{}) {}: {}",loc.file_name(),loc.line(),loc.column(),loc.function_name(),str.str()).c_str()};
 		}
 	};
@@ -115,15 +118,15 @@ type DYNAMIC_CAST(auto variable){
 }
 
 template<typename T,typename U>
-std::shared_ptr<T>DYNAMIC_POINTER_CAST(const std::shared_ptr<U>&variable){
-    std::shared_ptr<T> newVariable=dynamic_pointer_cast<T>(variable);
+const std::shared_ptr<T>DYNAMIC_POINTER_CAST(const std::shared_ptr<U>&variable){
+    const std::shared_ptr<T> newVariable=dynamic_pointer_cast<T>(variable);
     if(!newVariable)ERR("Could not dynamic cast to pointer type "<<typeid(newVariable).name()<<"!");
     return newVariable;
 }
 
 template<typename T,typename U>
-std::shared_ptr<T>DYNAMIC_POINTER_CAST(const std::weak_ptr<U>&variable){
-    std::shared_ptr<T> newVariable=dynamic_pointer_cast<T>(variable.lock());
+const std::shared_ptr<T>DYNAMIC_POINTER_CAST(const std::weak_ptr<U>&variable){
+    const std::shared_ptr<T> newVariable=dynamic_pointer_cast<T>(variable.lock());
     if(!newVariable)ERR("Could not dynamic cast to pointer type "<<typeid(newVariable).name()<<"!");
     return newVariable;
 }

Adventures in Lestoria/ExplosiveTrap.cpp

@@ -47,7 +47,7 @@ INCLUDE_ANIMATION_DATA
 INCLUDE_game
 
 ExplosiveTrap::ExplosiveTrap(vf2d pos,float radius,float explosionRadius,float automaticDetonationTime,int damage,float fadeinTime,float fadeoutTime,float activationWaitTime,bool upperLevel,bool hitsMultiple,float lifetime,bool friendly,Pixel col,vf2d scale)
-	:activationWaitTime(activationWaitTime),automaticDetonationTime(automaticDetonationTime),activationRadius(radius),explosionRadius(explosionRadius),Bullet(pos,{},0.f,damage,"Ability Icons/explosive_trap.png",upperLevel,hitsMultiple,lifetime,false,friendly,col,scale,0.f,"Trap Hit"){
+	:activationWaitTime(activationWaitTime),automaticDetonationTime(automaticDetonationTime),activationRadius(radius),explosionRadius(explosionRadius),explosionCount(game->GetPlayer()->HasEnchant("Concussive Trap")?"Concussive Trap"_ENC["TRAP EXPLODE COUNT"]:1),Bullet(pos,{},0.f,damage,"Ability Icons/explosive_trap.png",upperLevel,hitsMultiple,INFINITE,false,friendly,col,scale,0.f,"Trap Hit"){
 	fadeInTime=fadeinTime;
 	animation.AddState("explosive_trap.png",ANIMATION_DATA["explosive_trap.png"]);
 	if(!friendly)ERR("WARNING! Trying to use unimplemented enemy version of the Explosive Trap Bullet!");
@@ -58,7 +58,10 @@ void ExplosiveTrap::Update(float fElapsedTime){
 
 	if(IsDeactivated())return;
 
-	if(!trapActivated){
+	if(rearmTime>0.f){
+		rearmTime-=fElapsedTime;
+		if(rearmTime<=0.f)Detonate();
+	}else if(!trapActivated){
 		activationWaitTime-=fElapsedTime;
 		if(activationWaitTime<=0.f){
 			radius=activationRadius;
@@ -89,13 +92,14 @@ BulletDestroyState ExplosiveTrap::PlayerHit(Player*player){
 }
 
 void ExplosiveTrap::Detonate(){
-	fadeOutTime=0.5f;
-	const HurtList list{game->HurtNotHit(pos,"Trapper.Ability 3.Explosion Radius"_F/100.f*24,damage,hitList,OnUpperLevel(),GetZ(),HurtType::MONSTER,HurtFlag::PLAYER_ABILITY)};
+	const HurtList list{game->Hurt(pos,"Trapper.Ability 3.Explosion Radius"_F/100.f*24,damage,OnUpperLevel(),GetZ(),HurtType::MONSTER,HurtFlag::PLAYER_ABILITY)};
 	for(const auto&[targetPtr,wasHit]:list){
 		if(wasHit){
 			std::get<Monster*>(targetPtr)->ApplyMark("Trapper.Ability 3.Explosion Mark Stack Time"_F,"Trapper.Ability 3.Explosion Mark Stack Increase"_I);
-			std::get<Monster*>(targetPtr)->ProximityKnockback(pos,"Trapper.Ability 3.Explosion Knockback Amount"_F);
-			std::get<Monster*>(targetPtr)->Knockup("Trapper.Ability 3.Explosion Knockup Amount"_F);
+			if(explosionCount==1)std::get<Monster*>(targetPtr)->ProximityKnockback(pos,"Trapper.Ability 3.Explosion Knockback Amount"_F);
+			else std::get<Monster*>(targetPtr)->ProximityKnockback(pos,20.f);
+			if(explosionCount==1)std::get<Monster*>(targetPtr)->Knockup("Trapper.Ability 3.Explosion Knockup Amount"_F);
+			else std::get<Monster*>(targetPtr)->Knockup(0.1f);
 		}
 	}
 
@@ -103,7 +107,13 @@ void ExplosiveTrap::Detonate(){
 	explodeEffect->scaleSpd={0.125f,0.125f};
 	game->AddEffect(std::move(explodeEffect));
 	SoundEffect::PlaySFX("Explosion",pos);
+	explosionCount--;
+	if(explosionCount>0)rearmTime=0.6f;
+	else{
+		fadeOutTime=0.5f;
 		Deactivate();
+		lifetime=0.f;
+	}
 }
 
 BulletDestroyState ExplosiveTrap::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit){
@@ -111,9 +121,6 @@ BulletDestroyState ExplosiveTrap::MonsterHit(Monster&monster,const uint8_t markS
 		monster.Hurt(0,monster.OnUpperLevel(),monster.GetZ(),HurtFlag::PLAYER_ABILITY);//Triggers mark multiple times after the first mark.
 	}
 
-	monster.ProximityKnockback(pos,"Trapper.Ability 3.Explosion Knockback Amount"_F);
-	monster.Knockup("Trapper.Ability 3.Explosion Knockup Amount"_F);
-
 	Detonate();
 
 	return BulletDestroyState::KEEP_ALIVE;

Adventures in Lestoria/FadeInOutEffect.cpp

@@ -0,0 +1,65 @@
+#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 "Effect.h"
+#include "AdventuresInLestoria.h"
+#include "DEFINES.h"
+#include "util.h"
+
+INCLUDE_game
+
+FadeInOutEffect::FadeInOutEffect(vf2d pos,const std::string&img,float lifetime,float cycleSpd,bool onUpperLevel,float size,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending,float particleSpawnFreq,const std::function<Effect(const Effect&self)>&particleGenerator)
+	:FadeInOutEffect({pos,pos,cycleSpd},img,lifetime,onUpperLevel,{{size,size},{size,size},cycleSpd},spd,{col,{col.r,col.g,col.b,0},cycleSpd},rotation,rotationSpd,additiveBlending,particleSpawnFreq,particleGenerator){}
+FadeInOutEffect::FadeInOutEffect(Oscillator<vf2d>pos,const std::string&img,float lifetime,bool onUpperLevel,Oscillator<vf2d>size,vf2d spd,Oscillator<Pixel>col,float rotation,float rotationSpd,bool additiveBlending,float particleSpawnFreq,const std::function<Effect(const Effect&self)>&particleGenerator)
+	:particleSpawnFreq(particleSpawnFreq),particleGenerator(particleGenerator),particleSpawnTimer(particleSpawnFreq),originalParticleSpawnTimer(particleSpawnTimer),posOscillator(pos),colOscillator(col),sizeOscillator(size),Effect(pos.first,lifetime,img,onUpperLevel,size.first,0.25f,spd,col.first,rotation,rotationSpd,additiveBlending){}
+bool FadeInOutEffect::Update(float fElapsedTime){
+	if(particleGenerator){
+		particleSpawnTimer-=fElapsedTime;
+		if(particleSpawnTimer<=0.f){
+			particleSpawnTimer+=originalParticleSpawnTimer;
+			game->AddEffect(std::make_unique<Effect>(particleGenerator(*this)));
+		}
+	}
+	pos=posOscillator.Update(fElapsedTime);
+	size=sizeOscillator.Update(fElapsedTime);
+	col=colOscillator.Update(fElapsedTime);
+	return Effect::Update(fElapsedTime);
+}
+void FadeInOutEffect::Draw(const Pixel blendCol)const{
+	Effect::Draw(blendCol);
+}

Adventures in Lestoria/FallingBullet.cpp

@@ -45,14 +45,14 @@ All rights reserved.
 
 INCLUDE_game
 
-FallingStone::FallingStone(vf2d targetPos,vf2d vel,float zVel,float indicatorDisplayTime,float radius,int damage,bool upperLevel,bool hitsMultiple,float knockbackAmt,float lifetime,bool friendly,Pixel col,vf2d scale,float image_angle,float spellCircleRotation,float spellCircleRotationSpd,Pixel insigniaCol,float insigniaRotation,float insigniaRotationSpd)
-:Bullet(targetPos,vel,radius,damage,"rock.png",upperLevel,false,lifetime+0.1f,false,friendly,col,scale,image_angle),targetPos(targetPos),zVel(zVel),indicatorDisplayTime(indicatorDisplayTime),knockbackAmt(knockbackAmt),
-indicator(targetPos,lifetime+0.1f,"range_indicator.png","spell_insignia.png",upperLevel,radius/12.f,0.5f,{},col,spellCircleRotation,spellCircleRotationSpd,false,radius/12.f,0.f,{},insigniaCol,insigniaRotation,insigniaRotationSpd,false){
+FallingBullet::FallingBullet(const std::string&imgName,vf2d targetPos,vf2d vel,float zVel,float indicatorDisplayTime,float radius,int damage,bool upperLevel,bool hitsMultiple,float knockbackAmt,float lifetime,bool friendly,Pixel spellCircleCol,vf2d scale,float image_angle,float spellCircleRotation,float spellCircleRotationSpd,Pixel insigniaCol,float insigniaRotation,float insigniaRotationSpd)
+:Bullet(targetPos,vel,0.f,damage,imgName,upperLevel,false,lifetime+0.1f,false,friendly,WHITE,scale,image_angle),targetPos(targetPos),zVel(zVel),indicatorDisplayTime(indicatorDisplayTime),knockbackAmt(knockbackAmt),collisionRadius(radius),
+indicator(targetPos,lifetime+0.1f,"range_indicator.png","spell_insignia.png",upperLevel,radius/12.f,0.5f,{},spellCircleCol,spellCircleRotation,spellCircleRotationSpd,false,radius/12.f,0.f,{},insigniaCol,insigniaRotation,insigniaRotationSpd,false){
 	pos+=-vel*lifetime;
 	z=-zVel*lifetime;
 }
 
-void FallingStone::Update(float fElapsedTime){
+void FallingBullet::Update(float fElapsedTime){
 	z+=zVel*fElapsedTime;
 	lastTrailEffect-=fElapsedTime;
 	if(z<=0.f){
@@ -62,16 +62,15 @@ void FallingStone::Update(float fElapsedTime){
 			fadeOutTime=0.5f;
 			SoundEffect::PlaySFX("Stone Land",pos);
 			if(friendly){
-				for(auto&[monsterPtr,hurt]:game->Hurt(targetPos,radius,damage,OnUpperLevel(),z,HurtType::MONSTER)){
+				for(auto&[monsterPtr,hurt]:game->Hurt(pos,collisionRadius,damage,OnUpperLevel(),z,HurtType::MONSTER)){
 					if(hurt)std::get<Monster*>(monsterPtr)->ApplyIframes(0.1f);
 				}
-			}
-			else{
-				for(auto&[playerPtr,hurt]:game->Hurt(targetPos,radius,damage,OnUpperLevel(),z,HurtType::PLAYER)){
+			}else{
+				for(auto&[playerPtr,hurt]:game->Hurt(pos,collisionRadius,damage,OnUpperLevel(),z,HurtType::PLAYER)){
 					if(hurt)std::get<Player*>(playerPtr)->ApplyIframes(0.1f);
 				}
 			}
-			game->ProximityKnockback(targetPos,radius,knockbackAmt,HurtType::PLAYER|HurtType::MONSTER);
+			game->ProximityKnockback(pos,collisionRadius,knockbackAmt,HurtType::PLAYER|HurtType::MONSTER);
 			for(int i:std::ranges::iota_view(0,30))game->AddEffect(std::make_unique<Effect>(pos-vf2d{0.f,GetZ()},util::random_range(0.05f,0.2f),"circle_outline.png",OnUpperLevel(),util::random_range(0.5f,1.f),0.2f,vf2d{util::random_range(-10.f,10.f),util::random_range(-3.f,0.f)},PixelLerp(BLACK,col,util::random(1.f)),0.f,0.f,true));
 			Deactivate();
 		}
@@ -82,11 +81,11 @@ void FallingStone::Update(float fElapsedTime){
 	}
 	indicator.Update(fElapsedTime);
 }
-void FallingStone::Draw(const Pixel blendCol)const{
+void FallingBullet::Draw(const Pixel blendCol)const{
 	if(lifetime<=indicatorDisplayTime){
-		indicator.Draw();
+		indicator._Draw();
 	}
 	Bullet::Draw(blendCol);
 }
 
-void FallingStone::ModifyOutgoingDamageData(HurtDamageInfo&data){}
+void FallingBullet::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/FireBolt.cpp

@@ -41,13 +41,16 @@ All rights reserved.
 #include "DEFINES.h"
 #include "util.h"
 #include "SoundEffect.h"
+#include "TrailEffect.h"
 
 INCLUDE_game
 INCLUDE_MONSTER_LIST
 
 FireBolt::FireBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col)
 	:Bullet(pos,vel,radius,damage,
-		"energy_bolt.png",upperLevel,false,INFINITE,true,friendly,col){}
+		"energy_bolt.png",upperLevel,false,INFINITE,true,friendly,col){
+	if(game->GetPlayer()->HasEnchant("Trail of Fire"))flameTrail=dynamic_cast<TrailEffect&>(game->AddEffect(std::make_unique<TrailEffect>(pos,"Trail of Fire"_ENC["TRAIL DURATION"],"FlamesTexture.png","Trail of Fire"_ENC["TRAIL DAMAGE"]/100.f*game->GetPlayer()->GetAttack(),"Trail of Fire"_ENC["TRAIL TICK FREQUENCY"],upperLevel,1.f,vf2d{1.f,2.f},30000.f,Oscillator<Pixel>{{255,0,0,128},Pixel(0xE74F30),2.f},EffectType::TRAIL_OF_FIRE,true),true));
+}
 
 void FireBolt::Update(float fElapsedTime){
 	lastParticleSpawn=std::max(0.f,lastParticleSpawn-fElapsedTime);
@@ -55,7 +58,7 @@ void FireBolt::Update(float fElapsedTime){
 		lastParticleSpawn="Wizard.Ability 1.ParticleFrequency"_F;
 		game->AddEffect(std::make_unique<Effect>(pos,"Wizard.Ability 1.ParticleLifetimeRange"_FRange,"energy_particle.png",upperLevel,"Wizard.Ability 1.ParticleSizeRange"_FRange,"Wizard.Ability 1.ParticleFadeoutTime"_F,vf2d{"Wizard.Ability 1.ParticleXSpeedRange"_FRange,"Wizard.Ability 1.ParticleYSpeedRange"_FRange},Pixel{uint8_t("Wizard.Ability 1.ParticleRedRange"_FRange),uint8_t("Wizard.Ability 1.ParticleGreenRange"_FRange),uint8_t("Wizard.Ability 1.ParticleBlueRange"_FRange),uint8_t("Wizard.Ability 1.ParticleAlphaRange"_FRange)}));
 	}
-	if(distanceTraveled>"Wizard.Ability 1.Range"_F&&IsActivated()){
+	if(distanceTraveled>"Wizard.Ability 1.Max Range"_F&&IsActivated()){
 		fadeOutTime="Wizard.Ability 1.BulletHitFadeoutTime"_F;
 		for(int i=0;i<"Wizard.Ability 1.BulletHitExplosionParticleCount"_I;i++){
 			game->AddEffect(std::make_unique<Effect>(pos,"Wizard.Ability 1.BulletHitExplosionParticleLifetimeRange"_FRange,"circle.png",upperLevel,"Wizard.Ability 1.BulletHitExplosionParticleSizeRange"_FRange,"Wizard.Ability 1.BulletHitExplosionParticleFadeoutTimeRange"_FRange,vf2d{"Wizard.Ability 1.BulletHitExplosionParticleSpeedRange"_FRange,"Wizard.Ability 1.BulletHitExplosionParticleSpeedRange"_FRange},Pixel{uint8_t("Wizard.Ability 1.BulletHitExplosionParticleRedRange"_FRange),uint8_t("Wizard.Ability 1.BulletHitExplosionParticleGreenRange"_FRange),uint8_t("Wizard.Ability 1.BulletHitExplosionParticleBlueRange"_FRange),uint8_t("Wizard.Ability 1.BulletHitExplosionParticleAlphaRange"_FRange)}));
@@ -72,6 +75,8 @@ void FireBolt::Update(float fElapsedTime){
 
 		SoundEffect::PlaySFX("Wizard Fire Bolt Hit",pos);
 	}
+
+	if(flameTrail)flameTrail.value().get().SetEndPos(pos);
 }
 
 BulletDestroyState FireBolt::PlayerHit(Player*player)

Adventures in Lestoria/ForegroundEffect.cpp

@@ -47,12 +47,6 @@ ForegroundEffect::ForegroundEffect(vf2d pos,float lifetime,std::string imgFile,b
 	:Effect(pos,lifetime,imgFile,upperLevel,size,fadeout,spd,col,rotation,rotationSpd,additiveBlending){}
 ForegroundEffect::ForegroundEffect(vf2d pos,float lifetime,std::string imgFile,bool upperLevel,vf2d size,float fadeout,vf2d spd,Pixel col,float rotation,float rotationSpd,bool additiveBlending)
 	:Effect(pos,lifetime,imgFile,upperLevel,size,fadeout,spd,col,rotation,rotationSpd,additiveBlending){}
-void ForegroundEffect::Draw()const{
-	if(additiveBlending)game->SetDecalMode(DecalMode::ADDITIVE);
-	if(fadeout==0){
-		game->DrawPartialRotatedDecal(pos,GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,col);
-	} else {
-		game->DrawPartialRotatedDecal(pos,GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,{col.r,col.g,col.b,uint8_t(fadeout/original_fadeOutTime*255)});
-	}
-	game->SetDecalMode(DecalMode::NORMAL);
+void ForegroundEffect::Draw(const Pixel blendCol)const{
+	game->DrawPartialRotatedDecal(pos,GetFrame().GetSourceImage()->Decal(),rotation,GetFrame().GetSourceRect().size/2,GetFrame().GetSourceRect().pos,GetFrame().GetSourceRect().size,size,blendCol);
 }

Adventures in Lestoria/Frog.cpp

@@ -51,11 +51,11 @@ using A=Attribute;
 void Monster::STRATEGY::FROG(Monster&m,float fElapsedTime,std::string strategy){
 	m.F(A::LOCKON_WAITTIME)=std::max(0.0f,m.F(A::LOCKON_WAITTIME)-fElapsedTime);
 	phase:
-	switch(m.I(A::PHASE)){
+	switch(PHASE()){
 		case 0:{ //Move towards phase.
 			float distToPlayer=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).length();
 			if(distToPlayer<24*ConfigInt("Range")/100.f){
-				m.I(A::PHASE)++;
+				SETPHASE(PHASE()+1);
 				m.F(A::LOCKON_WAITTIME)=ConfigFloat("Lockon Wait Time");
 				m.V(A::LOCKON_POS)=game->GetPlayer()->GetPos();
 				m.RotateTowardsPos(m.V(A::LOCKON_POS));
@@ -72,23 +72,23 @@ void Monster::STRATEGY::FROG(Monster&m,float fElapsedTime,std::string strategy){
 				SoundEffect::PlaySFX("Slime Shoot",m.pos);
 				CreateBullet(FrogTongue)(m,tongueMaxRangePos,ConfigFloat("Attack Duration"),m.GetAttack(),m.OnUpperLevel(),ConfigFloat("Tongue Knockback Strength"),false,ConfigPixel("Tongue Color"))EndBullet;
 				m.PerformShootAnimation();
-				m.I(A::PHASE)=2;
+				SETPHASE(2);
 			}
 			m.PerformIdleAnimation();
 		}break;
 		case 2:{
 			if(m.F(A::LOCKON_WAITTIME)==0.0f){
 				m.F(A::LOCKON_WAITTIME)=ConfigFloat("Attack Recovery Time");
-				m.I(A::PHASE)=3;
+				SETPHASE(3);
 			}
 		}break;
 		case 3:{
 			if(m.F(A::LOCKON_WAITTIME)==0.0f){
-				m.I(A::PHASE)=0;
+				SETPHASE(0);
 			}
 		}break;
 		default:{
-			ERR(std::format("Unhandled phase {} for {} strategy!",m.I(A::PHASE),strategy));
+			ERR(std::format("Unhandled phase {} for {} strategy!",PHASE(),strategy));
 		}
 	}
 }

Adventures in Lestoria/FrogTongue.cpp

@@ -56,13 +56,14 @@ void FrogTongue::Update(float fElapsedTime){
 		geom2d::line<float>lineToTarget(pos,targetPos);
 		vf2d drawVec=lineToTarget.vector().norm()*3;
 
-		tongueLength=util::lerp(0,lineToTarget.length(),pow(sin((lifetime*PI)/duration),20.f));
+		tongueLength=util::lerp(0.f,lineToTarget.length(),pow(sin((lifetime*PI)/duration),20.f));
 
 		vf2d tongueEndPos=geom2d::line<float>(pos+drawVec,targetPos).upoint(pow(sin((lifetime*PI)/duration),20.f));
 		geom2d::line<float>tongueLine(pos+drawVec,tongueEndPos);
 
-		if(!friendly&&geom2d::overlaps(game->GetPlayer()->Hitbox(),tongueLine)){
+		if(!friendly&&hitList.find(game->GetPlayer())==hitList.end()&&geom2d::overlaps(game->GetPlayer()->Hitbox(),tongueLine)){
 			_PlayerHit(game->GetPlayer());
+			hitList.insert(game->GetPlayer());
 		}
 		if(friendly){
 			for(std::shared_ptr<Monster>&m:MONSTER_LIST){

Adventures in Lestoria/GhostOfPirateCaptain.cpp

@@ -0,0 +1,211 @@
+#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 "MonsterStrategyHelpers.h"
+#include "util.h"
+#include "AdventuresInLestoria.h"
+#include "SoundEffect.h"
+#include "BulletTypes.h"
+#include <ranges>
+
+using A=Attribute;
+
+INCLUDE_game
+INCLUDE_MONSTER_LIST
+
+void Monster::STRATEGY::GHOST_OF_PIRATE_CAPTAIN(Monster&m,float fElapsedTime,std::string strategy){
+	enum PhaseName{
+		INIT,
+		NORMAL,
+		AFTERIMAGE_FADEIN,
+		GHOSTSABER_SLASH=999,
+		TOSS_COIN,
+	};
+
+	enum CannonShotType{
+		BOMBARDMENT,//every shot is at a random location within 900 Range of the player. (This is also the move during hide and seek.)
+		PRECISE_BOMBARDMENT,//same as before but within 700 range of the player.
+		LINE,//the 4th or 5th hit would hit the player if the player doesnt move at all.
+		SHARPSHOOTER,//aiming directly at the player, skipping every 2nd shot. (only 4 instead of 8 shots)
+		PREDICTION,//shoots in the direction of the current or last players movement and predicts where the player would be in 2.8 seconds. (slightly further then where the player would be at impact. thats why 2.8 instead of 2.5 seconds)
+	};
+
+	static const uint8_t PHASE_COUNT{uint8_t(DATA.GetProperty("MonsterStrategy.Ghost of Pirate Captain.Cannon Cycle").GetValueCount())};
+	static uint8_t TOTAL_CANNON_SHOTS{0};
+
+	const auto AdvanceCannonPhase{[&m,&strategy](){
+		m.GetFloat(A::CANNON_TIMER)=0.f;
+		if(m.GetInt(A::CANNON_PHASE)+1>=PHASE_COUNT)m.GetInt(A::CANNON_SHOT_TYPE)=util::random()%5;
+		const int prevCannonPhase{m.I(A::CANNON_PHASE)};
+		m.I(A::CANNON_PHASE)=(m.I(A::CANNON_PHASE)+1)%PHASE_COUNT;
+		if(prevCannonPhase>m.I(A::CANNON_PHASE)){//Phase has wrapped around, reset cannon shot count.
+			m.I(A::CANNON_SHOT_COUNT)=0;
+			if(!m.B(A::FIRST_WAVE_COMPLETE)){
+				m.B(A::FIRST_WAVE_COMPLETE)=true;
+				m.ForceSetPos(m.spawnPos);
+				m.SetupAfterImage();
+				m.afterImagePos=m.GetPos();
+				m.SetCollisionRadius(0.f);
+				m.F(A::CASTING_TIMER)=1.f;
+				SETPHASE(AFTERIMAGE_FADEIN);
+			}
+		}
+	}};
+	
+	if(m.F(A::SHRAPNEL_SHOT_FALL_TIMER)>0.f){
+		m.F(A::SHRAPNEL_SHOT_FALL_TIMER)-=fElapsedTime;
+		while(m.I(A::SHRAPNEL_SHOT_COUNT)&&m.F(A::SHRAPNEL_SHOT_FALL_TIMER)<=0.f){
+			const float randomAng{util::random_range(0,2*PI)};
+			const float range{util::random_range(0,ConfigPixels("Bombardment Max Distance"))};
+			const vf2d targetPos{game->GetPlayer()->GetPos()+vf2d{range,randomAng}.cart()};
+			m.F(A::SHRAPNEL_SHOT_FALL_TIMER)+=ConfigFloat("Shrapnel Shot Bullet Separation");
+			CreateBullet(FallingBullet)("cannonball.png",targetPos,ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Shrapnel Shot Bullet Radius"),ConfigInt("Shrapnel Shot Damage"),m.OnUpperLevel(),false,ConfigFloat("Shrapnel Knockback Amt"),ConfigFloat("Shrapnel Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Shrapnel Shot Bullet Radius")/100.f*1.75f,ConfigFloat("Shrapnel Shot Bullet Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+			m.I(A::SHRAPNEL_SHOT_COUNT)--;
+		}
+	}
+
+	m.F(A::GHOST_SABER_TIMER)-=fElapsedTime;
+	
+	if(m.B(A::FIRST_WAVE_COMPLETE)){
+		m.UpdateFacingDirection(m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
+		m.SetVelocity(util::pointTo(m.GetPos(),game->GetPlayer()->GetPos())*100.f*m.GetMoveSpdMult());
+		const float distToPlayer{util::distance(m.GetPos(),game->GetPlayer()->GetPos())};
+		if(m.F(A::GHOST_SABER_TIMER)<=0.f&&distToPlayer<=ConfigPixels("Ghost Saber Activation Range")){
+			m.F(A::GHOST_SABER_TIMER)=ConfigFloat("Ghost Saber Cooldown");
+			const float playerToMonsterAngle{util::pointTo(game->GetPlayer()->GetPos(),m.GetPos()).polar().y};
+			CreateBullet(GhostSaber)(m.GetPos(),m.GetWeakPointer(),ConfigFloat("Ghost Saber Lifetime"),ConfigFloat("Ghost Saber Distance"),ConfigFloat("Ghost Saber Knockback Amt"),playerToMonsterAngle,ConfigFloat("Ghost Saber Radius"),ConfigFloat("Ghost Saber Expand Spd"),ConfigInt("Ghost Saber Damage"),m.OnUpperLevel(),util::degToRad(ConfigFloat("Ghost Saber Rotation Spd")))EndBullet;
+		}
+	}
+
+	switch(PHASE()){
+		enum CannonPhaseType{
+			CANNON_SHOT,
+			SILENCE,
+			SHRAPNEL_SHOT,
+		};
+		case INIT:{
+			for(int i:std::ranges::iota_view(0U,PHASE_COUNT)){
+				const int cannonCycle{DATA.GetProperty("MonsterStrategy.Ghost of Pirate Captain.Cannon Cycle").GetInt(i)};
+				m.VEC(A::CANNON_PHASES).emplace_back(cannonCycle);
+				if(cannonCycle==CANNON_SHOT)TOTAL_CANNON_SHOTS++;
+			}
+			m.B(A::FIRST_WAVE_COMPLETE)=false;
+			m.I(A::CANNON_SHOT_TYPE)=BOMBARDMENT;
+			m.ForceSetPos({-400.f,-400.f});
+			SETPHASE(NORMAL);
+		}break;
+		case NORMAL:{
+			m.F(A::CANNON_TIMER)+=fElapsedTime;
+			const int phase{std::any_cast<int>(m.VEC(A::CANNON_PHASES)[m.I(A::CANNON_PHASE)])};
+			switch(phase){
+				case CANNON_SHOT:{//Normal Cannon Shot. Takes on one of five varieties.
+					if(m.F(A::CANNON_TIMER)>=ConfigFloat("Cannon Shot Delay")){
+						switch(m.I(A::CANNON_SHOT_TYPE)){
+							case BOMBARDMENT:{
+								const float randomAng{util::random_range(0,2*PI)};
+								const float range{util::random_range(0,ConfigPixels("Bombardment Max Distance"))};
+								const vf2d targetPos{game->GetPlayer()->GetPos()+vf2d{range,randomAng}.cart()};
+								CreateBullet(FallingBullet)("cannonball.png",targetPos,ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Cannon Radius"),ConfigInt("Cannon Damage"),m.OnUpperLevel(),false,ConfigFloat("Cannon Knockback Amt"),ConfigFloat("Cannon Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Cannon Radius")/100.f*1.75f,ConfigFloat("Cannon Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+							}break;
+							case PRECISE_BOMBARDMENT:{
+								const float randomAng{util::random_range(0,2*PI)};
+								const float range{util::random_range(0,ConfigPixels("Precise Bombardment Max Distance"))};
+								const vf2d targetPos{game->GetPlayer()->GetPos()+vf2d{range,randomAng}.cart()};
+								CreateBullet(FallingBullet)("cannonball.png",targetPos,ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Cannon Radius"),ConfigInt("Cannon Damage"),m.OnUpperLevel(),false,ConfigFloat("Cannon Knockback Amt"),ConfigFloat("Cannon Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Cannon Radius")/100.f*1.75f,ConfigFloat("Cannon Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+							}break;
+							case LINE:{
+								//Draw a line from one side of the screen to the other, drawing through the middle.
+								if(m.I(A::CANNON_SHOT_COUNT)==0)m.F(A::LINE_SHOT_ANG)=util::random_range(0,2*PI);
+								const vf2d targetPos{geom2d::line{game->GetPlayer()->GetPos()+vf2d{float(game->ScreenHeight()),m.F(A::LINE_SHOT_ANG)}.cart(),game->GetPlayer()->GetPos()+vf2d{float(game->ScreenHeight()),m.F(A::LINE_SHOT_ANG)+PI}.cart()}.upoint(float(m.I(A::CANNON_SHOT_COUNT))/TOTAL_CANNON_SHOTS)};
+								CreateBullet(FallingBullet)("cannonball.png",targetPos,ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Cannon Radius"),ConfigInt("Cannon Damage"),m.OnUpperLevel(),false,ConfigFloat("Cannon Knockback Amt"),ConfigFloat("Cannon Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Cannon Radius")/100.f*1.75f,ConfigFloat("Cannon Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+							}break;
+							case SHARPSHOOTER:{
+								if(m.I(A::CANNON_SHOT_COUNT)%2==0)CreateBullet(FallingBullet)("cannonball.png",game->GetPlayer()->GetPos(),ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Cannon Radius"),ConfigInt("Cannon Damage"),m.OnUpperLevel(),false,ConfigFloat("Cannon Knockback Amt"),ConfigFloat("Cannon Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Cannon Radius")/100.f*1.75f,ConfigFloat("Cannon Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+							}break;
+							case PREDICTION:{
+								LOG(std::format("Previous Pos: {} Current: {}",game->GetPlayer()->GetPreviousPos().str(),game->GetPlayer()->GetPos().str()));
+								const float angle{util::angleTo(game->GetPlayer()->GetPreviousPos(),game->GetPlayer()->GetPos())};
+								const float range{util::random_range(0,100.f*game->GetPlayer()->GetMoveSpdMult())*ConfigFloat("Cannon Shot Impact Time")};
+								LOG(std::format("Range/Angle: {}",vf2d{range,angle}.str()));
+								const vf2d targetPos{game->GetPlayer()->GetPos()+vf2d{range,angle}.cart()};
+								CreateBullet(FallingBullet)("cannonball.png",targetPos,ConfigVec("Cannon Vel"),ConfigFloatArr("Cannon Vel",2),ConfigFloat("Indicator Time"),ConfigPixels("Cannon Radius"),ConfigInt("Cannon Damage"),m.OnUpperLevel(),false,ConfigFloat("Cannon Knockback Amt"),ConfigFloat("Cannon Shot Impact Time"),false,ConfigPixel("Cannon Spell Circle Color"),vf2d{ConfigFloat("Cannon Radius")/100.f*1.75f,ConfigFloat("Cannon Radius")/100.f*1.75f},util::random(2*PI),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Circle Rotation Spd")),ConfigPixel("Cannon Spell Insignia Color"),util::random(2*PI),util::degToRad(ConfigFloat("Cannon Spell Insignia Rotation Spd")))EndBullet;
+							}break;
+						}
+						AdvanceCannonPhase();
+						m.I(A::CANNON_SHOT_COUNT)++;
+					}
+				}break;
+				case SILENCE:{
+					if(m.F(A::CANNON_TIMER)>=ConfigFloat("Silence Time"))AdvanceCannonPhase();
+				}break;
+				case SHRAPNEL_SHOT:{
+					if(m.F(A::CANNON_TIMER)>=ConfigFloat("Shrapnel Shot Delay")){
+						m.I(A::SHRAPNEL_SHOT_COUNT)=ConfigInt("Shrapnel Shot Bullet Count");
+						m.F(A::SHRAPNEL_SHOT_FALL_TIMER)=ConfigFloat("Shrapnel Shot Bullet Separation");
+						AdvanceCannonPhase();
+					}
+				}break;
+			}
+
+			if(Config("Curse Thresholds").GetValueCount()>m.I(A::CURSE_THRESHOLD_ARRAY_IND)&&
+				m.GetHealthRatio()<=ConfigFloatArr("Curse Thresholds",m.I(A::CURSE_THRESHOLD_ARRAY_IND))){
+				m.I(A::CURSE_THRESHOLD_ARRAY_IND)++;
+				SETPHASE(TOSS_COIN);
+			}
+		}break;
+		case AFTERIMAGE_FADEIN:{
+			m.F(A::CASTING_TIMER)-=fElapsedTime;
+			if(m.F(A::CASTING_TIMER)<=0.f){
+				SETPHASE(NORMAL);
+				m.SetCollisionRadius(m.GetOriginalCollisionRadius());
+			}
+		}break;
+		case GHOSTSABER_SLASH:{ //This was triggered by GhostSaber when 
+			m.F(A::GHOST_SABER_SLASH_ANIMATION_TIMER)-=fElapsedTime;
+			if(m.F(A::GHOST_SABER_SLASH_ANIMATION_TIMER)<=0.f){
+				m.PerformIdleAnimation();
+				SETPHASE(m.I(A::PREVIOUS_PHASE));
+			}
+		}break;
+		case TOSS_COIN:{
+			const float curseDmgPctOverTime{ConfigFloat("Curse Damage")};
+			game->GetPlayer()->AddBuff(BuffType::PIRATE_GHOST_CAPTAIN_CURSE,ConfigFloat("Curse Damage Wait Time"),ceil(game->GetPlayer()->GetMaxHealth()*ConfigFloat("Curse Damage")/100.f)+1,[curseDmgPctOverTime](Player*attachedTarget,Buff&b){attachedTarget->AddBuff(BuffType::PIRATE_GHOST_CAPTAIN_CURSE_DOT,BuffRestorationType::OVER_TIME,BuffOverTimeType::HP_PCT_DAMAGE_OVER_TIME,INFINITY,curseDmgPctOverTime,1.f);});
+			SETPHASE(NORMAL);
+		}break;
+	}
+}

Adventures in Lestoria/GhostSaber.cpp

@@ -0,0 +1,84 @@
+#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 "BulletTypes.h"
+#include "Attributable.h"
+
+GhostSaber::GhostSaber(const vf2d pos,const std::weak_ptr<Monster>target,const float lifetime,const float distFromTarget,const float knockbackAmt,const float initialRot,const float radius,const float expandSpd,const int damage,const bool upperLevel,const float rotSpd,const bool friendly,const Pixel col,const vf2d scale,const float image_angle)
+:Bullet(target.lock()->GetPos()+vf2d{distFromTarget,initialRot}.cart(),{},radius,damage,"ghost_dagger.png",upperLevel,false,INFINITE,false,friendly,col,scale,image_angle),attachedMonster(target),rotSpd(rotSpd),distFromTarget(distFromTarget),rot(initialRot),aliveTime(lifetime),knockbackAmt(knockbackAmt),expandSpd(expandSpd){}
+void GhostSaber::Update(float fElapsedTime){
+	alphaOscillator.Update(fElapsedTime);
+	particleTimer-=fElapsedTime;
+	aliveTime-=fElapsedTime;
+	distFromTarget+=expandSpd*fElapsedTime;
+	if(particleTimer<=0.f){
+		particleTimer+=0.05f;
+		game->AddEffect(std::make_unique<ShineEffect>(pos,0.1f,0.1f,"pixel.png",2.f,vf2d{},Pixel{239,215,98,192},util::random(2*PI),0.f,true));
+	}
+	rot+=rotSpd*fElapsedTime;
+	if(!attachedMonster.expired()){
+		pos=attachedMonster.lock()->GetPos()+vf2d{distFromTarget,rot}.cart();
+	}
+	if(aliveTime<=0.f&&!IsDeactivated()){
+		Deactivate();
+		fadeOutTime=0.5f;
+	}
+	col.a=alphaOscillator.get();
+	image_angle=-rot*2;
+};
+
+BulletDestroyState GhostSaber::PlayerHit(Player*player){
+	player->ApplyIframes(0.2f);
+	player->Knockback(vf2d{knockbackAmt,rot}.cart());
+	if(!attachedMonster.expired()){
+		const int GHOSTSABER_SLASH_PHASEID{999};
+		attachedMonster.lock()->GetInt(Attribute::PREVIOUS_PHASE)=attachedMonster.lock()->GetPhase(attachedMonster.lock()->GetStrategyName());
+		attachedMonster.lock()->SetPhase(attachedMonster.lock()->GetStrategyName(),GHOSTSABER_SLASH_PHASEID);
+		attachedMonster.lock()->PerformAnimation("SLASHING");
+		attachedMonster.lock()->GetFloat(Attribute::GHOST_SABER_SLASH_ANIMATION_TIMER)=attachedMonster.lock()->GetCurrentAnimation().GetTotalAnimationDuration();
+	}
+	return BulletDestroyState::KEEP_ALIVE;
+}
+
+BulletDestroyState GhostSaber::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit){
+	monster.ApplyIframes(0.2f);
+	monster.Knockback(vf2d{knockbackAmt,rot}.cart());
+	return BulletDestroyState::KEEP_ALIVE;
+}
+
+void GhostSaber::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/GiantCrab.cpp

@@ -0,0 +1,84 @@
+#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 "MonsterStrategyHelpers.h"
+#include "util.h"
+#include "AdventuresInLestoria.h"
+#include "SoundEffect.h"
+#include "BulletTypes.h"
+
+using A=Attribute;
+
+INCLUDE_game
+
+void Monster::STRATEGY::GIANT_CRAB(Monster&m,float fElapsedTime,std::string strategy){
+	enum PhaseName{
+		PREPARE_CHARGE,
+		CHARGE,
+	};
+	switch(PHASE()){
+		case PREPARE_CHARGE:{
+			m.F(A::CASTING_TIMER)-=fElapsedTime;
+			if(m.F(A::CASTING_TIMER)<=0.f){
+				m.AddBuff(BuffType::SPEEDBOOST,ConfigFloat("Charge Time"),0.f);
+				m.F(A::SPEED_RAMPUP_TIMER)=0.1f;
+				SETPHASE(CHARGE);
+			}
+		}break;
+		case CHARGE:{
+			m.F(A::CHASE_TIMER)+=fElapsedTime;
+			m.F(A::SPEED_RAMPUP_TIMER)-=fElapsedTime;
+			if(m.F(A::CHASE_TIMER)>=ConfigFloat("Charge Time")||m.ReachedTargetPos()){
+				m.F(A::CHASE_TIMER)=0.f;
+				m.target=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).rpoint(util::distance(m.GetPos(),game->GetPlayer()->GetPos())+ConfigPixels("Charge Extend Distance"));
+				m.RemoveBuff(BuffType::SPEEDBOOST);
+				m.F(A::CASTING_TIMER)=ConfigFloat("Charge Wait Time");
+				SETPHASE(PREPARE_CHARGE);
+			}
+			if(m.F(A::SPEED_RAMPUP_TIMER)<=0.f){
+				m.F(A::SPEED_RAMPUP_TIMER)=0.1f;
+				if(m.HasBuff(BuffType::SPEEDBOOST)){
+					const float buffIntensity{m.GetBuffs(BuffType::SPEEDBOOST)[0].intensity};
+					m.EditBuff(BuffType::SPEEDBOOST,0).intensity=std::min(buffIntensity+ConfigFloat("Movespeed Rampup Final Amount")/100.f/(ConfigFloat("Movespeed Rampup Time")/0.1f),ConfigFloat("Movespeed Rampup Final Amount")/100.f);
+				}
+			}
+
+			RUN_TOWARDS(m,fElapsedTime,"Run Towards");
+		}break;
+	}
+}

Adventures in Lestoria/GiantOctopus.cpp

@@ -0,0 +1,179 @@
+#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 "MonsterStrategyHelpers.h"
+#include "util.h"
+#include "AdventuresInLestoria.h"
+#include "SoundEffect.h"
+#include "BulletTypes.h"
+
+using A=Attribute;
+
+INCLUDE_game
+INCLUDE_MONSTER_LIST
+
+void Monster::STRATEGY::GIANT_OCTOPUS(Monster&m,float fElapsedTime,std::string strategy){
+	enum PhaseName{
+		INIT,
+		IDENTIFY_ARMS,
+		NORMAL,
+		HURT_ANIMATION,
+		DEAD,
+	};
+
+	if(!m.B(A::ARM_SPEEDS_INCREASED)&&m.GetHealth()<=ConfigInt("Arm Speedup Health Threshold")){
+		m.B(A::ARM_SPEEDS_INCREASED)=true;
+		for(std::shared_ptr<Monster>&arm:MONSTER_LIST){
+			const std::string OCTOPUS_ARM_NAME{"Octopus Arm"};
+			if(arm->GetName()==OCTOPUS_ARM_NAME){
+				std::weak_ptr<Monster>armPtr{arm};
+				if(!armPtr.expired())armPtr.lock()->GetFloat(A::ATTACK_ANIMATION_SPEED)=1.f+ConfigFloat("Arm Animation Speed Increase")/100.f;
+			}
+		}
+	}
+
+	switch(PHASE()){
+		case INIT:{
+			m.F(A::BREAK_TIME)=0.5f;
+			m.AddBuff(BuffType::DAMAGE_REDUCTION,INFINITE,ConfigFloat("Permanent Resistance Buff")/100.f);
+			m.SetStrategyDeathFunction([](GameEvent&event,Monster&m,const std::string&strategy){
+				std::string takoyakiImgDir{"item_img_directory"_S+"Takoyaki.png"};
+				if(!GFX.count(takoyakiImgDir))ERR(std::format("WARNING! Could not find item image {}",takoyakiImgDir));
+				game->AddEffect(std::make_unique<Effect>(m.GetPos(),INFINITE,"item_img_directory"_S+"Takoyaki.png",m.OnUpperLevel(),1.f,0.f,vf2d{4.f,4.f},vf2d{},WHITE));
+				m.SetLifetime(4.f);
+				SETPHASE(DEAD);
+				return false;
+			});
+			SETPHASE(IDENTIFY_ARMS);
+		}break;
+		case IDENTIFY_ARMS:{
+			m.F(A::BREAK_TIME)-=fElapsedTime;
+			if(m.F(A::BREAK_TIME)<=0.f){
+				m.F(A::CASTING_TIMER)=util::random_range(ConfigFloatArr("Arm Move Timer",0),ConfigFloatArr("Arm Move Timer",1));
+				for(std::shared_ptr<Monster>&arm:MONSTER_LIST){
+					const std::string OCTOPUS_ARM_NAME{"Octopus Arm"};
+					if(arm->GetName()==OCTOPUS_ARM_NAME){
+						std::weak_ptr<Monster>armPtr{arm};
+						m.VEC(A::ARM_LIST).emplace_back(armPtr);
+						m.VEC(A::ARM_LOCATIONS).emplace_back(armPtr.lock()->GetPos());
+					}
+				}
+				SETPHASE(NORMAL);
+			}
+		}break;
+		case NORMAL:{
+			const bool InSecondPhase{m.GetHealth()<=ConfigInt("Phase 2 Health Threshold")};
+			m.F(A::SHOOT_TIMER)-=fElapsedTime;
+			m.F(A::CASTING_TIMER)-=fElapsedTime;
+			m.F(A::LAST_SHOOT_TIMER)-=fElapsedTime;
+			m.F(A::LAST_INK_SHOOT_TIMER)-=fElapsedTime;
+			if(m.F(A::SHOOT_ANIMATION_TIME)>0.f){
+				m.F(A::SHOOT_ANIMATION_TIME)-=fElapsedTime;
+				if(m.F(A::SHOOT_ANIMATION_TIME)<=0.f)m.PerformIdleAnimation();
+			}
+			if(m.F(A::CASTING_TIMER)<=0.f){
+				int deadMonsterCount{0};
+				std::vector<vf2d>unoccupiedArmLocs;
+				AddAllUnoccupedArmLocations:
+				std::for_each(m.VEC(A::ARM_LOCATIONS).begin(),m.VEC(A::ARM_LOCATIONS).end(),[&unoccupiedArmLocs](const std::any&armLoc){unoccupiedArmLocs.emplace_back(std::any_cast<vf2d>(armLoc));});
+				std::vector<std::any>liveArms;
+				RemoveOccupiedArmLocationsAndDetectAliveArms:
+				std::copy_if(m.VEC(A::ARM_LIST).begin(),m.VEC(A::ARM_LIST).end(),std::back_inserter(liveArms),[&unoccupiedArmLocs,&deadMonsterCount](const std::any&arm){
+					const std::weak_ptr<Monster>&m{std::any_cast<std::weak_ptr<Monster>>(arm)};
+					const bool isLive{!m.expired()&&m.lock()->IsAlive()};
+					if(isLive)std::erase_if(unoccupiedArmLocs,[&m](const vf2d&armLoc){return m.lock()->GetPos()==armLoc;});
+					else deadMonsterCount++;
+					return isLive;
+				});
+				RemoveArmLocationsTooFarFromPlayer:
+				std::erase_if(unoccupiedArmLocs,[maxDist=ConfigPixels("Arm Max Move Distance From Player")](const vf2d&armLoc){return util::distance(game->GetPlayer()->GetPos(),armLoc)>maxDist;});
+				const bool AtLeastOneArmAlive{deadMonsterCount!=m.VEC(A::ARM_LIST).size()};
+				if(deadMonsterCount>0&&AtLeastOneArmAlive&&unoccupiedArmLocs.size()>0){
+					const std::weak_ptr<Monster>&randomArm{std::any_cast<std::weak_ptr<Monster>>(liveArms[util::random()%liveArms.size()])};
+					const vf2d&randomLoc{std::any_cast<vf2d>(unoccupiedArmLocs[util::random()%unoccupiedArmLocs.size()])};
+					randomArm.lock()->PerformAnimation("SUBMERGE");
+					randomArm.lock()->SetPhase("Octopus Arm",randomArm.lock()->I(A::SUBMERGE_STRAT_ID));
+					randomArm.lock()->GetFloat(A::RECOVERY_TIME)=randomArm.lock()->GetCurrentAnimation().GetTotalAnimationDuration();
+					randomArm.lock()->SetCollisionRadius(0.f);
+					randomArm.lock()->V(A::JUMP_TARGET_POS)=randomLoc;
+					randomArm.lock()->SetStrategyDrawFunction([](AiL*game,Monster&monster,const std::string&strategy){});
+				}
+				m.F(A::CASTING_TIMER)=util::random_range(ConfigFloatArr("Arm Move Timer",0),ConfigFloatArr("Arm Move Timer",1));
+			}
+			if(m.F(A::SHOOT_TIMER)<=0.f){
+				const auto CreateBurstBullet=[&](){
+					CreateBullet(BurstBullet)(m.GetPos(),util::pointTo(m.GetPos(),game->GetPlayer()->GetPos())*ConfigFloat("Big Bullet Speed"),game->GetPlayer(),ConfigPixels("Big Bullet Detection Radius"),ConfigInt("Big Bullet Extra Bullet Count"),util::degToRad(ConfigFloat("Big Bullet Extra Bullet Rotate Speed")),ConfigFloat("Big Bullet Extra Bullet Radius"),vf2d{ConfigFloatArr("Big Bullet Extra Bullet Image Scale",0),ConfigFloatArr("Big Bullet Extra Bullet Image Scale",1)},ConfigFloat("Big Bullet Extra Bullet Speed"),ConfigFloat("Big Bullet Extra Bullet Acceleration"),ConfigFloat("Big Bullet Radius"),ConfigInt("Big Bullet Damage"),m.OnUpperLevel(),false,ConfigPixel("Big Bullet Color"),vf2d{ConfigFloat("Big Bullet Image Scale"),ConfigFloat("Big Bullet Image Scale")})EndBullet;
+					m.F(A::SHOOT_TIMER)=ConfigFloat("Big Bullet Boss Rest Time");
+					m.I(A::ATTACK_COUNT)=-1;
+				};
+				if(InSecondPhase){
+					if(m.F(A::LAST_INK_SHOOT_TIMER)<=0.f){
+						CreateBullet(InkBullet)(m.GetPos(),game->GetPlayer()->GetPos(),vf2d{ConfigFloat("Phase 2.Ink Bullet Speed"),0.f},ConfigFloat("Phase 2.Ink Explosion Radius"),ConfigFloat("Phase 2.Ink Puddle Lifetime"),ConfigFloat("Phase 2.Ink Slowdown Time"),ConfigFloat("Phase 2.Ink Slowdown Amount")/100.f,ConfigFloat("Phase 2.Ink Puddle Collision Radius"),m.OnUpperLevel(),false)EndBullet;
+						m.F(A::LAST_INK_SHOOT_TIMER)=ConfigFloat("Phase 2.Ink Bullet Frequency");
+						goto BulletShot;
+					}else
+					if(m.I(A::BULLET_COUNT_AFTER_INK_ATTACK)>ConfigInt("Phase 2.Homing Bullet Starts After")){
+						if(m.I(A::ATTACK_COUNT)%ConfigInt("Phase 2.Homing Bullet Frequency")==0)CreateBullet(HomingBullet)(m.GetPos(),Entity{game->GetPlayer()},util::degToRad(ConfigFloat("Phase 2.Homing Bullet Rotation Speed")),util::degToRad(ConfigFloat("Phase 2.Homing Bullet Rotation Speed Player Covered In Ink")),ConfigFloat("Phase 2.Homing Bullet Lifetime"),ConfigFloat("Bullet Speed"),ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Damage"),m.OnUpperLevel(),false,ConfigPixel("Phase 2.Homing Bullet Color"),{ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Radius")})EndBullet;
+						else 
+						if(m.I(A::ATTACK_COUNT)>=ConfigInt("Big Bullet Frequency")-1)CreateBurstBullet();
+						else CreateBullet(Bullet)(m.GetPos(),util::pointTo(m.GetPos(),game->GetPlayer()->GetPos())*ConfigFloat("Bullet Speed"),ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Damage"),m.OnUpperLevel(),false,ConfigPixel("Bullet Color"),{ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Radius")})EndBullet;
+						m.F(A::SHOOT_TIMER)=ConfigFloat("Shoot Frequency");
+						goto BulletShot;
+					}
+					m.I(A::BULLET_COUNT_AFTER_INK_ATTACK)++;
+				}
+				if(m.I(A::ATTACK_COUNT)>=ConfigInt("Big Bullet Frequency")-1)CreateBurstBullet();
+				else{
+					m.F(A::SHOOT_TIMER)=ConfigFloat("Shoot Frequency");
+					CreateBullet(Bullet)(m.GetPos(),util::pointTo(m.GetPos(),game->GetPlayer()->GetPos())*ConfigFloat("Bullet Speed"),ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Damage"),m.OnUpperLevel(),false,ConfigPixel("Bullet Color"),{ConfigFloat("Bullet Radius"),ConfigFloat("Bullet Radius")})EndBullet;
+				}
+				BulletShot:
+				m.F(A::LAST_SHOOT_TIMER)=1.f;
+				m.PerformShootAnimation(m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
+				m.I(A::ATTACK_COUNT)++;
+			}
+			if(m.F(A::LAST_SHOOT_TIMER)<=0.f){
+				m.PerformIdleAnimation(m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
+			}
+		}break;
+		case HURT_ANIMATION:{
+
+		}break;
+		case DEAD:{}break;
+	}
+}

Adventures in Lestoria/Goblin_Boar_Rider.cpp

@@ -52,17 +52,16 @@ void Monster::STRATEGY::GOBLIN_BOAR_RIDER(Monster&m,float fElapsedTime,std::stri
 	if(!m.B(A::INITIALIZED_MOUNTED_MONSTER)){
 		m.B(A::INITIALIZED_MOUNTED_MONSTER)=true;
 		m.F(A::PERCEPTION_LEVEL)=ConfigFloat("Starting Perception Level");
-		m.internal_mounted_animState=Animate2D::AnimationState{};
 		m.mounted_animation=Animate2D::Animation<std::string>{};
 		
 		for(bool firstAnimation=true;const std::string&animation:Config("Imposed Monster Animations").GetValues()){
 			m.mounted_animation.value().AddState(animation,ANIMATION_DATA.at(animation));
 			
-			if(firstAnimation)m.mounted_animation.value().ChangeState(m.internal_mounted_animState.value(),animation);
+			if(firstAnimation)m.mounted_animation.value().ChangeState(m.internal_mounted_animState,animation);
 			firstAnimation=false;
 		}
 		m.mountedSprOffset=ConfigVec("Imposed Monster Offset");
-		m.deathData.push_back(DeathSpawnInfo{ConfigString("Spawned Monster"),1U});
+		m.deathData.emplace_back(ConfigString("Spawned Monster"),1U);
 	}
 
 	BOAR(m,fElapsedTime,"Boar");
@@ -79,11 +78,11 @@ void Monster::STRATEGY::GOBLIN_BOAR_RIDER(Monster&m,float fElapsedTime,std::stri
 
 			m.F(A::ATTACK_COOLDOWN)=0.f;
 			m.F(A::PERCEPTION_LEVEL)=std::min(ConfigFloat("Maximum Perception Level"),m.F(A::PERCEPTION_LEVEL)+ConfigFloat("Perception Level Increase"));
-			m.mounted_animation.value().ChangeState(m.internal_mounted_animState.value(),std::format("GOBLIN_BOW_MOUNTED_{}",int(m.GetFacingDirection())));
+			m.mounted_animation.value().ChangeState(m.internal_mounted_animState,std::format("GOBLIN_BOW_MOUNTED_{}",int(m.GetFacingDirection())));
 		}
 	}else
 	if(m.F(A::ATTACK_COOLDOWN)>=ConfigFloat("Attack Reload Time")){
 		m.F(A::SHOOT_TIMER)=ConfigFloat("Attack Windup Time");
-		m.mounted_animation.value().ChangeState(m.internal_mounted_animState.value(),std::format("GOBLIN_BOW_ATTACK_{}",int(m.GetFacingDirection())));
+		m.mounted_animation.value().ChangeState(m.internal_mounted_animState,std::format("GOBLIN_BOW_ATTACK_{}",int(m.GetFacingDirection())));
 	}
 }

Adventures in Lestoria/Goblin_Bomb.cpp

@@ -60,10 +60,10 @@ void Monster::STRATEGY::GOBLIN_BOMB(Monster&m,float fElapsedTime,std::string str
 		RUN,
 	};
 
-	switch(m.phase){
+	switch(PHASE()){
 		case INITIALIZE:{
 			m.F(A::SHOOT_TIMER)=m.randomFrameOffset;
-			m.phase=RUN;
+			SETPHASE(RUN);
 		}break;
 		case RUN:{      
 			m.F(A::SHOOT_TIMER)+=fElapsedTime;

Adventures in Lestoria/Goblin_Bow.cpp

@@ -66,10 +66,10 @@ void Monster::STRATEGY::GOBLIN_BOW(Monster&m,float fElapsedTime,std::string stra
 		};
 	#pragma endregion
 
-	switch(m.phase){
+	switch(PHASE()){
 		case INITIALIZE_PERCEPTION:{
 			m.F(A::PERCEPTION_LEVEL)=ConfigFloat("Starting Perception Level");
-			m.phase=MOVE;
+			SETPHASE(MOVE);
 		}break;
 		case MOVE:{
 			m.F(A::ATTACK_COOLDOWN)+=fElapsedTime;
@@ -79,7 +79,7 @@ void Monster::STRATEGY::GOBLIN_BOW(Monster&m,float fElapsedTime,std::string stra
 			const bool outsideMaxShootingRange=distToPlayer>=ConfigPixelsArr("Stand Still and Shoot Range",1);
 
 			auto PrepareToShoot=[&](){
-				m.phase=LOCKON;
+				SETPHASE(LOCKON);
 				m.F(A::SHOOT_TIMER)=ConfigFloat("Attack Windup Time");
 
 				m.PerformAnimation("SHOOT",m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
@@ -118,7 +118,7 @@ void Monster::STRATEGY::GOBLIN_BOW(Monster&m,float fElapsedTime,std::string stra
 				m.V(A::EXTENDED_LINE)=extendedLine;
 				Arrow tempArrow{m.GetPos(),extendedLine,pointTowardsPlayer.vector().norm()*ConfigFloat("Arrow Spd"),"goblin_arrow.png",ConfigFloat("Arrow Hitbox Radius"),m.GetAttack(),m.OnUpperLevel()};
 				m.V(A::FIRE_VELOCITY)=tempArrow.PointToBestTargetPath(m.F(A::PERCEPTION_LEVEL));
-				m.phase=WINDUP;
+				SETPHASE(WINDUP);
 			}
 		}break;
 		case WINDUP:{
@@ -128,7 +128,7 @@ void Monster::STRATEGY::GOBLIN_BOW(Monster&m,float fElapsedTime,std::string stra
 				CreateBullet(Arrow)(m.GetPos(),m.V(A::EXTENDED_LINE),m.V(A::FIRE_VELOCITY),"goblin_arrow.png",ConfigFloat("Arrow Hitbox Radius"),m.GetAttack(),m.OnUpperLevel())EndBullet;
 				m.F(A::PERCEPTION_LEVEL)=std::min(ConfigFloat("Maximum Perception Level"),m.F(A::PERCEPTION_LEVEL)+ConfigFloat("Perception Level Increase"));
 				m.PerformAnimation("IDLE",m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
-				m.phase=MOVE;
+				SETPHASE(MOVE);
 			}
 			m.B(A::RANDOM_DIRECTION)=util::random()%2;
 			m.F(A::RANDOM_RANGE)=util::random_range(ConfigPixelsArr("Random Direction Range",0),ConfigPixelsArr("Random Direction Range",1));

Adventures in Lestoria/Goblin_Dagger.cpp

@@ -66,13 +66,13 @@ void Monster::STRATEGY::GOBLIN_DAGGER(Monster&m,float fElapsedTime,std::string s
 		SLASH
 	};
 
-	switch(m.phase){
+	switch(PHASE()){
 		case MOVE:{
 			float distToPlayer=m.GetDistanceFrom(game->GetPlayer()->GetPos());
 			if(distToPlayer>ConfigFloat("Attack Spacing")/100.f*24){
 				RUN_TOWARDS(m,fElapsedTime,"Run Towards");
 			}else{
-				m.phase=WINDUP;
+				SETPHASE(WINDUP);
 				m.I(A::ATTACK_TYPE)=util::random()%2; //Choose randomly between stab or slash.
 				switch(m.I(A::ATTACK_TYPE)){
 					case STAB:{
@@ -90,18 +90,18 @@ void Monster::STRATEGY::GOBLIN_DAGGER(Monster&m,float fElapsedTime,std::string s
 		case WINDUP:{
 			m.F(A::CASTING_TIMER)-=fElapsedTime;
 			if(m.F(A::CASTING_TIMER)<=0){
-				m.phase=RECOVERY;
+				SETPHASE(RECOVERY);
 				switch(m.I(A::ATTACK_TYPE)){
 					case STAB:{
 						vf2d stabTarget=game->GetPlayer()->GetPos();
 						m.PerformAnimation("STABBING",m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
-						CreateBullet(DaggerStab)(m,ConfigFloat("Dagger Hit Radius"),m.GetAttack(),ConfigFloat("Dagger Stab Knockback"),m.OnUpperLevel(),m.GetFacingDirectionToTarget(stabTarget),ConfigFloat("Dagger Frame Duration"),ConfigFloat("Dagger Stab Distance"),
+						CreateBullet(DaggerStab)(m,ConfigString("Dagger Stab Image"),ConfigFloat("Dagger Hit Radius"),m.GetAttack(),ConfigFloat("Dagger Stab Knockback"),m.OnUpperLevel(),m.GetFacingDirectionToTarget(stabTarget),ConfigFloat("Dagger Frame Duration"),ConfigFloat("Dagger Stab Distance"),
 							DaggerStab::DirectionOffsets{ConfigVec("Dagger Up Offset"),ConfigVec("Dagger Down Offset"),ConfigVec("Dagger Right Offset"),ConfigVec("Dagger Left Offset")})EndBullet;
 					}break;
 					case SLASH:{
 						vf2d slashTarget=game->GetPlayer()->GetPos();
 						m.PerformAnimation("SLASHING",m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));
-						CreateBullet(DaggerSlash)(m,ConfigFloat("Dagger Hit Radius"),m.GetAttack(),ConfigFloat("Dagger Slash Knockback"),m.OnUpperLevel(),m.GetFacingDirectionToTarget(slashTarget),ConfigFloat("Dagger Frame Duration"),ConfigFloat("Dagger Slash Distance"))EndBullet;
+						CreateBullet(DaggerSlash)(m,ConfigString("Dagger Slash Image"),ConfigFloat("Dagger Hit Radius"),m.GetAttack(),ConfigFloat("Dagger Slash Knockback"),m.OnUpperLevel(),m.GetFacingDirectionToTarget(slashTarget),ConfigFloat("Dagger Frame Duration"),ConfigFloat("Dagger Slash Distance"))EndBullet;
 					}break;
 					default:ERR(std::format("WARNING! Invalid Attack type {} provided. THIS SHOULD NOT BE HAPPENING!",m.I(A::ATTACK_TYPE)));
 				}
@@ -113,7 +113,7 @@ void Monster::STRATEGY::GOBLIN_DAGGER(Monster&m,float fElapsedTime,std::string s
 			m.F(A::CASTING_TIMER)-=fElapsedTime;
 			m.F(A::RECOVERY_TIME)-=fElapsedTime;
 			if(m.F(A::CASTING_TIMER)<=0){m.PerformIdleAnimation(m.GetFacingDirectionToTarget(game->GetPlayer()->GetPos()));}
-			if(m.F(A::RECOVERY_TIME)<=0)m.phase=MOVE;
+			if(m.F(A::RECOVERY_TIME)<=0)SETPHASE(MOVE);
 		}break;
 	}
 }

Adventures in Lestoria/Hawk.cpp

@@ -63,11 +63,11 @@ void Monster::STRATEGY::HAWK(Monster&m,float fElapsedTime,std::string strategy){
 		m.SetZ(std::max(float(m.F(A::FLYING_HEIGHT)+ConfigFloat("Flight Oscillation Amount")*sin((PI*m.TimeSpentAlive())/1.5f)),0.f));
 	#pragma endregion
 
-	switch(m.phase){
+	switch(PHASE()){
 		case INITIALIZE:{
 			m.F(A::TARGET_FLYING_HEIGHT)=m.F(A::FLYING_HEIGHT)=ConfigFloat("Flight Height")-ConfigFloat("Flight Height Variance")+util::random_range(0,ConfigFloat("Flight Height Variance")*2);
 			m.B(A::RANDOM_DIRECTION)=int(util::random_range(0,2));
-			m.phase=FLYING;
+			SETPHASE(FLYING);
 			m.AddBuff(BuffType::SELF_INFLICTED_SLOWDOWN,INFINITE,util::random_range(0,ConfigFloat("Flight Speed Variance")/100));
 			m.F(A::ATTACK_COOLDOWN)=util::random_range(1.f,ConfigFloat("Flight Charge Cooldown"));
 		}break;
@@ -76,7 +76,7 @@ void Monster::STRATEGY::HAWK(Monster&m,float fElapsedTime,std::string strategy){
 			if(m.F(A::FLYING_HEIGHT)<m.F(A::TARGET_FLYING_HEIGHT))m.F(A::FLYING_HEIGHT)=std::min(m.F(A::TARGET_FLYING_HEIGHT),m.F(A::FLYING_HEIGHT)+ConfigFloat("Attack Z Speed")*fElapsedTime);
 			if(m.F(A::ATTACK_COOLDOWN)<=0){
 				m.F(A::CASTING_TIMER)=ConfigFloat("Attack Wait Time");
-				m.phase=PREPARE_CHARGE;
+				SETPHASE(PREPARE_CHARGE);
 			}else{
 				float dirToPlayer{util::pointTo(game->GetPlayer()->GetPos(),m.GetPos()).polar().y};
 				dirToPlayer+=m.B(A::RANDOM_DIRECTION)?0.25*PI:-0.25*PI;
@@ -89,7 +89,7 @@ void Monster::STRATEGY::HAWK(Monster&m,float fElapsedTime,std::string strategy){
 			m.UpdateFacingDirection(game->GetPlayer()->GetPos());
 			m.PerformAnimation("ATTACK");
 			if(m.F(A::CASTING_TIMER)<=0){
-				m.phase=CHARGE;
+				SETPHASE(CHARGE);
 				m.PerformAnimation("ATTACKING");
 				m.target=geom2d::line<float>(m.GetPos(),game->GetPlayer()->GetPos()).rpoint(ConfigFloat("Flight Distance")*2.f);
 				m.UpdateFacingDirection(m.target);
@@ -103,7 +103,7 @@ void Monster::STRATEGY::HAWK(Monster&m,float fElapsedTime,std::string strategy){
 			float distToTarget=geom2d::line<float>(m.GetPos(),m.target).length();
 			if(distToTarget<12.f){
 				m.F(A::TARGET_FLYING_HEIGHT)=ConfigFloat("Flight Height")-ConfigFloat("Flight Height Variance")+util::random_range(0,ConfigFloat("Flight Height Variance")*2);
-				m.phase=FLYING;
+				SETPHASE(FLYING);
 				m.F(A::ATTACK_COOLDOWN)=ConfigFloat("Flight Charge Cooldown");
 				m.PerformJumpAnimation();
 			}

Adventures in Lestoria/HomingBullet.cpp

@@ -0,0 +1,54 @@
+#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 "BulletTypes.h"
+
+HomingBullet::HomingBullet(const vf2d pos,const Entity target,const float rotateTowardsSpeed,const float rotateTowardsSpeedCoveredInInk,const float lifetime,const float speed,const float radius,const int damage,const bool upperLevel,const bool friendly,const Pixel col,const vf2d scale,const float image_angle)
+:Bullet(pos,util::pointTo(pos,target.GetPos())*speed,radius,damage,upperLevel,friendly,col,scale,image_angle),target(target),rotateTowardsSpeed(rotateTowardsSpeed),rotateTowardsSpeedCoveredInInk(rotateTowardsSpeedCoveredInInk){
+	this->lifetime=lifetime;
+}
+void HomingBullet::Update(float fElapsedTime){
+	const float magnitude{vel.mag()};
+	float bulletAngle{vel.polar().y};
+	float bulletRotationSpeed{rotateTowardsSpeed};
+	if(game->GetPlayer()->CoveredInInk())bulletRotationSpeed=rotateTowardsSpeedCoveredInInk;
+	if(util::distance(pos,game->GetPlayer()->GetPos())>=7*24.f)bulletRotationSpeed=0.f; //Don't rotate if basically offscreen.
+	util::turn_towards_target(bulletAngle,pos,target.GetPos(),bulletRotationSpeed,fElapsedTime);
+	vel=vf2d{magnitude,bulletAngle}.cart();
+}
+void HomingBullet::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/HubPauseMenu.cpp

@@ -0,0 +1,130 @@
+#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 "Menu.h"
+#include "MenuComponent.h"
+#include "GameState.h"
+#include "MenuLabel.h"
+#include "AdventuresInLestoria.h"
+#include "CharacterRotatingDisplay.h"
+#include "ClassInfo.h"
+#include "Unlock.h"
+
+INCLUDE_game
+INCLUDE_GFX
+
+void Menu::InitializeHubPauseWindow(){
+	Menu*hubPauseWindow=CreateMenu(MenuType::HUB_PAUSE,CENTERED,vi2d{96,168});
+
+	hubPauseWindow->ADD("Resume Button",MenuComponent)(geom2d::rect<float>{{6.f,0.f},{84.f,24.f}},"Resume",[](MenuFuncData data){void ClearGarbage();
+		game->ClearGarbage();
+		Menu::CloseMenu();
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+	hubPauseWindow->ADD("Character Button",MenuComponent)(geom2d::rect<float>{{6.f,28.f},{84.f,24.f}},"Character",[](MenuFuncData data){
+		Component<CharacterRotatingDisplay>(CHARACTER_MENU,"Character Rotating Display")->SetIcon(GFX[classutils::GetClassInfo(game->GetPlayer()->GetClassName()).classFullImgName].Decal());
+		Component<MenuComponent>(CHARACTER_MENU,"Equip Selection Select Button")->Click();
+		Menu::OpenMenu(CHARACTER_MENU);
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+	hubPauseWindow->ADD("Change Loadout Button",MenuComponent)(geom2d::rect<float>{{6.f,56.f},{84.f,24.f}},"Change\nLoadout",[](MenuFuncData data){
+		Menu::OpenMenu(ITEM_HUB_LOADOUT);
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+	hubPauseWindow->ADD("Inventory Button",MenuComponent)(geom2d::rect<float>{{6.f,84.f},{84.f,24.f}},"Inventory",[](MenuFuncData data){
+		Menu::OpenMenu(INVENTORY);
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+	hubPauseWindow->ADD("Settings Button",MenuComponent)(geom2d::rect<float>{{6.f,112.f},{84.f,24.f}},"Settings",[](MenuFuncData data){
+		Menu::OpenMenu(SETTINGS);
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+	hubPauseWindow->ADD("Return to Camp Button",MenuComponent)(geom2d::rect<float>{{6.f,140.f},{84.f,24.f}},"Leave Area",[](MenuFuncData data){
+		Component<MenuLabel>(LEVEL_COMPLETE,"Stage Complete Label")->SetLabel("Stage Summary");
+		Component<MenuComponent>(LEVEL_COMPLETE,"Level Details Outline")->SetLabel("");
+
+		if(game->GetCurrentMapName()=="HUB"&&game->PreviousStageCompleted())Unlock::UnlockCurrentMap(); //Special unlock for the hub area when leaving.
+
+		if(Unlock::IsUnlocked("STORY_1_1")){
+			Component<MenuComponent>(LEVEL_COMPLETE,"Next Button")->Enable();
+		}else{
+			Component<MenuComponent>(LEVEL_COMPLETE,"Next Button")->Disable();
+		}
+		if(GameState::STATE==GameState::states[States::GAME_HUB]){
+			GameState::ChangeState(States::OVERWORLD_MAP,0.4f);
+		}else{
+			GameState::ChangeState(States::LEVEL_COMPLETE,0.4f);
+		}
+		return true;
+	},ButtonAttr::FIT_TO_LABEL)END;
+
+	hubPauseWindow->SetupKeyboardNavigation(
+	[](MenuType type,Data&returnData){ //On Open
+		returnData="Resume Button";
+	},
+	{ //Button Key
+		{game->KEY_SCROLL,{"Navigate",[](MenuType type){}}},
+		{game->KEY_BACK,{"Resume",[](MenuType type){
+			Component<MenuComponent>(type,"Resume Button")->Click();
+		}}},
+		{game->KEY_MENU,{"Resume",[](MenuType type){
+			Component<MenuComponent>(type,"Resume Button")->Click();
+		}}},
+		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+	}
+	,{ //Button Navigation Rules
+		{"Resume Button",{
+			.up="Return to Camp Button",
+			.down="Character Button",}},
+		{"Character Button",{
+			.up="Resume Button",
+			.down="Change Loadout Button",}},
+		{"Change Loadout Button",{
+			.up="Character Button",
+			.down="Inventory Button",}},
+		{"Inventory Button",{
+			.up="Change Loadout Button",
+			.down="Settings Button",}},
+		{"Settings Button",{
+			.up="Inventory Button",
+			.down="Return to Camp Button",}},
+		{"Return to Camp Button",{
+			.up="Settings Button",
+			.down="Resume Button",}},
+	});
+}

Adventures in Lestoria/IBullet.cpp

@@ -51,7 +51,7 @@ INCLUDE_WINDOW_SIZE
 IBullet::IBullet(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col,vf2d scale,float image_angle)
 	:pos(pos),vel(vel),radius(radius),damage(damage),col(col),friendly(friendly),upperLevel(upperLevel),scale(scale),image_angle(image_angle){};
 
-IBullet::IBullet(vf2d pos,vf2d vel,float radius,int damage,std::string animation,bool upperLevel,bool hitsMultiple,float lifetime,bool rotatesWithAngle,bool friendly,Pixel col,vf2d scale,float image_angle,std::string_view hitSound)
+IBullet::IBullet(vf2d pos,vf2d vel,float radius,int damage,const std::string&animation,bool upperLevel,bool hitsMultiple,float lifetime,bool rotatesWithAngle,bool friendly,Pixel col,vf2d scale,float image_angle,std::string_view hitSound)
 	:pos(pos),vel(vel),radius(radius),damage(damage),col(col),animated(true),rotates(rotatesWithAngle),lifetime(lifetime),hitsMultiple(hitsMultiple),friendly(friendly),upperLevel(upperLevel),scale(scale),image_angle(image_angle),hitSound(std::string(hitSound)){
 	this->animation.AddState(animation,ANIMATION_DATA.at(animation));
 	this->animation.ChangeState(internal_animState,animation);
@@ -88,8 +88,8 @@ void IBullet::_Update(const float fElapsedTime){
 	UpdateFadeTime(fElapsedTime);
 	Update(fElapsedTime);
 	animation.UpdateState(internal_animState,fElapsedTime);
-	const bool CollisionCheckRequired=IsActivated()&&fadeInTimer==fadeInTime&&radius!=0.f;
-	if(CollisionCheckRequired){
+	const auto CollisionCheckRequired=[this](){return IsActivated()&&fadeInTimer==fadeInTime&&radius!=0.f;};
+	if(CollisionCheckRequired()){
 		float totalDistance=(vel*fElapsedTime).mag();
 		int iterations=int(std::max(1.f,(vel*fElapsedTime).mag()));
 		int totalIterations=iterations;
@@ -106,31 +106,29 @@ void IBullet::_Update(const float fElapsedTime){
 							ModifyOutgoingDamageData(damageData);
 							uint8_t markStacksBeforeHit{m->GetMarkStacks()};
 							if(m->Hurt(damageData)){
+								hitList.insert(&*m);
 								if(!hitsMultiple){
-									if(_MonsterHit(*m,markStacksBeforeHit)==BulletDestroyState::DESTROY){
-										dead=true;
-									}
+									if(_MonsterHit(*m,markStacksBeforeHit)==BulletDestroyState::DESTROY)dead=true;
 									return false;
 								}else _MonsterHit(*m,markStacksBeforeHit);
-								hitList.insert(&*m);
+								if(!CollisionCheckRequired())return false;
 							}
 						}
 					}
 				}
-			} else {
+			}else{
 				if(geom2d::overlaps(game->GetPlayer()->Hitbox(),geom2d::circle(pos,radius))){
 					if(hitList.find(game->GetPlayer())==hitList.end()){
 						HurtDamageInfo damageData{game->GetPlayer(),damage,OnUpperLevel(),z,HurtFlag::NONE};
 						//NOTE: OnHurt() will potentially change the Damage Data, passing it along to bullet children that might need to modify the flags!
 						ModifyOutgoingDamageData(damageData);
 						if(game->GetPlayer()->Hurt(damageData)){
+							hitList.insert(game->GetPlayer());
 							if(!hitsMultiple){
-								if(_PlayerHit(&*game->GetPlayer())==BulletDestroyState::DESTROY){
-									dead=true;
-								}
+								if(_PlayerHit(&*game->GetPlayer())==BulletDestroyState::DESTROY)dead=true;
 								return false;
 							}else _PlayerHit(&*game->GetPlayer());
-							hitList.insert(game->GetPlayer());
+							if(!CollisionCheckRequired())return false;
 						}
 					}
 				}
@@ -141,6 +139,7 @@ void IBullet::_Update(const float fElapsedTime){
 		while(iterations>0){
 			iterations--;
 			if(IsPlayerAutoAttackProjectile()){pos+=(game->GetWindSpeed()*game->GetElapsedTime())/float(totalIterations);}
+			vel=vf2d{vel.polar().x+(acc*fElapsedTime/float(totalIterations)),vel.polar().y}.cart();
 			pos+=(vel*fElapsedTime)/float(totalIterations);
 			if(!CollisionCheck()){
 				goto DeadBulletCheck;
@@ -152,6 +151,7 @@ void IBullet::_Update(const float fElapsedTime){
 		}
 	}else{
 		if(IsPlayerAutoAttackProjectile()){pos+=game->GetWindSpeed()*game->GetElapsedTime();}
+		vel=vf2d{vel.polar().x+acc*fElapsedTime,vel.polar().y}.cart();
 		pos+=vel*fElapsedTime;
 	}
 
@@ -168,11 +168,13 @@ void IBullet::_Update(const float fElapsedTime){
 }
 
 void IBullet::_Draw()const{
+	game->SetDecalMode(DecalMode::NORMAL);
+	if(additiveBlending)game->SetDecalMode(DecalMode::ADDITIVE);
 	Pixel blendCol=col;
 	
 	if(fadeInTime==0&&fadeOutTime==0)blendCol.a=col.a;
-	else if(fadeOutTime>0)blendCol.a=uint8_t(util::lerp(col.a,0,1-((fadeOutTime-fadeOutTimer)/fadeOutTime)));
-	else if(fadeInTime>0)blendCol.a=uint8_t(util::lerp(col.a,0,((fadeInTime-fadeInTimer)/fadeInTime)));
+	else if(fadeOutTime>0)blendCol.a=uint8_t(util::lerp(col.a,uint8_t(0),1-((fadeOutTime-fadeOutTimer)/fadeOutTime)));
+	else if(fadeInTime>0)blendCol.a=uint8_t(util::lerp(col.a,uint8_t(0),((fadeInTime-fadeInTimer)/fadeInTime)));
 
 	if(GetZ()>0){
 		vf2d shadowScale=vf2d{8*scale.x/3.f,1}/std::max(1.f,GetZ()/8);
@@ -186,6 +188,7 @@ void IBullet::_Draw()const{
 		blendCol.a/=1.59f; //Comes from 255 divided by 160 which is roughly what we want the alpha to be when the bullet has full transparency.
 	}
 	Draw(blendCol);
+	game->SetDecalMode(DecalMode::NORMAL);
 }
 
 void IBullet::Draw(const Pixel blendCol)const{
@@ -274,6 +277,10 @@ void IBullet::Deactivate(){
 	deactivated=true;
 }
 
+void IBullet::Activate(){
+	deactivated=false;
+}
+
 const double IBullet::GetTimeAlive()const{
 	return aliveTime;
 }

Adventures in Lestoria/IBullet.h

@@ -42,6 +42,11 @@ All rights reserved.
 #include "DEFINES.h"
 using HitList=std::unordered_set<std::variant<Monster*,Player*>>;
 
+enum class HurtType{
+	PLAYER=0b01,
+	MONSTER=0b10,
+};
+
 enum class BulletType{
 	UNDEFINED,
 	FEATHER,
@@ -55,6 +60,7 @@ enum class BulletDestroyState{
 
 struct IBullet{
 	friend class AiL;
+	float acc{};
 	vf2d vel;
 	vf2d pos;
 	float radius;
@@ -76,6 +82,8 @@ protected:
 	float fadeInTime=0; //Setting the fade in time causes the bullet to be disabled and the bullet's alpha will fade in from zero to the actual alpha of the bullet. When the fade in timer reaches the fade in time automatically, the bullet will be enabled.
 	virtual void Update(float fElapsedTime);
 	void Deactivate();
+	void Activate();
+	bool additiveBlending{false};
 private:
 	float fadeOutTimer=0;
 	float fadeInTimer=0;
@@ -104,7 +112,7 @@ public:
 	virtual ~IBullet()=default;
 	IBullet(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f);
 	//Initializes a bullet with an animation.
-	IBullet(vf2d pos,vf2d vel,float radius,int damage,std::string animation,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool rotatesWithAngle=false,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f,std::string_view hitSound="");
+	IBullet(vf2d pos,vf2d vel,float radius,int damage,const std::string&animation,bool upperLevel,bool hitsMultiple=false,float lifetime=INFINITE,bool rotatesWithAngle=false,bool friendly=false,Pixel col=WHITE,vf2d scale={1,1},float image_angle=0.f,std::string_view hitSound="");
 	public:
 
 	void SimulateUpdate(const float fElapsedTime);

Adventures in Lestoria/IT.cpp

@@ -49,9 +49,14 @@ IT::IT(std::string name)
 		itemName=ITEM_CONVERSIONS.at(name); //Convert the item if it's using an old name.
 	}
 }
+IT::IT(std::string_view name)
+	:IT(std::string(name)){}
 IT::operator std::string(){
 	return itemName;
 }
+IT::operator std::string_view(){
+	return itemName;
+}
 std::ostream&operator<<(std::ostream&rhs,IT&item){
 	rhs<<item.itemName;
 	return rhs;

Adventures in Lestoria/IT.h

@@ -49,7 +49,9 @@ class IT{
 public:
 	IT();
 	IT(std::string name);
+	IT(std::string_view name);
 	operator std::string();
+	operator std::string_view();
 	const bool operator==(const std::shared_ptr<Item>&rhs);
 	const bool operator==(const std::weak_ptr<Item>&rhs);
 	friend std::ostream&operator<<(std::ostream&rhs,IT&item);

Adventures in Lestoria/Ink.cpp

@@ -0,0 +1,52 @@
+#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 "AdventuresInLestoria.h"
+
+INCLUDE_game
+
+Ink::Ink(vf2d pos,float radius,float lifetime,float inkSlowdownDuration,float inkSlowdownPct,float fadeinTime,float fadeoutTime,vf2d size,Pixel col,bool onUpperLevel,float rotation)
+	:Effect(pos,lifetime,"ink.png",onUpperLevel,fadeinTime,fadeoutTime,size,{},EffectType::NONE,col,rotation,0.f,false),radius(radius),inkSlowdownDuration(inkSlowdownDuration),inkSlowdownAmount(inkSlowdownPct){}
+bool Ink::Update(float fElapsedTime){
+	const float distToPlayer{util::distance(game->GetPlayer()->GetPos(),pos)};
+	if(distToPlayer<=radius){
+		Buff&currentInkSlowdown{game->GetPlayer()->GetOrAddBuff(BuffType::INK_SLOWDOWN,{inkSlowdownDuration,inkSlowdownAmount})};
+		currentInkSlowdown.duration=inkSlowdownDuration; //Reset the duration if needed.
+	}
+	return Effect::Update(fElapsedTime);
+}

Adventures in Lestoria/InkBullet.cpp

@@ -0,0 +1,66 @@
+#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 "BulletTypes.h"
+
+INCLUDE_ANIMATION_DATA
+
+InkBullet::InkBullet(const vf2d pos,const vf2d targetPos,const vf2d vel,const float inkExplosionRadius,const float inkPuddleLifetime,const float inkSlowdownDuration,const float inkSlowdownPct,const float inkPuddleRadius,const bool upperLevel,const bool friendly)
+:Bullet(pos,vel,inkExplosionRadius,0,"inkbullet.png",upperLevel,friendly),targetPos(targetPos),inkExplosionRadius(inkExplosionRadius),inkSlowdownPct(inkSlowdownPct),inkSlowdownDuration(inkSlowdownDuration),inkPuddleLifetime(inkPuddleLifetime),inkPuddleRadius(inkPuddleRadius){
+	additiveBlending=true;
+}
+void InkBullet::Update(float fElapsedTime){
+	const float magnitude{vel.mag()};
+	vel=util::pointTo(pos,targetPos)*magnitude;
+	if(util::distance(pos,targetPos)<=8.f){Splat();}
+	else if(GetAliveTime()>=30.f)ERR(std::format("WARNING! An Ink Bullet did not resolve to target position {} in time! Last reported pos: {}! THE DISTANCE THRESHOLD FOR INK EXPLOSIONS IS LIKELY TOO HIGH! THIS SHOULD NOT BE HAPPENING!",targetPos.str(),pos.str())); //NOTE: THIS SHOULD NOT BE HAPPENING! If this does, then we probably just set the distance threshold WAY TOO LOW! Let's crash for now.
+}
+void InkBullet::Splat(){
+	game->AddEffect(std::make_unique<Effect>(pos,ANIMATION_DATA["inkbubble_explode.png"].GetTotalAnimationDuration(),"inkbubble_explode.png",OnUpperLevel(),vf2d{1.f,1.f},0.f,vf2d{},WHITE,0.f,0.f,additiveBlending));
+	game->AddEffect(std::make_unique<Ink>(pos,inkPuddleRadius,inkPuddleLifetime,inkSlowdownDuration,inkSlowdownPct,0.4f,0.4f,vf2d{1.f,1.f},WHITE,OnUpperLevel(),int(util::random_range(0,4.f))*PI/2),true);
+	lifetime=0.f;
+}
+BulletDestroyState InkBullet::PlayerHit(Player*player){
+	Splat();
+	return BulletDestroyState::DESTROY;
+}
+BulletDestroyState InkBullet::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit){
+	Splat();
+	return BulletDestroyState::DESTROY;
+}
+void InkBullet::ModifyOutgoingDamageData(HurtDamageInfo&data){}

Adventures in Lestoria/Item.cpp

@@ -80,7 +80,7 @@ std::vector<std::string>ItemSortRules::secondarySort;
 Stats Stats::NO_MAX_HIGHLIGHT;
 
 ItemInfo::ItemInfo()
-	:customProps({nullptr,nullptr}),img(nullptr){}
+	:customProps({nullptr,nullptr}){}
 
 void ItemInfo::InitializeItems(){
 	Stats::NO_MAX_HIGHLIGHT={};
@@ -142,6 +142,8 @@ void ItemInfo::InitializeItems(){
 			std::string scriptName="",description="",category="";
 			std::string setName="";
 			float castTime=0;
+			float castRange=0;
+			float castSize=0;
 			std::vector<std::string> slot;
 			float cooldownTime="Item.Item Cooldown Time"_F;
 			std::vector<ItemAttribute>statValueList;
@@ -153,6 +155,7 @@ void ItemInfo::InitializeItems(){
 			std::unordered_set<std::string>equippableClass;
 			EventName useSound;
 			std::optional<std::string>fragmentName;
+			std::optional<std::string>fragmentIcon;
 			for(auto&[itemKey,itemValue]:data[key].GetKeys()){
 				std::string keyName=itemKey;
 				if(keyName=="Description"){
@@ -166,6 +169,12 @@ void ItemInfo::InitializeItems(){
 				}else
 				if(keyName=="Cast Time"){
 					castTime=float(data[key][keyName].GetReal());
+				}
+				if(keyName=="Cast Range"){
+					castRange=float(data[key][keyName].GetReal());
+				}else
+				if(keyName=="Cast Size"){
+					castSize=float(data[key][keyName].GetReal())/100.f*24;
 				}else
 				if(keyName=="Cooldown Time"){
 					cooldownTime=float(data[key][keyName].GetReal());
@@ -204,6 +213,9 @@ void ItemInfo::InitializeItems(){
 				}else
 				if(keyName.starts_with("Fragment Name")){
 					fragmentName=data[key][keyName].GetString();
+				}else
+				if(keyName.starts_with("Fragment Icon")){
+					fragmentIcon=data[key][keyName].GetString();
 				}else{ //THis is a custom override modifier for a script. NO-OP
 				}
 			}
@@ -298,6 +310,8 @@ void ItemInfo::InitializeItems(){
 			it.description=description;
 			it.category=category;
 			it.castTime=castTime;
+			it.castRange=castRange;
+			it.castSize=castSize;
 			it.cooldownTime=cooldownTime;
 			it.slot=EquipSlot::NONE;
 			it.set=setName;
@@ -316,7 +330,7 @@ void ItemInfo::InitializeItems(){
 				ERR("WARNING! Tried to add item "<<it.name<<" to category "<<it.category<<" which does not exist!")
 			}
 			ITEM_CATEGORIES.at(it.category).insert(it.name);
-			it.img=img.Decal();
+			it.img=img;
 			ItemProps&props=it.customProps;
 			if(scriptName!=""){
 				props.scriptProps=&DATA["ItemScript"][scriptName];
@@ -326,6 +340,7 @@ void ItemInfo::InitializeItems(){
 			it.minStats=minStats;
 			it.maxStats=maxStats;
 			it.fragmentName=fragmentName;
+			it.fragmentIcon=fragmentIcon;
 
 			#pragma region Equipment Category Verification Tests
 				int equipmentCategories=0;
@@ -366,19 +381,28 @@ void ItemInfo::InitializeItems(){
 		for(const auto&itemName:ITEM_CATEGORIES.at("Accessories")){
 			const std::string fragmentName{ITEM_DATA.at(itemName).fragmentName.value()};
 			ItemInfo&it{ITEM_DATA[fragmentName]};
-			GFX[fragmentName].Create(24,24);
+			GFX["item_img_directory"_S+fragmentName].Create(24,24);
+			it.img=GFX.at("item_img_directory"_S+fragmentName);
 			if(!game->TestingModeEnabled()){
+				if(it.FragmentIcon()){
+					game->SetDrawTarget(GFX.at("item_img_directory"_S+fragmentName).Sprite());
+					game->Clear(BLANK);
+					game->SetPixelMode(Pixel::ALPHA);
+					game->DrawSprite({},GFX.at(it.FragmentIcon().value()).Sprite());
+					game->SetDrawTarget(nullptr);
+					GFX.at("item_img_directory"_S+fragmentName).Decal()->Update();
+				}else{
 					#pragma region Collect colors from source ring image
 						std::set<Pixel>colors;
 						for(int y=0;y<24;y++){
 							for(int x=0;x<24;x++){
-								colors.insert(ITEM_DATA.at(itemName).img->sprite->GetPixel(x,y));
+								colors.insert(ITEM_DATA.at(itemName).Icon().Sprite()->GetPixel(x,y));
 							}
 						}
 						colors.erase(BLANK);
 					#pragma endregion
 					#pragma region Generate fragment with randomly sampled pixels from the source ring image
-					game->SetDrawTarget(GFX.at(fragmentName).Sprite());
+					game->SetDrawTarget(GFX.at("item_img_directory"_S+fragmentName).Sprite());
 					game->DrawSprite({},GFX.at("items/Fragment.png").Sprite(),1U,0U,[colors](const Pixel&in){
 						if(in==BLANK)return in;
 						for(const Pixel&p:colors){
@@ -387,11 +411,12 @@ void ItemInfo::InitializeItems(){
 						return in;
 					});
 					game->SetDrawTarget(nullptr);
-					GFX.at(fragmentName).Decal()->Update();
+					GFX.at("item_img_directory"_S+fragmentName).Decal()->Update();
 				#pragma endregion
 				}
-			it.img=GFX.at(fragmentName).Decal();
+			}
 			it.name=fragmentName;
+			it.fragmentIcon="item_img_directory"_S+fragmentName;
 			it.description="Fragment Description"_S;
 			it.category="Materials";
 			LOG(std::format("Item Fragment {} generated...",fragmentName));
@@ -412,15 +437,15 @@ void ItemInfo::InitializeItems(){
 ItemProps::ItemProps(utils::datafile*scriptProps,utils::datafile*customProps)
 	:scriptProps(scriptProps),customProps(customProps){}
 
-int ItemProps::GetIntProp(const std::string&prop,size_t index)const{
+int ItemProps::GetInt(const std::string&prop,size_t index)const{
 	if(customProps->HasProperty(prop)) return (*customProps)[prop].GetInt(index);
 	else return (*scriptProps)[prop].GetInt(index);
 };
-float ItemProps::GetFloatProp(const std::string&prop,size_t index)const{
+float ItemProps::GetFloat(const std::string&prop,size_t index)const{
 	if(customProps->HasProperty(prop)) return float((*customProps)[prop].GetReal(index));
 	else return float((*scriptProps)[prop].GetReal(index));
 };
-std::string ItemProps::GetStringProp(const std::string&prop,size_t index)const{
+std::string ItemProps::GetString(const std::string&prop,size_t index)const{
 	if(customProps->HasProperty(prop)) return (*customProps)[prop].GetString(index);
 	else return (*scriptProps)[prop].GetString(index);
 };
@@ -437,51 +462,6 @@ const std::unordered_map<std::string,BuffOverTimeType::BuffOverTimeType>ItemInfo
 	{"MP % Restore",BuffOverTimeType::MP_PCT_RESTORATION},
 };
 
-void ItemInfo::InitializeScripts(){
-
-	ITEM_SCRIPTS["Restore"]=[](AiL*game,ItemProps props){
-		for(const auto&[propName,buffType]:NameToBuffType){
-			int restoreAmt=props.GetIntProp(propName);
-			
-			game->GetPlayer()->AddBuff(BuffRestorationType::ONE_OFF,NameToBuffType.at(propName),0.01f,float(restoreAmt),0.0f);
-			if(restoreAmt>0&&props.PropCount(propName)==3){
-				game->GetPlayer()->AddBuff(BuffRestorationType::OVER_TIME,NameToBuffType.at(propName),props.GetFloatProp(propName,2),float(restoreAmt),props.GetFloatProp(propName,1));
-			}
-		}
-		return true;
-	};
-	
-	for(auto&[key,value]:ItemAttribute::attributes){
-		if(!DATA.GetProperty("ItemScript.Buff").HasProperty(key)){
-			ERR("WARNING! Buff Item Script does not support Buff "<<std::quoted(value.Name())<<"!");
-		}
-	}
-
-	ITEM_SCRIPTS["Buff"]=[](AiL*game,ItemProps props){
-		for(auto&[key,value]:ItemAttribute::attributes){
-			float intensity=props.GetFloatProp(key,0);
-			if(intensity==0.f)continue;
-			if(ItemAttribute::Get(key).DisplayAsPercent())intensity/=100;
-			game->GetPlayer()->AddBuff(BuffType::STAT_UP,props.GetFloatProp(key,1),intensity,{ItemAttribute::Get(key)});
-		}
-		return true;
-	};
-	ITEM_SCRIPTS["RestoreDuringCast"]=[](AiL*game,ItemProps props){
-		for(const auto&[propName,buffType]:NameToBuffType){
-			int restoreAmt=props.GetIntProp(propName);
-
-			game->GetPlayer()->AddBuff(BuffRestorationType::ONE_OFF,NameToBuffType.at(propName),0.01f,float(restoreAmt),0.0f);
-			if(restoreAmt>0&&props.PropCount(propName)==3){
-				game->GetPlayer()->AddBuff(BuffRestorationType::OVER_TIME_DURING_CAST,NameToBuffType.at(propName),props.GetFloatProp(propName,2),float(restoreAmt),props.GetFloatProp(propName,1));
-			}
-		}
-		return true;
-	};
-
-	ITEM_SCRIPTS.SetInitialized();
-	LOG(ITEM_SCRIPTS.size()<<" item scripts have been loaded.");
-}
-
 Item::Item()
 	:amt(0),it(nullptr),enhancementLevel(0){}
 
@@ -546,12 +526,14 @@ uint32_t Inventory::GetItemCount(IT it){
 }
 
 //Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
-bool Inventory::UseItem(IT it,uint32_t amt){
+bool Inventory::UseItem(IT it,uint32_t amt,const std::optional<vf2d>targetingPos){
 	if(!_inventory.count(it))return false;
 	//There are two places to manipulate items in (Both the sorted inventory and the actual inventory)
 	for(uint32_t i=0;i<amt;i++){
-		if(ExecuteAction(it)){
+		if(ExecuteAction(it,targetingPos)){
+			if(GameState::GetCurrentState()!=States::GAME_HUB){
 				return RemoveItem(GetItem(it)[0]);
+			}else return false;
 		}
 	}
 	return false;
@@ -666,9 +648,9 @@ void Inventory::InsertIntoStageInventoryCategory(std::shared_ptr<Item>itemRef,co
 	Menu::InventorySlotsUpdated(stageInventoryCategory);
 }
 
-bool Inventory::ExecuteAction(IT item){
+bool Inventory::ExecuteAction(IT item,const std::optional<vf2d>targetingPos){
 	if(ITEM_SCRIPTS.count(ITEM_DATA.at(item).useFunc)){
-		return ITEM_SCRIPTS.at(ITEM_DATA.at(item).useFunc)(game,ITEM_DATA[item].customProps);
+		return ITEM_SCRIPTS.at(ITEM_DATA.at(item).useFunc)(game,targetingPos,ITEM_DATA[item].customProps);
 	}else{
 		return false;
 	}
@@ -776,8 +758,8 @@ const std::string Item::Description(CompactText compact)const{
 const ITCategory Item::Category()const{
 	return it->Category();
 }
-const::Decal*const Item::Decal()const{
-	return it->Decal();
+const::Renderable&Item::Icon()const{
+	return it->Icon();
 }
 const ItemScript&Item::OnUseAction()const{
 	return it->OnUseAction();
@@ -792,8 +774,8 @@ const std::string&ItemInfo::Description()const{
 const ITCategory ItemInfo::Category()const{
 	return category;	
 }
-const::Decal*const ItemInfo::Decal()const{
-	return img;
+const::Renderable&ItemInfo::Icon()const{
+	return img.value().get();
 }
 const ItemScript&ItemInfo::OnUseAction()const{
 	return ITEM_SCRIPTS.at(useFunc);
@@ -840,7 +822,7 @@ void ItemOverlay::Draw(){
 		Pixel lightCol=Menu::GetCurrentTheme().GetButtonCol()*1.2f;
 		game->GradientFillRectDecal(pos,{item.width,8},darkCol,darkCol,darkCol,lightCol);
 		game->DrawRectDecal(pos,{item.width,8},Menu::GetCurrentTheme().GetHighlightCol());
-		game->DrawDecal(pos,const_cast<Decal*>(item.it.Decal()),{itemScale,itemScale});
+		game->DrawDecal(pos,const_cast<Decal*>(item.it.Icon().Decal()),{itemScale,itemScale});
 		game->DrawShadowStringPropDecal(pos+vf2d{itemScale*24+2,2},item.it.Name(),WHITE,BLACK,{0.5f,0.7f});
 		counter++;
 	}
@@ -1020,7 +1002,7 @@ void Item::EnhanceItem(uint8_t qty){
 			for(const auto&[name,amt]:consumedResources.GetItems()){
 				Inventory::RemoveItem(Inventory::GetItem(name)[0],amt);
 			}
-			game->GetPlayer()->SetMoney(game->GetPlayer()->GetMoney()-consumedResources.GetCost());
+			game->GetPlayer()->RemoveMoney(consumedResources.GetCost());
 
 			SoundEffect::PlaySFX("Enhance Item",SoundEffect::CENTERED);
 
@@ -1033,7 +1015,7 @@ void Item::EnhanceItem(uint8_t qty){
 			for(const auto&[name,amt]:consumedResources.GetItems()){
 				Inventory::RemoveItem(Inventory::GetItem(name)[0],amt);
 			}
-			game->GetPlayer()->SetMoney(game->GetPlayer()->GetMoney()-consumedResources.GetCost());
+			game->GetPlayer()->RemoveMoney(consumedResources.GetCost());
 		}
 	}
 	SoundEffect::PlaySFX("Craft Item",SoundEffect::CENTERED);
@@ -1073,8 +1055,7 @@ const std::string Stats::GetStatsString(const Stats&maxStats,CompactText compact
 
 		std::string col="";
 		if(maxStats.attributes.count(attr)&&int(val)>=int(maxStats.attributes.at(attr))){
-			Pixel shimmeringCol=PixelLerp({255,196,60},{254,217,133},sin((70*game->GetRunTime())/2.f+0.5f));
-			col=shimmeringCol.toHTMLColorCode();
+			col=Stats::GetShimmeringColor().toHTMLColorCode();
 		}
 
 		description+=col+std::string(attr.Name())+": "+statNumber+(attr.DisplayAsPercent()?"%":"")+"#FFFFFF";
@@ -1400,12 +1381,14 @@ const EquipSlot ItemInfo::StringToEquipSlot(std::string_view slotName){
 	return nameToEquipSlot[std::string(slotName)];
 }
 
-void Inventory::Disassemble(std::weak_ptr<Item>itemRef){
+const Inventory::DisassembleResult Inventory::Disassemble(std::weak_ptr<Item>itemRef){
 	if(ISBLANK(itemRef))ERR(std::format("WARNING! Trying to feed a blank item into the Disassemble function! THIS SHOULD NOT BE HAPPENING!"));
 	const std::shared_ptr<Item>&currentItem{itemRef.lock()};
 	if(!currentItem->IsAccessory())ERR(std::format("WARNING! Trying to disassemble Item {} which is not an accessory! THIS SHOULD NOT BE HAPPENING!",currentItem->ActualName()));
+	if(currentItem->IsLocked())return DisassembleResult::FAILED;
 	Inventory::RemoveItem(itemRef);
 	Inventory::AddItem(currentItem->FragmentName(),"Fragment Disassemble Gain Amount"_I);
+	return DisassembleResult::SUCCESS;
 }
 
 const std::string&Item::FragmentName()const{
@@ -1426,10 +1409,14 @@ const bool Item::CanBeRefined()const{
 	return false; //Maxed out, so cannot be refined.
 }
 
+const bool Item::CanBeEnchanted()const{
+	return IsAccessory()&&Inventory::GetItemCount(FragmentName())>="Fragment Enchant Cost"_i[0]&&game->GetPlayer()->GetMoney()>="Fragment Enchant Cost"_i[1];
+}
+
 RefineResult Item::Refine(){
 	if(!CanBeRefined())ERR("WARNING! Trying to refine an item that cannot be refined! Make sure you are checking with CanBeRefined() before calling this function!");
 	Inventory::RemoveItem(FragmentName(),"Fragment Refine Cost"_i[0]);
-	game->GetPlayer()->SetMoney(game->GetPlayer()->GetMoney()-"Fragment Refine Cost"_i[1]);
+	game->GetPlayer()->RemoveMoney("Fragment Refine Cost"_i[1]);
 	std::vector<ItemAttribute>statsAvailableForRefining;
 	for(const auto&[attr,val]:randomizedStats){
 		float maxVal{ITEM_DATA[ActualName()].GetMaxStats().A_Read(attr)};
@@ -1442,16 +1429,17 @@ RefineResult Item::Refine(){
 	const float oldAmt{randomizedStats.A_Read(chosenAttr)};
 	randomizedStats.A(chosenAttr)=std::min(maxStat,oldAmt+increaseAmt);
 	const float newAmt{randomizedStats.A_Read(chosenAttr)};
+	game->GetPlayer()->RecalculateEquipStats();
 	return RefineResult{chosenAttr,newAmt-oldAmt};
 }
 
-void Item::EnchantItem(const std::string_view enchantName){
-	enchant=ItemEnchant{enchantName};
+void Item::_EnchantItem(const ItemEnchant&newEnchant){
+	enchant=newEnchant;
 
 	game->GetPlayer()->RecalculateEquipStats();
 }
 
-std::optional<ItemEnchant>Item::GetEnchant()const{
+const std::optional<ItemEnchant>&Item::GetEnchant()const{
 	return enchant;
 }
 const bool Item::HasEnchant()const{
@@ -1462,3 +1450,76 @@ const Pixel Item::GetDisplayNameColor()const{
 	if(HasEnchant())col=enchant.value().DisplayCol();
 	return col;
 }
+const bool Item::SelectedEquipIsDifferent(const std::weak_ptr<Item>equipAttemptingToEquip,const EquipSlot slotToEquipTo){
+	std::weak_ptr<Item>currentItem=Inventory::GetEquip(slotToEquipTo);
+	switch(slotToEquipTo){
+		case EquipSlot::RING1:
+		case EquipSlot::RING2:{
+			std::weak_ptr<Item>otherItem;
+
+			if(slotToEquipTo&EquipSlot::RING1)otherItem=Inventory::GetEquip(EquipSlot::RING2);
+			else
+			if(slotToEquipTo&EquipSlot::RING2)otherItem=Inventory::GetEquip(EquipSlot::RING1);
+
+			const auto EquipIsNotSameAsOppositeRingSlot=[&equip=equipAttemptingToEquip,&otherItem](){
+				return &*equip.lock()!=&*otherItem.lock();
+			};
+			const auto EquipIsNotSameAsCurrentRingSlot=[&equip=equipAttemptingToEquip,&currentItem](){
+				return &*equip.lock()!=&*currentItem.lock();
+			};
+			const auto OneOfBothRingsDoesNotHaveEnchant=[&equip=equipAttemptingToEquip,&otherItem](){
+				return !equip.lock()->HasEnchant()||!otherItem.lock()->HasEnchant();
+			};
+			const auto BothRingsAreCompatible=[&equip=equipAttemptingToEquip,&otherItem](){ //Check if enchants are compatible... Currently unused.
+				return true;
+			};
+			return (ISBLANK(otherItem)&&(OneOfBothRingsDoesNotHaveEnchant()||BothRingsAreCompatible())||
+				EquipIsNotSameAsOppositeRingSlot()&&
+				EquipIsNotSameAsCurrentRingSlot()&&
+				(OneOfBothRingsDoesNotHaveEnchant()||BothRingsAreCompatible()));
+		}break;
+		default:{
+			return &*equipAttemptingToEquip.lock()!=&*currentItem.lock();
+		}
+	}
+}
+const std::optional<std::string>&ItemInfo::FragmentIcon()const{
+	return fragmentIcon;
+}
+
+const Pixel Stats::GetShimmeringColor(){
+	return PixelLerp({255,196,60},{254,217,133},sin((70*game->GetRunTime())/2.f+0.5f));
+}
+
+const std::optional<std::string>&Item::FragmentIcon()const{
+	return ITEM_DATA.at(FragmentName()).FragmentIcon();
+}
+
+const ItemEnchant&Item::ApplyRandomEnchant(){
+	if(!CanBeEnchanted())ERR("WARNING! Trying to enchant an item that cannot be enchanted! Make sure you are checking with CanBeEnchanted() before calling this function!");
+	ItemEnchant randomEnchant{ItemEnchant::RollRandomEnchant(GetEnchant())};
+	_EnchantItem(randomEnchant);
+	Inventory::RemoveItem(FragmentName(),"Fragment Enchant Cost"_i[0]);
+	game->GetPlayer()->RemoveMoney("Fragment Enchant Cost"_i[1]);
+	return GetEnchant().value();
+}
+
+void Item::RemoveEnchant(){
+	enchant.reset();
+}
+
+const float Item::CastRange()const{
+	return ITEM_DATA.at(ActualName()).CastRange();
+}
+
+const float ItemInfo::CastRange()const{
+	return castRange;
+}
+
+const float Item::CastSize()const{
+	return ITEM_DATA.at(ActualName()).CastSize();
+}
+
+const float ItemInfo::CastSize()const{
+	return castSize;
+}

Adventures in Lestoria/Item.h

@@ -57,8 +57,9 @@ class ItemProps;
 
 using ITCategory=std::string;
 using EventName=std::string;
+using EnchantName=std::string;
 
-using ItemScript=std::function<bool(AiL*,ItemProps)>;
+using ItemScript=std::function<bool(AiL*game,std::optional<vf2d>targetingPos,ItemProps props)>;
 
 enum class EquipSlot{
 	HELMET=	0b0000'0001,
@@ -111,6 +112,7 @@ public:
 	}
 	const std::string GetStatsString(const Stats&maxStats,CompactText compact=NON_COMPACT)const;
 	friend const bool operator==(const Stats&lhs,const Stats&rhs){return lhs.attributes==rhs.attributes;}
+	static const Pixel GetShimmeringColor();
 };
 
 struct Stats;
@@ -211,10 +213,12 @@ public:
 	const EventName&UseSound()const;
 	const ITCategory Category()const;
 	const EquipSlot GetEquipSlot()const;
-	const::Decal*const Decal()const;
+	const::Renderable&Icon()const;
 	const Stats GetStats()const;
 	const ItemScript&OnUseAction()const;
 	const float CastTime()const;
+	const float CastRange()const;
+	const float CastSize()const;
 	const bool UseDuringCast()const; //When true, the item is activated during the cast instead of after the cast.
 	const float CooldownTime()const;
 	//Use ISBLANK macro instead!! This should not be called directly!!
@@ -252,10 +256,16 @@ public:
 	//Assumes an item can be refined. CHECK WITH CanBeRefined() First!!!
 	//Refines a random stat by the parameters defined in the Accessories.txt configuration file. Also takes away the costs required to refine the item.
 	RefineResult Refine(); 
+	const bool CanBeEnchanted()const;
 	void Lock();
 	void Unlock();
-	void EnchantItem(const std::string_view enchantName);
-	std::optional<ItemEnchant>GetEnchant()const;
+	void RemoveEnchant();
+	void _EnchantItem(const ItemEnchant&newEnchant);
+	//Applies a random valid enchant to an item and consumes the materials in the process.
+	//Assumes an item can be enchanted. CHECK WITH CanBeEnchanted() First!!!
+	//Enchants the item based on its class parameters defined in the ItemEnchants.txt configuration file. Also takes away the costs required to refine the item (Located in Accessories.txt).
+	const ItemEnchant&ApplyRandomEnchant();
+	const std::optional<ItemEnchant>&GetEnchant()const;
 	const bool HasEnchant()const;
 	friend const bool operator==(std::shared_ptr<Item>lhs,std::shared_ptr<Item>rhs){return lhs->it==rhs->it&&lhs->randomizedStats==rhs->randomizedStats;};
 	friend const bool operator==(std::shared_ptr<Item>lhs,const IT&rhs){return lhs->ActualName()==const_cast<IT&>(rhs);};
@@ -264,6 +274,8 @@ public:
 	friend const bool operator==(const IT&lhs,std::weak_ptr<Item>rhs){return operator==(rhs,lhs);};
 	friend const bool operator==(const IT&lhs,std::shared_ptr<Item>rhs){return operator==(rhs,lhs);};
 	const Pixel GetDisplayNameColor()const;
+	static const bool SelectedEquipIsDifferent(const std::weak_ptr<Item>equipAttemptingToEquip,const EquipSlot slotToEquipTo);
+	const std::optional<std::string>&FragmentIcon()const;
 };
 
 class Inventory{
@@ -273,13 +285,19 @@ class Inventory{
 	friend class InventoryCreator;
 	friend class ItemTests::ItemTest;
 public:
+
+	enum class DisassembleResult{
+		SUCCESS,
+		FAILED, //Failure is due to an item being locked.
+	};
+
 	static std::weak_ptr<Item>AddItem(IT it,uint32_t amt=1,bool monsterDrop=false);
 	//Returns the actual amount available in your main inventory.
 	[[nodiscard]] static uint32_t GetItemCount(IT it);
 	static std::vector<std::shared_ptr<Item>>CopyItem(IT it);
 	static std::vector<std::weak_ptr<Item>>GetItem(IT it);
 	//Auto-executes its use function and removes the amt specified from the inventory. Multiple amounts will cause the item to execute its useFunc multiple times.
-	static bool UseItem(IT it,uint32_t amt=1);
+	static bool UseItem(IT it,uint32_t amt=1,const std::optional<vf2d>targetingPos={});
 	//Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
 	static bool RemoveItem(std::weak_ptr<Item>itemRef,ITCategory inventory,uint32_t amt = 1);
 	//Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
@@ -301,7 +319,7 @@ public:
 	static void ResetLoadoutItemsUsed();
 	static void GivePlayerLoadoutItemsUsed();
 	static const bool EquipsFullyMaxedOut(int maxWeaponLevel=10,int maxArmorLevel=10);
-	static void Disassemble(std::weak_ptr<Item>itemRef);
+	[[nodiscard]]static const Inventory::DisassembleResult Disassemble(std::weak_ptr<Item>itemRef);
 
 	static bool SwapItems(ITCategory itemCategory,uint32_t slot1,uint32_t slot2);
 	//Makes sure this is a valid category. Will error out if it doesn't exist! Use for ERROR HANDLING!
@@ -312,7 +330,7 @@ public:
 private:
 	static void InsertIntoSortedInv(std::shared_ptr<Item>itemRef);
 	static void InsertIntoStageInventoryCategory(std::shared_ptr<Item>itemRef,const bool monsterDrop);
-	static bool ExecuteAction(IT item);
+	static bool ExecuteAction(IT item,const std::optional<vf2d>targetingPos);
 	static std::multimap<IT,std::shared_ptr<Item>>_inventory;
 	static std::vector<std::shared_ptr<Item>>blacksmithInventory;
 	static std::map<EquipSlot,std::weak_ptr<Item>>equipment;
@@ -327,9 +345,9 @@ class ItemProps{
 	utils::datafile*customProps; 
 public:
 	ItemProps(utils::datafile*scriptProps,utils::datafile*customProps);
-	int GetIntProp(const std::string&prop,size_t index=0)const;
-	float GetFloatProp(const std::string&prop,size_t index=0)const;
-	std::string GetStringProp(const std::string&prop,size_t index=0)const;
+	int GetInt(const std::string&prop,size_t index=0)const;
+	float GetFloat(const std::string&prop,size_t index=0)const;
+	std::string GetString(const std::string&prop,size_t index=0)const;
 	const uint32_t PropCount(const std::string&prop)const;
 };
 
@@ -340,10 +358,12 @@ class ItemInfo{
 	std::string description;
 	std::string category;
 	float castTime=0;
+	float castRange=0;
+	float castSize=0;
 	float cooldownTime=0;
 	EquipSlot slot=EquipSlot::NONE;
 	EnhancementInfo enhancement;
-	::Decal*img;
+	std::optional<std::reference_wrapper<Renderable>>img;
 	EventName useSound="";
 	std::string set="";
 	//Returns true if the item can be used, false otherwise
@@ -360,6 +380,7 @@ class ItemInfo{
 	Stats minStats;
 	Stats maxStats;
 	std::optional<std::string>fragmentName;
+	std::optional<std::string>fragmentIcon;
 private:
 	static void InitializeScripts();
 	static void InitializeSets();
@@ -372,7 +393,7 @@ public:
 	const std::string&Name()const;
 	const std::string&Description()const;
 	const ITCategory Category()const;
-	const::Decal*const Decal()const;
+	const::Renderable& Icon()const;
 	static const EquipSlot StringToEquipSlot(std::string_view slotName);
 	/*
 	For the useFunc, return true if the item can be used, false otherwise.
@@ -381,6 +402,8 @@ public:
 	const ItemScript&OnUseAction()const;
 	const Stats GetStats(int enhancementLevel)const;
 	const float CastTime()const;
+	const float CastRange()const;
+	const float CastSize()const;
 	const float CooldownTime()const;
 	const EquipSlot Slot()const;
 	const std::optional<const::ItemSet*const>ItemSet()const;
@@ -402,6 +425,7 @@ public:
 	const std::unordered_set<std::string>&GetClass()const;
 	Stats RandomizeStats();
 	const std::string&FragmentName()const;
+	const std::optional<std::string>&FragmentIcon()const;
 };
 
 class ItemOverlay{

Adventures in Lestoria/ItemDrop.cpp

@@ -47,12 +47,13 @@ float ItemDrop::gravity;
 std::vector<ItemDrop>ItemDrop::drops;
 
 void ItemDrop::Initialize(){
+	drops.clear();
 	gravity="ItemDrop.Item Drop Gravity"_F;
 }
 
 ItemDrop::ItemDrop(const ItemInfo*item,const vf2d pos,const bool isUpper)
 :item(item),pos(pos),upperLevel(isUpper){
-	const bool HasBossArenaBounds=game->GetCurrentMap().GetMapType()=="Boss";
+	const bool HasBossArenaBounds=game->GetCurrentMap().GetMapType()==Map::MapType::BOSS;
 	if(HasBossArenaBounds){
 		const geom2d::rect<int>arenaBounds=game->GetZones().at("BossArena")[0].zone;
 		this->pos.x=std::clamp(this->pos.x,float(arenaBounds.pos.x),float(arenaBounds.pos.x+arenaBounds.size.x));
@@ -68,7 +69,7 @@ vf2d ItemDrop::GetPos()const{
 	return pos;
 }
 
-bool ItemDrop::OnUpperLevel(){
+bool ItemDrop::OnUpperLevel()const{
 	return upperLevel;
 }
 
@@ -85,9 +86,9 @@ void ItemDrop::Draw()const{
 		yOffset=sin((game->levelTime+randomSpinOffset)*3)*0.5f;
 	}
 	game->view.DrawRotatedDecal(pos-vf2d{0,GetZ()+yOffset},GFX["skill_overlay_icon_overlay.png"].Decal(),0,GFX["skill_overlay_icon_overlay.png"].Decal()->sprite->Size()/2,{"ItemDrop.Item Drop Scale"_F,"ItemDrop.Item Drop Scale"_F},YELLOW);
-	game->view.DrawRotatedDecal(pos-vf2d{0,GetZ()+yOffset},const_cast<Decal*>(item->Decal()),0,item->Decal()->sprite->Size()/2,{"ItemDrop.Item Drop Scale"_F,"ItemDrop.Item Drop Scale"_F},{255,255,255,128});
+	game->view.DrawRotatedDecal(pos-vf2d{0,GetZ()+yOffset},const_cast<Decal*>(item->Icon().Decal()),0,item->Icon().Sprite()->Size()/2,{"ItemDrop.Item Drop Scale"_F,"ItemDrop.Item Drop Scale"_F},{255,255,255,128});
 	game->SetDecalMode(DecalMode::ADDITIVE);
-	game->view.DrawRotatedDecal(pos-vf2d{0,GetZ()+yOffset},const_cast<Decal*>(item->Decal()),0,item->Decal()->sprite->Size()/2,{"ItemDrop.Item Drop Scale"_F,"ItemDrop.Item Drop Scale"_F},{uint8_t(abs(sin(game->levelTime*1.5)*255.f)),uint8_t(abs(sin(game->levelTime*1.5)*255.f)),uint8_t(abs(sin(game->levelTime*1.5)*255.f)),128});
+	game->view.DrawRotatedDecal(pos-vf2d{0,GetZ()+yOffset},const_cast<Decal*>(item->Icon().Decal()),0,item->Icon().Sprite()->Size()/2,{"ItemDrop.Item Drop Scale"_F,"ItemDrop.Item Drop Scale"_F},{uint8_t(abs(sin(game->levelTime*1.5)*255.f)),uint8_t(abs(sin(game->levelTime*1.5)*255.f)),uint8_t(abs(sin(game->levelTime*1.5)*255.f)),128});
 	game->SetDecalMode(DecalMode::NORMAL);
 }
 
@@ -98,8 +99,7 @@ void ItemDrop::UpdateDrops(float fElapsedTime){
 			if(drop.z<=0){
 				drop.zSpeed=0;
 				drop.z=0;
-			}
-			else{
+			}else{
 				drop.zSpeed+=gravity*fElapsedTime;
 				drop.pos+=drop.speed*fElapsedTime;
 			}
@@ -109,7 +109,7 @@ void ItemDrop::UpdateDrops(float fElapsedTime){
 			if(drop.zSpeed==0&&drop.OnUpperLevel()==game->GetPlayer()->OnUpperLevel()){
 				geom2d::line<float>lineTo=geom2d::line<float>(drop.pos,game->GetPlayer()->GetPos());
 				float dist=lineTo.length();
-				if(dist<="ItemDrop.Item Drop Suction Range"_F){
+				if(dist<="ItemDrop.Item Drop Suction Range"_F&&dist>0){
 					vf2d pointVel=lineTo.vector().norm();
 					float moveDistance=(1.f/std::min(48.f,dist))*"ItemDrop.Item Drop Suction Strength"_F*fElapsedTime;
 					if(moveDistance>dist){

Adventures in Lestoria/ItemDrop.h

@@ -59,7 +59,7 @@ class ItemDrop{
 public:
 	static void Initialize();
 	vf2d GetPos()const;
-	bool OnUpperLevel();
+	bool OnUpperLevel()const;
 	void Draw()const;
 	static void UpdateDrops(float fElapsedTime);
 	static const std::vector<ItemDrop>&GetDrops();

Adventures in Lestoria/ItemEnchant.cpp

@@ -52,6 +52,7 @@ INCLUDE_DATA
 const Pixel ItemEnchantInfo::enchantAttributeCol{0x00DFE2};
 std::unordered_map<std::string,ItemEnchantInfo>ItemEnchantInfo::ENCHANT_LIST;
 std::unordered_map<ItemEnchantInfo::ItemEnchantCategory,ItemEnchantInfo::ItemEnchantCategoryData>ItemEnchantInfo::ENCHANT_CATEGORIES;
+std::unordered_map<ItemEnchantInfo::ItemEnchantCategory,Pixel>ItemEnchantInfo::enchantTextDisplayCol;
 
 const ItemEnchantInfo&operator ""_ENC(const char*key,std::size_t len){
 	return ItemEnchantInfo::GetEnchant(std::string(key));
@@ -79,6 +80,8 @@ void ItemEnchantInfo::Initialize(){
 			enchantCategory=ItemEnchantCategory::UNIQUE;
 		}else ERR(std::format("WARNING! Enchant type {} is not supported! THIS SHOULD NOT BE HAPPENING! Please check ItemEnchants.txt",key));
 
+		enchantTextDisplayCol[enchantCategory]=DATA["Item Enchants"][key]["Enchant Display Color"].GetPixel();
+
 		datafile&enchantData=DATA["Item Enchants"][key];
 
 		ItemEnchantCategoryData categoryData;
@@ -226,7 +229,7 @@ const std::unordered_map<std::string,ItemEnchantInfo>&ItemEnchantInfo::GetEnchan
 	return ENCHANT_LIST;
 }
 
-const std::string ItemEnchant::RollRandomEnchant(){
+const std::vector<ItemEnchantInfo>ItemEnchant::GetAvailableEnchants(){
 	std::vector<ItemEnchantInfo>filteredEnchants;
 
 	std::for_each(ItemEnchantInfo::GetEnchants().begin(),ItemEnchantInfo::GetEnchants().end(),[&filteredEnchants](const std::pair<std::string,ItemEnchantInfo>&data){
@@ -240,7 +243,41 @@ const std::string ItemEnchant::RollRandomEnchant(){
 		}
 	});
 
-	return filteredEnchants[util::random()%filteredEnchants.size()].Name();
+	return filteredEnchants;
+}
+
+const ItemEnchant ItemEnchant::RollRandomEnchant(const std::optional<ItemEnchant>previousEnchant){
+	const std::vector<ItemEnchantInfo>filteredEnchants{GetAvailableEnchants()};
+	
+	int randomRoll{int(util::random_range(0,100))};
+	const std::pair<int,int>generalEnchantRange{0,"Item Enchants.General Enchants.Percent Chance"_I};
+	const std::pair<int,int>classEnchantRange{generalEnchantRange.second,generalEnchantRange.second+"Item Enchants.Class Enchants.Percent Chance"_I};
+	const std::pair<int,int>uniqueEnchantRange{classEnchantRange.second,classEnchantRange.second+"Item Enchants.Unique Enchants.Percent Chance"_I};
+	std::vector<ItemEnchantInfo>remainingAvailableEnchants;
+
+	if(randomRoll>=generalEnchantRange.first&&randomRoll<generalEnchantRange.second){
+		std::copy_if(filteredEnchants.begin(),filteredEnchants.end(),std::back_inserter(remainingAvailableEnchants),[](const ItemEnchantInfo&enchant){return enchant.Category()==ItemEnchantInfo::ItemEnchantCategory::GENERAL;});
+	}else if(randomRoll>=classEnchantRange.first&&randomRoll<classEnchantRange.second){
+		std::copy_if(filteredEnchants.begin(),filteredEnchants.end(),std::back_inserter(remainingAvailableEnchants),[](const ItemEnchantInfo&enchant){return enchant.Category()==ItemEnchantInfo::ItemEnchantCategory::CLASS;});
+	}else if(randomRoll>=uniqueEnchantRange.first&&randomRoll<uniqueEnchantRange.second){
+		std::copy_if(filteredEnchants.begin(),filteredEnchants.end(),std::back_inserter(remainingAvailableEnchants),[](const ItemEnchantInfo&enchant){return enchant.Category()==ItemEnchantInfo::ItemEnchantCategory::UNIQUE;});
+	}else ERR(std::format("WARNING! Somehow did not pick a value in any of the given ranges. Rolled value was: {}. Ranges were {}-{}, {}-{}, {}-{}",randomRoll,generalEnchantRange.first,generalEnchantRange.second,classEnchantRange.first,classEnchantRange.second,uniqueEnchantRange.first,uniqueEnchantRange.second));
+
+	const auto AtLeastOneAttributeIncreased=[](const ItemEnchant&oldEnchant,const ItemEnchant&newEnchant){
+		if(oldEnchant.Name()!=newEnchant.Name())ERR(std::format("WARNING! Not intended to be used with enchants of varying names!! Old:{}  New:{}",oldEnchant.Name(),newEnchant.Name()));
+		for(const auto&[attr,val]:oldEnchant){
+			if(newEnchant.GetAttribute(attr.ActualName())>val)return true;
+		}
+		return false;
+	};
+
+	for(;;){
+		ItemEnchantInfo&randomEnchant{remainingAvailableEnchants[util::random()%remainingAvailableEnchants.size()]};
+		ItemEnchant newEnchant{randomEnchant.Name()};
+		if(!previousEnchant||
+			previousEnchant.value().Name()!=newEnchant.Name()||
+			AtLeastOneAttributeIncreased(previousEnchant.value(),newEnchant))return newEnchant;
+	}
 }
 
 void ItemEnchant::UpdateDescription(){
@@ -270,7 +307,7 @@ std::map<ItemAttribute,float>::const_iterator ItemEnchant::end()const{
 }
 
 const Pixel&ItemEnchant::DisplayCol()const{
-	return ItemEnchantInfo::GetEnchant(Name()).enchantAttributeCol;
+	return ItemEnchantInfo::enchantTextDisplayCol.at(Category());
 }
 
 const std::optional<ItemEnchantInfo::AbilitySlot>&ItemEnchantInfo::GetAbilitySlot()const{
@@ -302,3 +339,15 @@ const std::optional<std::reference_wrapper<Ability>>ItemEnchant::Ability()const{
 	if(GetEnchantInfo().GetAbility())return **GetEnchantInfo().GetAbility();
 	return {};
 }
+
+const Pixel&ItemEnchantInfo::DisplayCol()const{
+	return ItemEnchantInfo::enchantTextDisplayCol.at(Category());
+}
+
+const bool ItemEnchant::HasAttributes()const{
+	return stats.size()>0;
+}
+
+const std::optional<Class>&ItemEnchant::GetClass()const{
+	return ItemEnchantInfo::GetEnchant(Name()).GetClass();
+}

Adventures in Lestoria/ItemEnchant.h

@@ -69,6 +69,7 @@ public:
 	static void Initialize();
 	const static ItemEnchantInfo&GetEnchant(const std::string_view enchantName);
 	const static std::unordered_map<std::string,ItemEnchantInfo>&GetEnchants();
+	static std::unordered_map<ItemEnchantCategory,Pixel>enchantTextDisplayCol;
 
 	const std::string Name(TextStyle style=TextStyle::NORMAL)const;
 	const std::string_view Description()const;
@@ -76,8 +77,9 @@ public:
 	const std::optional<Class>&GetClass()const;
 	const std::optional<AbilitySlot>&GetAbilitySlot()const;
 	const std::optional<Ability*>GetAbility()const; //Get the ability this enchant is tied to.
+	const Pixel&DisplayCol()const;
 	const float GetConfigValue(const std::string_view keyName)const;	
-	const float operator[](const std::string& name)const;
+	const float operator[](const std::string&name)const;
 private:
 	class ItemEnchantCategoryData{
 		friend class ItemEnchantInfo;
@@ -98,6 +100,8 @@ private:
 	static std::unordered_map<ItemEnchantCategory,ItemEnchantCategoryData>ENCHANT_CATEGORIES;
 };
 
+class Item;
+
 class ItemEnchant{
 public:
 	ItemEnchant(const std::string_view enchantName);
@@ -105,14 +109,17 @@ public:
 	const std::string_view Description()const;
 	const ItemEnchantInfo::ItemEnchantCategory&Category()const;
 	const std::optional<ItemEnchantInfo::AbilitySlot>&AbilitySlot()const;
+	const static std::vector<ItemEnchantInfo>GetAvailableEnchants();
 	//Rolls a class-appropriate random enchant.
-	const static std::string RollRandomEnchant();
+	const static ItemEnchant RollRandomEnchant(const std::optional<ItemEnchant>previousEnchant={});
 	void SetAttribute(const std::string_view attr,const float val);
 	const float&GetAttribute(const std::string_view attr)const;
 	std::map<ItemAttribute,float>::const_iterator begin()const;
 	std::map<ItemAttribute,float>::const_iterator end()const;
+	const bool HasAttributes()const;
 	const Pixel&DisplayCol()const;
-	const std::optional<std::reference_wrapper<Ability>>Ability()const;
+	const std::optional<std::reference_wrapper<::Ability>>Ability()const;
+	const std::optional<Class>&GetClass()const;
 private:
 	void UpdateDescription();
 	const ItemEnchantInfo&GetEnchantInfo()const;

Adventures in Lestoria/ItemHubLoadout.cpp

@@ -0,0 +1,148 @@
+#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 "AdventuresInLestoria.h"
+#include "DEFINES.h"
+#include "Menu.h"
+#include "MenuLabel.h"
+#include "MenuItemLoadoutButton.h"
+#include "State_OverworldMap.h"
+
+INCLUDE_game
+using A=Attribute;
+
+void Menu::InitializeItemHubLoadoutWindow(){
+	Menu*itemHubLoadoutWindow=CreateMenu(ITEM_HUB_LOADOUT,CENTERED,game->GetScreenSize()-vi2d{4,4});
+
+	float itemLoadoutWindowWidth=(game->GetScreenSize().x-5.f);
+
+	itemHubLoadoutWindow->ADD("Loadout Label",MenuLabel)(geom2d::rect<float>{{0,24},{itemLoadoutWindowWidth,24}},"Setup Item Loadout",2,ComponentAttr::SHADOW|ComponentAttr::BACKGROUND|ComponentAttr::OUTLINE)END;
+	
+	itemHubLoadoutWindow->ADD("Loadout Description Label",MenuLabel)(geom2d::rect<float>{{0,58},{itemLoadoutWindowWidth,24}},"Bring up to 3 items with you.",1,ComponentAttr::SHADOW)END;
+
+	float buttonBorderPadding=64;
+
+	itemHubLoadoutWindow->ADD("Loadout Item 1",MenuItemLoadoutButton)(geom2d::rect<float>{{64,90},{48,48}},0,[](MenuFuncData data){
+		Menu::menus.at(INVENTORY_CONSUMABLES)->I(A::LOADOUT_SLOT)=0; 
+		Menu::OpenMenu(INVENTORY_CONSUMABLES);
+		return true;
+	},[](MenuFuncData data){
+		std::weak_ptr<MenuItemLoadoutButton>loadoutButton=DYNAMIC_POINTER_CAST<MenuItemLoadoutButton>(data.component);
+		if(!ISBLANK(loadoutButton.lock()->GetItem())){
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel(loadoutButton.lock()->GetItem().lock()->DisplayName());
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel(loadoutButton.lock()->GetItem().lock()->Description());
+		}
+		return true;
+	},[](MenuFuncData data){
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel("");
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel("");
+		return true;
+	})END
+		->SetIconScale({2.f,2.f});
+	itemHubLoadoutWindow->ADD("Loadout Item 2",MenuItemLoadoutButton)(geom2d::rect<float>{{itemLoadoutWindowWidth/2-24,90},{48,48}},1,[](MenuFuncData data){
+		Menu::menus.at(INVENTORY_CONSUMABLES)->I(A::LOADOUT_SLOT)=1;
+		Menu::OpenMenu(INVENTORY_CONSUMABLES);
+		return true;
+	},[](MenuFuncData data){
+		std::weak_ptr<MenuItemLoadoutButton>loadoutButton=DYNAMIC_POINTER_CAST<MenuItemLoadoutButton>(data.component);
+		if(!ISBLANK(loadoutButton.lock()->GetItem())){
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel(loadoutButton.lock()->GetItem().lock()->DisplayName());
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel(loadoutButton.lock()->GetItem().lock()->Description());
+		}
+		return true;
+	},[](MenuFuncData data){
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel("");
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel("");
+		return true;
+	})END
+		->SetIconScale({2.f,2.f});
+	itemHubLoadoutWindow->ADD("Loadout Item 3",MenuItemLoadoutButton)(geom2d::rect<float>{{itemLoadoutWindowWidth-48-64,90},{48,48}},2,[](MenuFuncData data){
+		Menu::menus.at(INVENTORY_CONSUMABLES)->I(A::LOADOUT_SLOT)=2;
+		Menu::OpenMenu(INVENTORY_CONSUMABLES);
+		return true;
+	},[](MenuFuncData data){
+		std::weak_ptr<MenuItemLoadoutButton>loadoutButton=DYNAMIC_POINTER_CAST<MenuItemLoadoutButton>(data.component);
+		if(!ISBLANK(loadoutButton.lock()->GetItem())){
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel(loadoutButton.lock()->GetItem().lock()->DisplayName());
+			Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel(loadoutButton.lock()->GetItem().lock()->Description());
+		}
+		return true;
+	},[](MenuFuncData data){
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Name Label")->SetLabel("");
+		Component<MenuLabel>(ITEM_HUB_LOADOUT,"Item Description")->SetLabel("");
+		return true;
+	})END
+		->SetIconScale({2.f,2.f});
+
+	itemHubLoadoutWindow->ADD("Item Name Label",MenuLabel)(geom2d::rect<float>{{0,146},{itemLoadoutWindowWidth,12}},"",1,ComponentAttr::SHADOW)END;
+	itemHubLoadoutWindow->ADD("Item Description",MenuLabel)(geom2d::rect<float>{{0,158},{itemLoadoutWindowWidth,24}},"",1,ComponentAttr::SHADOW)END;
+
+	itemHubLoadoutWindow->ADD("Back Button",MenuComponent)(geom2d::rect<float>{{itemLoadoutWindowWidth/2-32,202},{64,16}},"Back",[](MenuFuncData data){Menu::CloseMenu();return true;})END;
+
+	itemHubLoadoutWindow->SetupKeyboardNavigation(
+	[](MenuType type,Data&returnData){ //On Open
+		returnData="Loadout Item 1";
+	},
+	{ //Button Key
+		{game->KEY_BACK,{"Back",[](MenuType type){
+			Component<MenuComponent>(type,"Back Button")->Click();
+		}}},
+		{game->KEY_CONFIRM,{"Select",[](MenuType type){}}},
+	}
+	,{ //Button Navigation Rules
+		{"Loadout Item 1",{
+			.up="Back Button",
+			.down="Back Button",
+			.left="Loadout Item 3",
+			.right="Loadout Item 2",}},
+		{"Loadout Item 2",{
+			.up="Back Button",
+			.down="Back Button",
+			.left="Loadout Item 1",
+			.right="Loadout Item 3",}},
+		{"Loadout Item 3",{
+			.up="Back Button",
+			.down="Back Button",
+			.left="Loadout Item 2",
+			.right="Loadout Item 1",}},
+		{"Back Button",{
+			.up="Loadout Item 1",
+			.down="Loadout Item 1",
+			.left="Back Button",
+			.right="Back Button",}},
+	});
+}

Adventures in Lestoria/ItemScript.cpp

@@ -0,0 +1,102 @@
+#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 "AdventuresInLestoria.h"
+#include "BulletTypes.h"
+
+INCLUDE_ITEM_SCRIPTS
+INCLUDE_game
+INCLUDE_ANIMATION_DATA
+
+void ItemInfo::InitializeScripts(){
+
+	ITEM_SCRIPTS["Restore"]=[](AiL*game,std::optional<vf2d>targetingPos,ItemProps props){
+		for(const auto&[propName,buffType]:NameToBuffType){
+			int restoreAmt=props.GetInt(propName);
+			
+			game->GetPlayer()->AddBuff(BuffRestorationType::ONE_OFF,NameToBuffType.at(propName),0.01f,float(restoreAmt),0.0f);
+			if(restoreAmt>0&&props.PropCount(propName)==3){
+				game->GetPlayer()->AddBuff(BuffRestorationType::OVER_TIME,NameToBuffType.at(propName),props.GetFloat(propName,2),float(restoreAmt),props.GetFloat(propName,1));
+			}
+		}
+		return true;
+	};
+	
+	for(auto&[key,value]:ItemAttribute::attributes){
+		if(!DATA.GetProperty("ItemScript.Buff").HasProperty(key)){
+			ERR("WARNING! Buff Item Script does not support Buff "<<std::quoted(value.Name())<<"!");
+		}
+	}
+
+	ITEM_SCRIPTS["Buff"]=[](AiL*game,std::optional<vf2d>targetingPos,ItemProps props){
+		for(auto&[key,value]:ItemAttribute::attributes){
+			float intensity=props.GetFloat(key,0);
+			if(intensity==0.f)continue;
+			if(ItemAttribute::Get(key).DisplayAsPercent())intensity/=100;
+			game->GetPlayer()->AddBuff(BuffType::STAT_UP,props.GetFloat(key,1),intensity,{ItemAttribute::Get(key)});
+		}
+		return true;
+	};
+	ITEM_SCRIPTS["RestoreDuringCast"]=[](AiL*game,std::optional<vf2d>targetingPos,ItemProps props){
+		for(const auto&[propName,buffType]:NameToBuffType){
+			int restoreAmt=props.GetInt(propName);
+
+			game->GetPlayer()->AddBuff(BuffRestorationType::ONE_OFF,NameToBuffType.at(propName),0.01f,float(restoreAmt),0.0f);
+			if(restoreAmt>0&&props.PropCount(propName)==3){
+				game->GetPlayer()->AddBuff(BuffRestorationType::OVER_TIME_DURING_CAST,NameToBuffType.at(propName),props.GetFloat(propName,2),float(restoreAmt),props.GetFloat(propName,1));
+			}
+		}
+		return true;
+	};
+	ITEM_SCRIPTS["Projectile"]=[](AiL*game,std::optional<vf2d>targetingPos,ItemProps props){
+		const int projectileDamage{props.GetInt("Base Damage")+int(game->GetPlayer()->GetAttack()*props.GetFloat("Player Damage Mult"))};
+		std::optional<LingeringEffect>lingeringEffect{};
+		if(props.GetFloat("Linger Time")>0.f){
+			const int damage{props.GetInt("Tick Base Damage")+int(props.GetFloat("Tick Player Damage Mult")*game->GetPlayer()->GetAttack())};
+			lingeringEffect.emplace(vf2d{},props.GetString("Lingering Effect"),props.GetString("Lingering Sound"),props.GetFloat("Linger Radius")/100.f*24,damage,props.GetFloat("Tick Rate"),HurtType::MONSTER,props.GetFloat("Linger Time"),5.f,game->GetPlayer()->OnUpperLevel(),1.f,vf2d{},DARK_RED,util::random(2*PI),0.f,false,0.2f,
+				[](const Effect&self){
+					return Effect{self.pos,0.5f,"fire_ring.png",self.OnUpperLevel(),util::random_range(0.7f,1.f),0.1f,{},PixelLerp(Pixel(0xF7B752),Pixel(0xE74F30),util::random(1.f)),util::random(2*PI),0.f,true};
+				});
+		}
+		CreateBullet(ThrownProjectile)(game->GetPlayer()->GetPos(),targetingPos.value(),props.GetString("Image"),props.GetFloat("Cast Size")/100.f*24,game->GetPlayer()->GetZ(),0.3f,8.f,projectileDamage,game->GetPlayer()->OnUpperLevel(),false,INFINITE,true,WHITE,props.GetFloat("Cast Size")/100.f*vf2d{1.f,1.f},0.f,
+			Effect{vf2d{},ANIMATION_DATA.at("explosionframes.png").GetTotalAnimationDuration(),"explosionframes.png",game->GetPlayer()->OnUpperLevel(),props.GetFloat("Cast Size")/100.f*vf2d{1.f,1.f}},props.GetString("Explode Sound Effect"),lingeringEffect)EndBullet;
+		return true;
+	};
+
+	ITEM_SCRIPTS.SetInitialized();
+	LOG(ITEM_SCRIPTS.size()<<" item scripts have been loaded.");
+}

Adventures in Lestoria/LightningBolt.cpp

@@ -48,8 +48,7 @@ INCLUDE_MONSTER_LIST
 INCLUDE_EMITTER_LIST
 
 LightningBolt::LightningBolt(vf2d pos,vf2d vel,float radius,int damage,bool upperLevel,bool friendly,Pixel col)
-	:Bullet(pos,vel,radius,damage,
-		"lightning_bolt.png",upperLevel,false,INFINITE,true,friendly,col){}
+	:Bullet(pos,vel,radius,damage,"lightning_bolt.png",upperLevel,false,INFINITE,true,friendly,col){}
 
 void LightningBolt::Update(float fElapsedTime){
 	lastParticleSpawn=std::max(0.f,lastParticleSpawn-fElapsedTime);
@@ -72,13 +71,12 @@ void LightningBolt::Update(float fElapsedTime){
 			}break;
 		}
 	}
-	if(distanceTraveled>"Wizard.Ability 2.Range"_F&&IsActivated()){
+	if(distanceTraveled>"Wizard.Ability 2.Max Range"_F&&IsActivated()){
 		fadeOutTime="Wizard.Ability 2.BulletFadeoutTime"_F;
 	}
 }
 
-BulletDestroyState LightningBolt::PlayerHit(Player*player)
-{
+BulletDestroyState LightningBolt::PlayerHit(Player*player){
 	fadeOutTime="Wizard.Ability 2.BulletFadeoutTime"_F;
 	game->AddEffect(std::make_unique<Effect>(player->GetPos(),"Wizard.Ability 2.SplashLifetime"_F,"lightning_splash_effect.png",upperLevel,player->GetSizeMult(),"Wizard.Ability 2.SplashFadeoutTime"_F,vf2d{},WHITE,"Wizard.Ability 2.SplashRotationRange"_FRange));
 
@@ -86,29 +84,43 @@ BulletDestroyState LightningBolt::PlayerHit(Player*player)
 	return BulletDestroyState::KEEP_ALIVE;
 }
 
-BulletDestroyState LightningBolt::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit)
-{
+BulletDestroyState LightningBolt::MonsterHit(Monster&monster,const uint8_t markStacksBeforeHit){
 	fadeOutTime="Wizard.Ability 2.BulletFadeoutTime"_F;
 	game->AddEffect(std::make_unique<Effect>(monster.GetPos(),"Wizard.Ability 2.SplashLifetime"_F,"lightning_splash_effect.png",upperLevel,monster.GetSizeMult(),"Wizard.Ability 2.SplashFadeoutTime"_F,vf2d{},WHITE,"Wizard.Ability 2.SplashRotationRange"_FRange));
+		
+	LightningBolt::ApplyLightningShock(monster,monster.OnUpperLevel());
+
+	SoundEffect::PlaySFX("Wizard Lightning Bolt Hit",pos);
+	return BulletDestroyState::KEEP_ALIVE;
+}
+
+void LightningBolt::ModifyOutgoingDamageData(HurtDamageInfo&data){
+	if(friendly)data.hurtFlags|=HurtFlag::PLAYER_ABILITY;
+}
+
+void LightningBolt::ApplyLightningShock(const Monster&monster,const bool onUpperLevel,const ChainLightningStatus chainLightningRepeatCount/*Set to higher amount to indicate when this monster instead affects monsters due to the enchantment, which changes which shock count variable we look at and will be used for counting down shock times.*/){
 	int targetsHit=0;
 	for(std::shared_ptr<Monster>&m:MONSTER_LIST){
-		if(&*m==&monster||monster.OnUpperLevel()!=m->OnUpperLevel())continue;
+		if(&*m==&monster||m->InUndamageableState(m->OnUpperLevel(),m->GetZ()))continue;
 		geom2d::line<float>lineToTarget=geom2d::line<float>(monster.GetPos(),m->GetPos());
 		float dist=lineToTarget.length();
 		if(dist<="Wizard.Ability 2.LightningChainRadius"_F/100*24){
-			if(m->Hurt(int(game->GetPlayer()->GetAttack()*"Wizard.Ability 2.LightningChainDamageMult"_F),OnUpperLevel(),0,HurtFlag::PLAYER_ABILITY)){
-				EMITTER_LIST.push_back(std::make_unique<LightningBoltEmitter>(LightningBoltEmitter(monster.GetPos(),m->GetPos(),"Wizard.Ability 2.LightningChainFrequency"_F,"Wizard.Ability 2.LightningChainLifetime"_F,upperLevel)));
-				game->AddEffect(std::make_unique<Effect>(m->GetPos(),"Wizard.Ability 2.LightningChainSplashLifetime"_F,"lightning_splash_effect.png",upperLevel,monster.GetSizeMult(),"Wizard.Ability 2.LightningChainSplashFadeoutTime"_F,vf2d{},WHITE,"Wizard.Ability 2.LightningChainSplashRotationRange"_FRange));
+			int lightningChainDamage{int(game->GetPlayer()->GetAttack()*"Wizard.Ability 2.LightningChainDamageMult"_F)};
+			if(chainLightningRepeatCount>0)lightningChainDamage=int(game->GetPlayer()->GetAttack()*"Chain Lightning"_ENC["SHOCK DAMAGE"]/100.f);
+			if(m->Hurt(lightningChainDamage,onUpperLevel,0,HurtFlag::PLAYER_ABILITY)){
+				EMITTER_LIST.emplace_back(std::make_unique<LightningBoltEmitter>(LightningBoltEmitter(monster.GetPos(),m->GetPos(),"Wizard.Ability 2.LightningChainFrequency"_F,"Wizard.Ability 2.LightningChainLifetime"_F,onUpperLevel)));
+				game->AddEffect(std::make_unique<Effect>(m->GetPos(),"Wizard.Ability 2.LightningChainSplashLifetime"_F,"lightning_splash_effect.png",onUpperLevel,monster.GetSizeMult(),"Wizard.Ability 2.LightningChainSplashFadeoutTime"_F,vf2d{},WHITE,"Wizard.Ability 2.LightningChainSplashRotationRange"_FRange));
+				int chainLightningRepeat{};
+				if(chainLightningRepeatCount>0)chainLightningRepeat=chainLightningRepeatCount-1;
+				else if(game->GetPlayer()->HasEnchant("Chain Lightning")&&chainLightningRepeatCount==ORIGINAL_BOLT)chainLightningRepeat=int("Chain Lightning"_ENC["REPEAT COUNT"]);
+				if(chainLightningRepeat>0&&game->GetPlayer()->HasEnchant("Chain Lightning"))m->AddBuff(BuffType::AFFECTED_BY_LIGHTNING_BOLT,"Chain Lightning"_ENC["ADDITIONAL SHOCK DELAY"],chainLightningRepeat,[](std::weak_ptr<Monster>attachedTarget,Buff&b){
+					LightningBolt::ApplyLightningShock(*attachedTarget.lock(),attachedTarget.lock()->OnUpperLevel(),ChainLightningStatus(b.intensity));
+				});
 				targetsHit++;
 			}
 		}
-		if(targetsHit>=2)break;
+		int targetHitLimit{"Wizard.Ability 2.LightningChainTargets"_I};
+		if(chainLightningRepeatCount>0)targetHitLimit="Chain Lightning"_ENC["ADDITIONAL SHOCK COUNT"];
+		if(targetsHit>=targetHitLimit)break;
 	}
-
-	SoundEffect::PlaySFX("Wizard Lightning Bolt Hit",pos);
-	return BulletDestroyState::KEEP_ALIVE;
-}
-
-void LightningBolt::ModifyOutgoingDamageData(HurtDamageInfo&data){
-	if(friendly)data.hurtFlags|=HurtFlag::PLAYER_ABILITY;
 }

Adventures in Lestoria/Menu.cpp

@@ -120,11 +120,12 @@ void Menu::InitializeMenus(){
 	InitializeCreditsWindow();
 	InitializeArtificerWindow();
 	InitializeArtificerRefineWindow();
-	InitializeArtificerRefineConfirmWindow();
+	InitializeArtificerRefineResultWindow();
 	InitializeArtificerDisassembleWindow();
-	InitializeArtificerDisassembleConfirmWindow();
 	InitializeArtificerEnchantWindow();
 	InitializeArtificerEnchantConfirmWindow();
+	InitializeHubPauseWindow();
+	InitializeItemHubLoadoutWindow();
 
 	for(MenuType type=MenuType(int(MenuType::ENUM_START)+1);type<MenuType::ENUM_END;type=MenuType(int(type+1))){
 		if(menus.count(type)==0){
@@ -410,8 +411,8 @@ void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
 			}
 			if(navigationGroups.count(selectionButtonName)){
 				Navigation nav=navigationGroups[selectionButtonName];
-
-				if(game->KEY_UP.PressedDAS()||game->KEY_SCROLLUP.AnalogDAS(0.5f)<-0.5f){
+				const float scrollVertAnalogDAS{game->KEY_SCROLLVERT_L.AnalogDAS(0.5f)};
+				if(game->KEY_UP.PressedDAS()||scrollVertAnalogDAS<-0.5f){
 					SoundEffect::PlaySFX("Menu Navigate",SoundEffect::CENTERED);
 					SetMouseNavigation(false);
 					if(std::holds_alternative<std::string>(nav.up)&&std::get<std::string>(nav.up).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.up)));
@@ -419,10 +420,11 @@ void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
 					if(std::holds_alternative<MenuDataFunc>(nav.up)){
 						Data returnData;
 						std::get<MenuDataFunc>(nav.up)(type,returnData);
+						if(!std::holds_alternative<ButtonName>(returnData)&&!std::holds_alternative<std::weak_ptr<MenuComponent>>(returnData))ERR(std::format("WARNING! No valid return type set for up button navigation in menu {}",int(type)));
 						SetSelection(returnData);
 					}
 				}
-				if(game->KEY_DOWN.PressedDAS()||game->KEY_SCROLLDOWN.AnalogDAS(0.5f)>0.5f){
+				if(game->KEY_DOWN.PressedDAS()||scrollVertAnalogDAS>0.5f){
 					SoundEffect::PlaySFX("Menu Navigate",SoundEffect::CENTERED);
 					SetMouseNavigation(false);
 					if(std::holds_alternative<std::string>(nav.down)&&std::get<std::string>(nav.down).length()>0)SetSelection(std::string_view(std::get<std::string>(nav.down)));
@@ -430,6 +432,7 @@ void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
 					if(std::holds_alternative<MenuDataFunc>(nav.down)){
 						Data returnData;
 						std::get<MenuDataFunc>(nav.down)(type,returnData);
+						if(!std::holds_alternative<ButtonName>(returnData)&&!std::holds_alternative<std::weak_ptr<MenuComponent>>(returnData))ERR(std::format("WARNING! No valid return type set for down button navigation in menu {}",int(type)));
 						SetSelection(returnData);
 					}
 				}
@@ -441,6 +444,7 @@ void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
 					if(std::holds_alternative<MenuDataFunc>(nav.left)){
 						Data returnData;
 						std::get<MenuDataFunc>(nav.left)(type,returnData);
+						if(!std::holds_alternative<ButtonName>(returnData)&&!std::holds_alternative<std::weak_ptr<MenuComponent>>(returnData))ERR(std::format("WARNING! No valid return type set for left button navigation in menu {}",int(type)));
 						SetSelection(returnData);
 					}
 				}
@@ -452,6 +456,7 @@ void Menu::KeyboardButtonNavigation(AiL*game,vf2d menuPos){
 					if(std::holds_alternative<MenuDataFunc>(nav.right)){
 						Data returnData;
 						std::get<MenuDataFunc>(nav.right)(type,returnData);
+						if(!std::holds_alternative<ButtonName>(returnData)&&!std::holds_alternative<std::weak_ptr<MenuComponent>>(returnData))ERR(std::format("WARNING! No valid return type set for right button navigation in menu {}",int(type)));
 						SetSelection(returnData);
 					}
 				}
@@ -816,3 +821,31 @@ const bool Menu::IsMouseOverMenu(){
 	if(Menu::stack.size()==0)return false;
 	return geom2d::overlaps(game->GetMousePos(),geom2d::rect<float>{Menu::stack.back()->pos-"Interface.9PatchSize"_V.x,Menu::stack.back()->size+"Interface.9PatchSize"_V.y*2});
 }
+
+void Menu::ScrollUp(const MenuType type,const std::string&componentName,Data&returnData,const std::optional<std::string>wrapDestination){
+	if(!Menu::menus[type]->GetSelection().expired()){
+		auto selection=Menu::menus[type]->GetSelection().lock();
+		size_t index=Component<ScrollableWindowComponent>(type,componentName)->GetComponentIndex(selection);
+		index--;
+		if(index>=Component<ScrollableWindowComponent>(type,componentName)->GetComponents().size()){
+			if(wrapDestination)returnData=wrapDestination.value();
+			else returnData=Component<ScrollableWindowComponent>(type,componentName)->GetComponents().back();
+		}else{
+			returnData=Component<ScrollableWindowComponent>(type,componentName)->GetComponents()[index];
+		}
+	}
+}
+
+void Menu::ScrollDown(const MenuType type,const std::string&componentName,Data&returnData,const std::optional<std::string>wrapDestination){
+	if(!Menu::menus[type]->GetSelection().expired()){
+		auto selection=Menu::menus[type]->GetSelection().lock();
+		size_t index=Component<ScrollableWindowComponent>(type,componentName)->GetComponentIndex(selection);
+		index++;
+		if(index>=Component<ScrollableWindowComponent>(type,componentName)->GetComponents().size()){
+			if(wrapDestination)returnData=wrapDestination.value();
+			else returnData=Component<ScrollableWindowComponent>(type,componentName)->GetComponents().front();
+		}else{
+			returnData=Component<ScrollableWindowComponent>(type,componentName)->GetComponents()[index];
+		}
+	}
+}

Adventures in Lestoria/Menu.h

@@ -113,11 +113,12 @@ class Menu:public IAttributable{
     static void InitializeCreditsWindow();
     static void InitializeArtificerWindow();
 	static void InitializeArtificerRefineWindow();
-	static void InitializeArtificerRefineConfirmWindow();
+	static void InitializeArtificerRefineResultWindow();
 	static void InitializeArtificerDisassembleWindow();
-	static void InitializeArtificerDisassembleConfirmWindow();
 	static void InitializeArtificerEnchantWindow();
 	static void InitializeArtificerEnchantConfirmWindow();
+    static void InitializeHubPauseWindow();
+    static void InitializeItemHubLoadoutWindow();
 
     friend class AiL;
     friend class ItemInfo;
@@ -209,6 +210,10 @@ public:
     //Returns whether or not this menu type is currently in the foreground of the game, and thus being interacted with by the user.
     static bool IsCurrentlyActive(MenuType type);
     static const bool IsMouseOverMenu(); //Returns whether the mouse is hovering over any portion of the menu, thus can be used if a menu is not supposed to cover up everything to determine mouse interactions.
+    //If a wrap destination is specified, will resolve the selection to that button when the top is reached, otherwise will default to wrapping around.
+    static void ScrollUp(const MenuType type,const std::string&componentName,Data&returnData,const std::optional<std::string>wrapDestination="");
+    //If a wrap destination is specified, will resolve the selection to that button when the bottom is reached, otherwise will default to wrapping around.
+    static void ScrollDown(const MenuType type,const std::string&componentName,Data&returnData,const std::optional<std::string>wrapDestination="");
 private:
     Menu(vf2d pos,vf2d size);
     static MenuType lastMenuTypeCreated;

Adventures in Lestoria/MenuComponent.cpp

@@ -99,6 +99,7 @@ void MenuComponent::DrawDecal(ViewPort&window,bool focused){
 		window.FillRectDecal(rect.pos+V(A::DRAW_OFFSET)+vf2d{rect.size.x-1+1,0},{1,rect.size.y+1},borderCol);
 		window.FillRectDecal(rect.pos+V(A::DRAW_OFFSET)+vf2d{0,rect.size.y-1+1},{rect.size.x+1,1},borderCol);
 	}
+	
 	if(showDefaultLabel){
 		vf2d adjustedScale=labelScaling;
 		vi2d labelTextSize=vf2d(game->GetTextSizeProp(label))*adjustedScale;