Selection menu for selecting powers

Co-authored-by: sigonasr2 <sigonasr2@gmail.com>

main.cpp

@@ -279,6 +279,18 @@ enum class BattleMoveName{
 	PKSHIELD_B,
 	PKSHIELD_O,
 	PKSHIELD_S,
+	PKLIFEUP_A,
+	PKLIFEUP_B,
+	PKLIFEUP_G,
+	PKLIFEUP_O,
+	PKFUN_A,
+	PKFUN_B,
+	PKFUN_G,
+	PKFUN_O,
+	PKFIRE_A,
+	PKFIRE_B,
+	PKFIRE_G,
+	PKFIRE_O,
 };
 
 namespace Battle{
@@ -291,10 +303,11 @@ namespace Battle{
 			bool pctDamage; //Uses % damage for the base damage instead of flat damage.
 			std::vector<std::pair<Property,int>> properties; //The int is used to determine the chance of something occurring.
 			//Properties order is WET, DRY, COLD, HEAT
+			int PPCost=0;
 			int grade=0; //If the name of a move name match, then the grade helps sort it into the same category on menus.
-			Move(std::string name,int baseDmg,int randomDmg,std::array<int,4>composition,bool pctDamage=false,std::vector<std::pair<Property,int>> properties={})
+			Move(std::string name,int baseDmg,int randomDmg,int PPCost,std::array<int,4>composition,bool pctDamage=false,std::vector<std::pair<Property,int>> properties={})
-			:Move(name,0,baseDmg,randomDmg,composition,pctDamage,properties){};
+			:Move(name,0,baseDmg,randomDmg,PPCost,composition,pctDamage,properties){};
-			Move(std::string name,int grade,int baseDmg,int randomDmg,std::array<int,4>composition,bool pctDamage=false,std::vector<std::pair<Property,int>> properties={})
+			Move(std::string name,int grade,int baseDmg,int randomDmg,int PPCost,std::array<int,4>composition,bool pctDamage=false,std::vector<std::pair<Property,int>> properties={})
 			:name(name),grade(grade),randomDmg(randomDmg),baseDmg(baseDmg),composition(composition),pctDamage(pctDamage),properties(properties){}
 	};
 }
@@ -433,10 +446,15 @@ public:
 	int BATTLE_TARGET=-99; //Negative numbers for players and positive numbers for enemy targets.
 	int CURRENT_TURN=-99; //Who's turn we are enacting.
 	int BATTLE_SELECTION_CURSOR=0;
-	int POWER_SELECTION_CURSOR=0;
+	int POWER_SELECTION_CURSOR[4]={0,0,0,0};
 	int TARGET_SELECTION_CURSOR=0;
 	bool ANYKEYPRESSED=false;
 	bool ACTIONKEYPRESSED=false;
+	std::map<std::string,std::vector<Battle::Move*>> BATTLE_MOVELIST_DISPLAY;
+	std::map<int,int> ADDITIONAL_FONT_VALS = {
+		{α,0},{β,1},{γ,2},{Ω,3},{Σ,4},
+	};
+	int POWER_SELECTION_OFFSET[4]={0,0,0,0};
 
 	
 
@@ -465,8 +483,8 @@ public:
 
 		EnableLayer(layer::COLLISION,false);
 
-		SetupPartyMemberStats();
 		SetupMoveList();
+		SetupPartyMemberStats();
 		SetupAnimations();
 		SetupObjectInfo();
 		SetupEncounters();
@@ -481,9 +499,9 @@ public:
 
 		additionalChars[α]={0,0};
 		additionalChars[β]={8,0};
-		additionalChars[γ]={16,0};
+		additionalChars[Ω]={16,0};
-		additionalChars[Ω]={24,0};
+		additionalChars[Σ]={24,0};
-		additionalChars[Σ]={32,0};
+		additionalChars[γ]={32,0};
 
 		MAP_ONETT=new Map("map0","map0_2","map0_3","map0_4","map0_5",SPRITES["terrainmap.png"]);
 
