Merge pull request #19 from cpp-gamedev/issue-17

Finish Base Game Features

Author: hentai-chan

src/anim.cpp

@@ -1,12 +1,7 @@
-#include <algorithm>
-#include <filesystem>
-#include <iostream>
-#include <numeric>
-#include <string>
-#include <vector>
-
 #include <str_format/str_format.hpp>
 
+#include <array>
+
 #include "models.hpp"
 #include "utils.hpp"
 
@@ -46,19 +41,50 @@ void print_splash_screen(const std::filesystem::path& assets_dir)
 
 	std::cout << '\n' << std::setfill(' ') << std::setw(19);
 
-	for (const char& c : "copyright (c) 2021 cpp-gamedev")
+	utils::slow_print("copyright (c) 2021 cpp-gamedev", std::chrono::milliseconds{50});
+}
+
+void print_move_table(const models::Pokemon& pkmn)
+{
+	// +----------------------------------------------------------+
+	// |    MOVE                                POWER    ACCURACY |
+	// | 1. move1                                 100          90 |
+	// |    first move description                                |
+	// | 2. move2                                  90          50 |
+	// |    second move description                               |
+	// | 3. move3                                 120          10 |
+	// |    third move description                                |
+	// | 4. move4                                  30          70 |
+	// |    fourth move description                               |
+	// +----------------------------------------------------------+
+
+	constexpr int width = 60;
+	utils::Color border_color = utils::Color::YELLOW;
+	std::string border = utils::style(std::string("|"), border_color);
+	std::string horizontal_line = utils::style(std::string("+").append(std::string(width - 2, '-')).append("+"), border_color);
+
+	std::cout << horizontal_line << '\n';
+	std::cout << border << std::string(4, ' ') << "MOVE" << std::string(32, ' ') << "POWER" << std::string(4, ' ') << "ACCURACY" << ' ' << border << '\n';
+
+	for (std::size_t i = 0; i < pkmn.move_set.size(); ++i)
 	{
-		std::cout << c;
-		utils::sleep(100);
+		// move name, power and accuracy
+		std::string name = kt::format_str("{}. {}", i + 1, pkmn.move_set[i].name);
+		std::cout << border << ' ' << utils::style(name, utils::Color::GREEN) << std::setfill(' ') << std::setw(width - 7 - name.length())
+				  << utils::style(std::to_string(pkmn.move_set[i].power), utils::Color::RED) << std::setfill(' ') << std::setw(21)
+				  << utils::style(std::to_string(pkmn.move_set[i].accuracy), utils::Color::CYAN) << ' ' << border << '\n';
+		// flavor text
+		std::cout << border << std::string(4, ' ') << pkmn.move_set[i].flavor_text << std::setfill(' ') << std::setw(width + 4 - pkmn.move_set[i].flavor_text.length())
+				  << border << '\n';
 	}
+
+	std::cout << horizontal_line << '\n';
 }
 
-std::vector<models::Pokemon> load_main_menu(utils::Manifest manifest)
+std::array<models::Pokemon, 2> load_main_menu(const utils::Manifest& manifest)
 {
 	// 1. set difficulty
-	int selection{};
-	utils::print_enum_table({"easy", "moderate", "hard"}, "difficulty");
-	selection = utils::get_user_input<int>(">>> ");
+	int selection{utils::validate_user_input({"easy", "moderate", "hard"}, "(1/2) SET DIFFICULTY")};
 	auto difficulty = (selection == 1) ? models::Difficulty::EASY : (selection == 2) ? models::Difficulty::MODERATE : models::Difficulty::HARD;
 
 	// 2. instantiate all available pokemons
@@ -71,17 +97,15 @@ std::vector<models::Pokemon> load_main_menu(utils::Manifest manifest)
 	std::vector<std::string> names{};
 	names.reserve(pkmns.size());
 	std::for_each(pkmns.begin(), pkmns.end(), [&names](models::Pokemon& pkmn) { names.push_back(pkmn.name); });
-	utils::print_enum_table(names, "pokemons");
-	selection = utils::get_user_input<int>(">>> ");
+	selection = utils::validate_user_input(names, "(2/2) CHOOSE A POKEMON");
 	models::Pokemon player = pkmns[selection - 1];
 
 	// 4. remove selection from pkmns, so that player won't fight against his doppelganger
 	pkmns.erase(std::remove_if(pkmns.begin(), pkmns.end(), [player](models::Pokemon pkmn) { return player.id == pkmn.id; }), pkmns.end());
-
 	return {player, pkmns.size() > 1 ? utils::random_choice(pkmns) : pkmns[0]};
 }
 