@@ -1119,19 +1137,40 @@ goes on a very long time, I hope you can understand this is only for testing pur
 						if (ACTIONKEYPRESSED) {
 							switch (BATTLE_SELECTION_CURSOR) {
 								case 0:{ //Power selected.
-									DisplayMessageBox("Not implemented yet.");
+									BATTLE_STATE=BattleState::POWER_SELECT;
+									BATTLE_MOVELIST_DISPLAY.clear();
+									Entity*member=PARTY_MEMBER_STATS[PARTY_MEMBER_ID[-CURRENT_TURN-1]];
+									Object*obj=PARTY_MEMBER_OBJ[-CURRENT_TURN-1];
+									for (int i=0;i<member->moveSet.size();i++) {
+										Battle::Move*move = member->moveSet[i];
+										if (BATTLE_MOVELIST_DISPLAY.count(move->name)) {
+											bool found=false;
+											for (int i=0;i<BATTLE_MOVELIST_DISPLAY[move->name].size();i++) {
+												if (ADDITIONAL_FONT_VALS[move->grade]<ADDITIONAL_FONT_VALS[BATTLE_MOVELIST_DISPLAY[move->name][i]->grade]) {
+													BATTLE_MOVELIST_DISPLAY[move->name].insert(BATTLE_MOVELIST_DISPLAY[move->name].begin()+i,move);
+													found=true;
+													break;
+												}
+											}
+											if (!found) {
+												BATTLE_MOVELIST_DISPLAY[move->name].push_back(move);
+											}
+										} else {
+											BATTLE_MOVELIST_DISPLAY[move->name].push_back(move);
+										}
+									}
 								}break;
 								case 1:{ //Attack selected.
-									DisplayMessageBox("Not implemented yet.");
+									BATTLE_STATE=BattleState::TARGET_SELECT;
 								}break;
 								case 2:{ //Items selected.
-									DisplayMessageBox("Not implemented yet.");
+									BATTLE_STATE=BattleState::ITEM_SELECT;
 								}break;
 								case 3:{ //Defend selected.
 									DisplayMessageBox("Not implemented yet.");
 								}break;
 								case 4:{ //Move selected.
-									DisplayMessageBox("Not implemented yet.");
+									BATTLE_STATE=BattleState::MOVE_SELECT;
 								}break;
 								case 5:{ //Run selected.
 									DisplayMessageBox("Not implemented yet.");
@@ -1140,6 +1179,22 @@ goes on a very long time, I hope you can understand this is only for testing pur
 						}
 					}
 				}break;
+				case BattleState::POWER_SELECT:{
+					if (CURRENT_TURN<0) {
+						if (DownPressed()) {
+							POWER_SELECTION_CURSOR[-CURRENT_TURN-1]=std::clamp(POWER_SELECTION_CURSOR[-CURRENT_TURN-1]+1,0,(int)BATTLE_MOVELIST_DISPLAY.size()-1);
+							if (POWER_SELECTION_CURSOR[-CURRENT_TURN-1]-POWER_SELECTION_OFFSET[-CURRENT_TURN-1]>=4) {
+								POWER_SELECTION_OFFSET[-CURRENT_TURN-1]++;
+							}
+						}
+						if (UpPressed()) {
+							POWER_SELECTION_CURSOR[-CURRENT_TURN-1]=std::clamp(POWER_SELECTION_CURSOR[-CURRENT_TURN-1]-1,0,(int)BATTLE_MOVELIST_DISPLAY.size()-1);
+							if (POWER_SELECTION_CURSOR[-CURRENT_TURN-1]<POWER_SELECTION_OFFSET[-CURRENT_TURN-1]) {
+								POWER_SELECTION_OFFSET[-CURRENT_TURN-1]--;
+							}
+						}
+					}
+				}break;
 			}
 		}
 