-void print_frame(const models::Pokemon& pkmn1, const models::Pokemon& pkmn2)
+int print_frame(const models::Pokemon& pkmn1, const models::Pokemon& pkmn2)
 {
 	std::string healthbars{};
 	std::string sprites{};
@@ -94,20 +118,34 @@ void print_frame(const models::Pokemon& pkmn1, const models::Pokemon& pkmn2)
 	if (padding > 30)
 		padding -= 2 * (padding - 30);
 
+	// gather healthbars
 	for (std::size_t i = 0; i < 3; i++)
 		healthbars.append(healthbar1[i]).append(std::string(padding, ' ')).append(healthbar2[i]).append("\n");
 
-	std::cout << healthbars;
-
+	// gather sprites
 	for (std::size_t i = 0; i < 20; i++)
 	{
 		std::string tmp = pkmn1.sprite[i]; // strip new line
 		tmp.erase(std::remove(tmp.begin(), tmp.end(), '\n'), tmp.end());
 		sprites.append(tmp).append(std::string(20, ' ')).append(pkmn2.sprite[i]);
 	}
 
-	std::cout << sprites;
+	int answer{};
+	std::vector<int> choices(pkmn1.move_set.size());
+	std::iota(choices.begin(), choices.end(), 1);
+
+	// read and return user-selected move
+	while (std::find(choices.begin(), choices.end(), answer) == choices.end())
+	{
+		utils::clear_screen();
+		std::cout << healthbars;
+		std::cout << sprites;
+		print_move_table(pkmn1);
+		answer = utils::get_user_input<int>(">>> ");
+		std::cin.clear();
+		std::cin.ignore(utils::str_max, '\n');
+	}
 
-	return;
+	return answer;
 }
 } // namespace anim

src/anim.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
-#include<string>
-#include<vector>
+#include <array>
+#include <string>
+#include <vector>
 
 #include "models.hpp"
 
@@ -11,7 +12,9 @@ std::vector<std::string> gen_healthbar(const models::Pokemon& pkmn);
 
 void print_splash_screen(const std::filesystem::path& assets_dir);
 
-std::vector<models::Pokemon> load_main_menu(utils::Manifest manifest);
+void print_move_table(const models::Pokemon& pkmn);
 
-void print_frame(const models::Pokemon& pkmn1, const models::Pokemon& pkmn2);
+std::array<models::Pokemon, 2> load_main_menu(const utils::Manifest& manifest);
+
+int print_frame(const models::Pokemon& pkmn1, const models::Pokemon& pkmn2);
 } // namespace anim

src/main.cpp

@@ -1,13 +1,9 @@
-#include <algorithm>
-#include <filesystem>
-#include <iostream>
-#include <numeric>
-#include <string>
-
 #include "anim.hpp"
 #include "models.hpp"
 #include "utils.hpp"
 
+using namespace std::chrono_literals;
+
 using namespace anim;
 using namespace models;
 using namespace utils;
@@ -23,14 +19,23 @@ int main()
 		clear_screen();
 
 		auto pkmns = load_main_menu(manifest);
-		sleep(1000);
+		auto& [player, ai] = pkmns;
 		clear_screen();
 
-		std::cout << "TODO: init game loop" << '\n';
-		sleep(1000);
-		clear_screen();
+		while (player.hp > 0 && ai.hp > 0)
+		{
+			player.make_move(ai, print_frame(player, ai));
 
-		print_frame(pkmns[0], pkmns[1]);
+			if (ai.hp > 0)
+			{
+				sleep(1000ms);
+				ai.make_move(player, random_range<std::size_t>(1, 4));
+				clear_screen();
+			}
+		}
+
+		clear_screen();
+		slow_print((ai.hp == 0) ? "You Won :)" : "You Lost :(", 50ms);
 
 		return EXIT_SUCCESS;
 	}

src/models.cpp

@@ -1,7 +1,3 @@
-#include <algorithm>
-#include <numeric>
-#include <vector>
-
 #include <str_format/str_format.hpp>
 #include <dumb_json/json.hpp>
 
@@ -18,14 +14,24 @@ std::vector<std::string> Pokemon::read_asset(std::string ext)
 
 void Pokemon::configure_move_set()
 {
-	this->move_set = utils::random_choices(this->all_moves, 4);
+	this->move_set = utils::random_choices(this->all_moves, 3);
+	// ensure that at least one move within the move set will be able to deal damage
+	auto iterator = std::find_if(this->all_moves.begin(), this->all_moves.end(), [&](const Move& move) { return move.power > 0; });
+	if (iterator != this->all_moves.end())
+	{
+		this->move_set.push_back(*iterator);
+	}
+
 
 	for (Move& move : this->move_set)
 	{
-		if (move.power >= 20 && move.accuracy > 0)
+		// NOTE: flavor_text can never be longer than 54 chars, or else it breaks the table formatting in print_move_table @anim.cpp
+
+		if (move.power > 0 && move.accuracy > 0)
 		{
 			move.type = MoveType::ATTACK;
 			move.power += this->difficulty == Difficulty::EASY ? -20 : (this->difficulty == Difficulty::MODERATE) ? 0 : 20;
+			move.power = abs(move.power);
 			move.flavor_text = kt::format_str("{} deals {} points in damage.", move.name, move.power);
 		}
 		else if (move.accuracy == 0)
@@ -39,14 +45,18 @@ void Pokemon::configure_move_set()
 		{
 			move.type = MoveType::HEAL;
 			move.accuracy = 100;
-			move.power = utils::random_range<int>(4, 9) * 10;
+			move.power = utils::random_range<int>(2, 5) * 10;
 			move.flavor_text = kt::format_str("Increase your HP by {} points.", move.power);
 		}
 	}
 }
 
 Pokemon::Pokemon(int id, std::filesystem::path assets_dir, Difficulty difficulty) : assets_dir{assets_dir}, id{id}, difficulty{difficulty}
 {
+	// base level ranges
+	constexpr int min = 15;
+	constexpr int max = 33;
+
 	this->sprite = read_asset("txt");
 	auto lines = read_asset("json");
 	this->json_str = std::accumulate(lines.begin(), lines.end(), std::string(""));
@@ -55,8 +65,8 @@ Pokemon::Pokemon(int id, std::filesystem::path assets_dir, Difficulty difficulty
 	{
 		this->id = id;
 		this->name = json["name"].as<std::string>();
-		this->level = json["level"].as<int>();
-		this->hp = json["hp"].as<int>();
+		this->level = utils::random_range<int>(max * static_cast<int>(difficulty) - min, max * static_cast<int>(difficulty));
+		this->hp = 2 * this->level * utils::random_range<double>(0.8, 1.2);
 		this->max_hp = this->hp;
 		this->atk = json["atk"].as<int>();
 		this->def = json["def"].as<int>();
@@ -83,4 +93,44 @@ Pokemon::Pokemon(int id, std::filesystem::path assets_dir, Difficulty difficulty
 		this->configure_move_set();
 	}
 }
+
+void Pokemon::make_move(Pokemon& pkmn, std::size_t index)
+{
+	std::string msg{};
+	const Move& move = this->move_set[index - 1];
+
+	switch (move.type)
+	{
+	case MoveType::ATTACK:
+		if (utils::random_range<int>(0, 100) <= move.accuracy)
+		{
+			int damage = std::ceil(move.power * (this->atk * 100) / (100 * pkmn.def));
+			pkmn.hp -= damage;
+			pkmn.hp = (pkmn.hp < 0) ? 0 : pkmn.hp;
+			msg = kt::format_str("{} used {} and inflicts {} points in damage!", this->name, move.name, damage);
+		}
+		else
+		{
+			msg = kt::format_str("{} missed his target!", this->name);
+		}
+		break;
+	case MoveType::HEAL:
+		this->hp += move.power;
+		this->hp = (this->hp > this->max_hp) ? this->max_hp : this->hp;
+		msg = kt::format_str("{} increased his HP by {} points", this->name, move.power);
+		break;
+	case MoveType::BOOST_ATK:
+		this->atk += move.power;
+		msg = kt::format_str("{} increased his ATTACK by {}%!", this->name, move.power);
+		break;
+	case MoveType::BOOST_DEF:
+		this->def += move.power;
+		msg = kt::format_str("{} increased his DEFENSE by {}%!", this->name, move.power);
+		break;
+	default:
+		break;
+	}
+
+	utils::slow_print(msg, std::chrono::milliseconds{50});
+}
 } // namespace models

src/models.hpp

@@ -29,6 +29,7 @@ struct Move
 
 enum class Difficulty
 {
+	NONE,
 	EASY,
 	MODERATE,
 	HARD
@@ -57,5 +58,7 @@ struct Pokemon
 	Difficulty difficulty{};
 
 	Pokemon(int id, std::filesystem::path assets_dir, Difficulty difficulty = Difficulty::MODERATE);
+
+	void make_move(Pokemon& pkmn, std::size_t index);
 };
 } // namespace models