@@ -1376,12 +1431,8 @@ goes on a very long time, I hope you can understand this is only for testing pur
 			}break;
 		}
 		if (BATTLE_ENCOUNTER!=nullptr) {
-			switch (BATTLE_STATE) {
-				case BattleState::MOVE_CAMERA:{
-
-				}break;
-				case BattleState::SELECT_ACTION:{
 			SetDrawTarget(layer::HIGH);
+			if (BATTLE_STATE==BattleState::SELECT_ACTION||BATTLE_STATE==BattleState::POWER_SELECT||BATTLE_STATE==BattleState::ITEM_SELECT) {
 				DrawDialogBox({1,1},{(int)(WIDTH*0.75),HEIGHT/6},Pixel(70, 33, 105,128),Pixel(62, 54, 69,128),Pixel(185, 148, 255,128));
 				const std::string labels[6]={"Power","Attack","Item","Defend","Move","Run"};
 				for (int i=0;i<6;i+=2) {
@@ -1389,9 +1440,43 @@ goes on a very long time, I hope you can understand this is only for testing pur
 					DrawStringPropDecal({3+8+i/2*64,23},labels[i+1]);
 				}
 				DrawDecal({BATTLE_SELECTION_CURSOR/2*64+3,9+((BATTLE_SELECTION_CURSOR%2==0)?0:14)},SPRITES["cursor.png"]);
-				} //Break intentionally left out!
+			}
-				default:{
+			if (BATTLE_STATE==BattleState::POWER_SELECT) {
-					SetDrawTarget(layer::HIGH);
+				SetDrawTarget(layer::INTERFACE);
+				DrawDialogBox({1,1},{(int)(WIDTH/2),HEIGHT/4},Pixel(70, 33, 105,128),Pixel(62, 54, 69,128),Pixel(185, 148, 255,128));
+				std::map<std::string, std::vector<Battle::Move *>>::const_iterator it = BATTLE_MOVELIST_DISPLAY.cbegin();
+				int counter=0;
+				int displayLimit=0;
+				while (it!=BATTLE_MOVELIST_DISPLAY.cend()) {
+					if (counter>=POWER_SELECTION_OFFSET[-CURRENT_TURN-1]&&counter<=POWER_SELECTION_OFFSET[-CURRENT_TURN-1]+3) {
+						int displayYOffset=-POWER_SELECTION_OFFSET[-CURRENT_TURN-1]*12;
+						std::vector<Battle::Move*> moves = it->second;
+						std::string name = it->first;
+						if (GetTextSizeProp(name).x>WIDTH/4) {
+							DrawStringPropDecal({12,12*counter+8+displayYOffset},name,WHITE,{(WIDTH/4)/(float)GetTextSizeProp(name).x,1});
+						} else {
+							DrawStringPropDecal({12,12*counter+8+displayYOffset},name);
+						}
+						std::wstring drawStr;
+						for (int i=0;i<moves.size();i++) {
+							drawStr+=moves[i]->grade;
+						}
+						DrawFancyStringDecal({8+WIDTH/4+4,12*counter+8+displayYOffset},drawStr);
+					}
+					++it;
+					++counter;
+				}
+				DrawDecal({4,12*(POWER_SELECTION_CURSOR[-CURRENT_TURN-1]-POWER_SELECTION_OFFSET[-CURRENT_TURN-1])+8},SPRITES["cursor.png"]);
+				if (BATTLE_MOVELIST_DISPLAY.size()>4) {
+					if (POWER_SELECTION_OFFSET[-CURRENT_TURN-1]>0) {
+						DrawRotatedDecal({WIDTH/2-16,3},SPRITES["cursor.png"],-M_PI_2,{4,4});
+					}
+					if (POWER_SELECTION_OFFSET[-CURRENT_TURN-1]+3<BATTLE_MOVELIST_DISPLAY.size()) {
+						DrawRotatedDecal({WIDTH/2-16,HEIGHT/4-11},SPRITES["cursor.png"],M_PI_2,{4,4});
+					}
+				}
+			}
+			if (BATTLE_STATE!=BattleState::MOVE_CAMERA) {
 				for (int i=0;i<PARTY_MEMBER_COUNT;i++) {
 					Entity*member=PARTY_MEMBER_STATS[PARTY_MEMBER_ID[i]];
 					Object*obj=PARTY_MEMBER_OBJ[i];
@@ -1426,7 +1511,6 @@ goes on a very long time, I hope you can understand this is only for testing pur
 				}
 			}
 		}
-		}
 		if (messageBoxVisible) {
 			SetDrawTarget(layer::INTERFACE);
 			DrawDialogBox({1,1},{WIDTH/2,HEIGHT/4},Pixel(70, 33, 105,128),Pixel(62, 54, 69,128),Pixel(185, 148, 255,128));
@@ -1747,32 +1831,75 @@ goes on a very long time, I hope you can understand this is only for testing pur
 			PARTY_MEMBER_STATS[i]=new Entity(120,120,30,30,8,{0,0,0,0},4,{MOVELIST[BattleMoveName::TESTMOVE1]});
 			printf("HP:%d Max HP:%d",PARTY_MEMBER_STATS[i]->HP,PARTY_MEMBER_STATS[i]->maxHP);
 		}
+		PARTY_MEMBER_STATS[PLAYER]->moveSet={
+			MOVELIST[BattleMoveName::HAILSTORM_A],
+			MOVELIST[BattleMoveName::HAILSTORM_B],
+			MOVELIST[BattleMoveName::HURRICANE_A],
+			MOVELIST[BattleMoveName::HURRICANE_B],
+			MOVELIST[BattleMoveName::HURRICANE_G],
+			MOVELIST[BattleMoveName::HURRICANE_O],
+			MOVELIST[BattleMoveName::METEORRAIN_A],
+			MOVELIST[BattleMoveName::PKFUN_A],
+			MOVELIST[BattleMoveName::PKLIFEUP_A],
+			MOVELIST[BattleMoveName::PKFREEZE_A],
+			MOVELIST[BattleMoveName::PKSHIELD_A]};
+		PARTY_MEMBER_STATS[NESS]->moveSet={
+			MOVELIST[BattleMoveName::PKFUN_A],
+			MOVELIST[BattleMoveName::PKFUN_B],
+			MOVELIST[BattleMoveName::PKLIFEUP_A],
+			MOVELIST[BattleMoveName::PKLIFEUP_B],
+			MOVELIST[BattleMoveName::PKLIFEUP_G],
+			MOVELIST[BattleMoveName::PKLIFEUP_O],};
+		PARTY_MEMBER_STATS[PAULA]->moveSet={
+			MOVELIST[BattleMoveName::PKFREEZE_A],
+			MOVELIST[BattleMoveName::PKFREEZE_B],
+			MOVELIST[BattleMoveName::PKFREEZE_G],
+			MOVELIST[BattleMoveName::PKFREEZE_O],
+			MOVELIST[BattleMoveName::PKFIRE_A],
+			MOVELIST[BattleMoveName::PKFIRE_B],};
+		PARTY_MEMBER_STATS[ANNA]->moveSet={
+			MOVELIST[BattleMoveName::PKFREEZE_A],
+			MOVELIST[BattleMoveName::PKSHIELD_A],
+			MOVELIST[BattleMoveName::PKSHIELD_B],
+			MOVELIST[BattleMoveName::PKLIFEUP_A],};
 	}
 
 	void SetupMoveList() {
-		MOVELIST[BattleMoveName::TESTMOVE1]=new Battle::Move("Test Move 1",30,5,{0,0,0,0});
+		MOVELIST[BattleMoveName::TESTMOVE1]=new Battle::Move("Test Move 1",30,5,ㅍ 0,{0,0,0,0});
-		MOVELIST[BattleMoveName::TESTMOVE2]=new Battle::Move("Test Move 2",40,10,{0,0,0,0});
+		MOVELIST[BattleMoveName::TESTMOVE2]=new Battle::Move("Test Move 2",40,10,ㅍ 0,{0,0,0,0});
-		MOVELIST[BattleMoveName::TESTMOVE3]=new Battle::Move("Test Move 3",25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::TESTMOVE3]=new Battle::Move("Test Move 3",25,5,ㅍ 0,{0,0,20,0});
-		MOVELIST[BattleMoveName::HAILSTORM_A]=new Battle::Move("Hailstorm",ALPHA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HAILSTORM_A]=new Battle::Move("Hailstorm",ALPHA,25,5,ㅍ 4,{0,0,20,0});
-		MOVELIST[BattleMoveName::HAILSTORM_B]=new Battle::Move("Hailstorm",BETA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HAILSTORM_B]=new Battle::Move("Hailstorm",BETA,25,5,ㅍ 12,{0,0,20,0});
-		MOVELIST[BattleMoveName::HAILSTORM_G]=new Battle::Move("Hailstorm",GAMMA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HAILSTORM_G]=new Battle::Move("Hailstorm",GAMMA,25,5,ㅍ 28,{0,0,20,0});
-		MOVELIST[BattleMoveName::HAILSTORM_O]=new Battle::Move("Hailstorm",OMEGA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HAILSTORM_O]=new Battle::Move("Hailstorm",OMEGA,25,5,ㅍ 69,{0,0,20,0});
-		MOVELIST[BattleMoveName::HURRICANE_A]=new Battle::Move("Hurricane",ALPHA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HURRICANE_A]=new Battle::Move("Hurricane",ALPHA,25,5,ㅍ 7,{0,0,20,0});
-		MOVELIST[BattleMoveName::HURRICANE_B]=new Battle::Move("Hurricane",BETA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HURRICANE_B]=new Battle::Move("Hurricane",BETA,25,5,ㅍ 13,{0,0,20,0});
-		MOVELIST[BattleMoveName::HURRICANE_G]=new Battle::Move("Hurricane",GAMMA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HURRICANE_G]=new Battle::Move("Hurricane",GAMMA,25,5,ㅍ 25,{0,0,20,0});
-		MOVELIST[BattleMoveName::HURRICANE_O]=new Battle::Move("Hurricane",OMEGA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::HURRICANE_O]=new Battle::Move("Hurricane",OMEGA,25,5,ㅍ 55,{0,0,20,0});
-		MOVELIST[BattleMoveName::METEORRAIN_A]=new Battle::Move("Meteor Rain",ALPHA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::METEORRAIN_A]=new Battle::Move("Meteor Rain",ALPHA,25,5,ㅍ 10,{0,0,20,0});
-		MOVELIST[BattleMoveName::METEORRAIN_B]=new Battle::Move("Meteor Rain",BETA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::METEORRAIN_B]=new Battle::Move("Meteor Rain",BETA,25,5,ㅍ 22,{0,0,20,0});
-		MOVELIST[BattleMoveName::METEORRAIN_G]=new Battle::Move("Meteor Rain",GAMMA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::METEORRAIN_G]=new Battle::Move("Meteor Rain",GAMMA,25,5,ㅍ 47,{0,0,20,0});
-		MOVELIST[BattleMoveName::METEORRAIN_O]=new Battle::Move("Meteor Rain",OMEGA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::METEORRAIN_O]=new Battle::Move("Meteor Rain",OMEGA,25,5,ㅍ 98,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKFREEZE_A]=new Battle::Move("PK Freeze",ALPHA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFREEZE_A]=new Battle::Move("PK Freeze",ALPHA,25,5,ㅍ 4,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKFREEZE_B]=new Battle::Move("PK Freeze",BETA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFREEZE_B]=new Battle::Move("PK Freeze",BETA,25,5,ㅍ 8,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKFREEZE_G]=new Battle::Move("PK Freeze",GAMMA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFREEZE_G]=new Battle::Move("PK Freeze",GAMMA,25,5,ㅍ 12,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKFREEZE_O]=new Battle::Move("PK Freeze",OMEGA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFREEZE_O]=new Battle::Move("PK Freeze",OMEGA,25,5,ㅍ 22,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKSHIELD_A]=new Battle::Move("PK Shield",ALPHA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKSHIELD_A]=new Battle::Move("PK Shield",ALPHA,25,5,ㅍ 12,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKSHIELD_B]=new Battle::Move("PK Shield",BETA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKSHIELD_B]=new Battle::Move("PK Shield",BETA,25,5,ㅍ 20,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKSHIELD_O]=new Battle::Move("PK Shield",OMEGA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKSHIELD_O]=new Battle::Move("PK Shield",OMEGA,25,5,ㅍ 59,{0,0,20,0});
-		MOVELIST[BattleMoveName::PKSHIELD_S]=new Battle::Move("PK Shield",SIGMA,25,5,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKSHIELD_S]=new Battle::Move("PK Shield",SIGMA,25,5,ㅍ 80,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKLIFEUP_A]=new Battle::Move("PK Lifeup",ALPHA,25,5,ㅍ 4,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKLIFEUP_B]=new Battle::Move("PK Lifeup",BETA,25,5,ㅍ 9,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKLIFEUP_G]=new Battle::Move("PK Lifeup",GAMMA,25,5,ㅍ 21,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKLIFEUP_O]=new Battle::Move("PK Lifeup",OMEGA,25,5,ㅍ 64,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFUN_A]=new Battle::Move("PK Fun",ALPHA,25,5,ㅍ 15,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFUN_B]=new Battle::Move("PK Fun",BETA,25,5,ㅍ 30,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFUN_G]=new Battle::Move("PK Fun",GAMMA,25,5,ㅍ 45,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFUN_O]=new Battle::Move("PK Fun",OMEGA,25,5,ㅍ 90,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFIRE_A]=new Battle::Move("PK Fire",ALPHA,25,5,ㅍ 6,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFIRE_B]=new Battle::Move("PK Fire",BETA,25,5,ㅍ 12,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFIRE_G]=new Battle::Move("PK Fire",GAMMA,25,5,ㅍ 20,{0,0,20,0});
+		MOVELIST[BattleMoveName::PKFIRE_O]=new Battle::Move("PK Fire",OMEGA,25,5,ㅍ 32,{0,0,20,0});
 	}
 
 	void SetupAnimations() {

states.h

@@ -14,5 +14,9 @@ namespace BattleState{
         WAIT,
         WAIT_ANIMATION,
         SELECT_ACTION,
+        POWER_SELECT,
+        ITEM_SELECT,
+        TARGET_SELECT,
+        MOVE_SELECT,
     };
 }