From 50f058e7ea845169b75528bb97bb406a9122356d Mon Sep 17 00:00:00 2001 From: a25liang Date: Fri, 12 Jul 2024 16:41:42 -0400 Subject: [PATCH] format --- src/arguments.cc | 238 +++++++++++++++++++++--------------------- src/arguments.h | 1 - src/boost_atk.cc | 23 ++-- src/boost_atk.h | 9 +- src/boost_def.cc | 21 ++-- src/boost_def.h | 8 +- src/characters.cc | 132 ++++++++++++----------- src/characters.h | 95 +++++++++-------- src/console_input.h | 8 +- src/console_output.cc | 87 ++++++++------- src/console_output.h | 16 +-- src/constants.h | 6 +- src/curses_input.cc | 108 +++++++++---------- src/curses_input.h | 6 +- src/curses_output.cc | 30 +++--- src/curses_output.h | 16 +-- src/cursor.cc | 48 ++++----- src/cursor.h | 16 +-- src/display.cc | 14 +-- src/display.h | 34 +++--- src/drow.cc | 32 +++--- src/drow.h | 12 +-- src/file_input.cc | 56 +++++----- src/file_input.h | 8 +- src/file_output.cc | 30 +++--- src/file_output.h | 14 +-- src/fraction.cc | 42 ++++---- src/fraction.h | 18 ++-- src/game.h | 26 ++--- src/goblin.cc | 38 +++---- src/goblin.h | 12 +-- src/input.cc | 11 +- src/input.h | 4 +- src/log.cc | 2 +- src/log.h | 24 ++--- src/main.cc | 31 +++--- src/map.cc | 56 +++++----- src/map.h | 56 +++++----- src/poison_health.cc | 20 ++-- src/poison_health.h | 8 +- src/position.cc | 28 ++--- src/position.h | 20 ++-- src/potion.cc | 6 +- src/potion.h | 26 ++--- src/restore_health.cc | 18 ++-- src/restore_health.h | 8 +- src/rng.cc | 24 ++--- src/rng.h | 26 ++--- src/room.h | 2 - src/shade.cc | 31 +++--- src/shade.h | 12 +-- src/vampire.cc | 38 +++---- src/vampire.h | 12 +-- src/wound_atk.cc | 21 ++-- src/wound_atk.h | 8 +- src/wound_def.cc | 20 ++-- src/wound_def.h | 8 +- 57 files changed, 853 insertions(+), 871 deletions(-) diff --git a/src/arguments.cc b/src/arguments.cc index 1b2462f..d0fe958 100644 --- a/src/arguments.cc +++ b/src/arguments.cc @@ -19,157 +19,157 @@ feature proc_args(int argc, char **argv, std::unique_ptr &out, std::unique_ptr &log, std::unique_ptr &rng) { - feature result = 0; - std::string str; - std::string fn_fin; - std::string fn_fout; - std::string fn_lout; - std::string fn_save; - std::string seed; + feature result = 0; + std::string str; + std::string fn_fin; + std::string fn_fout; + std::string fn_lout; + std::string fn_save; + std::string seed; - for (int i = 1; i < argc; ++i) { - str = argv[i]; + for (int i = 1; i < argc; ++i) { + str = argv[i]; - if (str == "-n") { - if (result & (FEATURE_IN_FILE | FEATURE_OUT_FILE)) - return FEATURE_CONFLICT | i; + if (str == "-n") { + if (result & (FEATURE_IN_FILE | FEATURE_OUT_FILE)) + return FEATURE_CONFLICT | i; - result |= FEATURE_NCURSES; - } else if (str == "-r") { - result |= FEATURE_RAND_MAP; - } else if (str == "-m") { - result |= FEATURE_MENU; - } else if (str == "-c") { - result |= FEATURE_ENEMIES_CHASE; - } else if (str == "-i") { - result |= FEATURE_INVENTORY; - } else if (str == "-t") { - result |= FEATURE_THROW; - } else if (str == "-R") { - result |= FEATURE_REVISIT; - } else if (str == "-s") { - ++i; - str = argv[i]; + result |= FEATURE_NCURSES; + } else if (str == "-r") { + result |= FEATURE_RAND_MAP; + } else if (str == "-m") { + result |= FEATURE_MENU; + } else if (str == "-c") { + result |= FEATURE_ENEMIES_CHASE; + } else if (str == "-i") { + result |= FEATURE_INVENTORY; + } else if (str == "-t") { + result |= FEATURE_THROW; + } else if (str == "-R") { + result |= FEATURE_REVISIT; + } else if (str == "-s") { + ++i; + str = argv[i]; - if (!seed.empty() && seed != str) - return FEATURE_CONFLICT | i; + if (!seed.empty() && seed != str) + return FEATURE_CONFLICT | i; - seed = str; - result |= FEATURE_SEED; - } else if (str == "-L") { - ++i; - str = argv[i]; + seed = str; + result |= FEATURE_SEED; + } else if (str == "-L") { + ++i; + str = argv[i]; - if (!fn_lout.empty() && fn_lout != str) - return FEATURE_CONFLICT | i; + if (!fn_lout.empty() && fn_lout != str) + return FEATURE_CONFLICT | i; - fn_lout = str; - result |= FEATURE_LOG; - } else if (str == "-I") { - ++i; - str = argv[i]; + fn_lout = str; + result |= FEATURE_LOG; + } else if (str == "-I") { + ++i; + str = argv[i]; - if (!fn_fin.empty() && fn_fin != str) - return FEATURE_CONFLICT | i; + if (!fn_fin.empty() && fn_fin != str) + return FEATURE_CONFLICT | i; - fn_fin = str; - result |= FEATURE_IN_FILE; - } else if (str == "-O") { - ++i; - str = argv[i]; + fn_fin = str; + result |= FEATURE_IN_FILE; + } else if (str == "-O") { + ++i; + str = argv[i]; - if (!fn_fout.empty() && fn_fout != str) - return FEATURE_CONFLICT | i; + if (!fn_fout.empty() && fn_fout != str) + return FEATURE_CONFLICT | i; - fn_fout = str; - result |= FEATURE_OUT_FILE; - } else if (str == "-h" || str == "--help") { - return FEATURE_LIST_ARGS; - } else { - return FEATURE_PANIC | i; - } + fn_fout = str; + result |= FEATURE_OUT_FILE; + } else if (str == "-h" || str == "--help") { + return FEATURE_LIST_ARGS; + } else { + return FEATURE_PANIC | i; } + } - if (result & FEATURE_IN_FILE) { - std::ifstream fin(fn_fin); + if (result & FEATURE_IN_FILE) { + std::ifstream fin(fn_fin); - if (!fin.good()) - return FEATURE_PANIC_FILE | FEATURE_IN_FILE; + if (!fin.good()) + return FEATURE_PANIC_FILE | FEATURE_IN_FILE; - in = std::make_unique(std::move(fin)); - } else if (!(result & FEATURE_NCURSES)) - in = std::make_unique(std::cin); + in = std::make_unique(std::move(fin)); + } else if (!(result & FEATURE_NCURSES)) + in = std::make_unique(std::cin); - if (result & FEATURE_OUT_FILE) { - std::ofstream fout(fn_fout); + if (result & FEATURE_OUT_FILE) { + std::ofstream fout(fn_fout); - if (!fout.good()) - return FEATURE_PANIC_FILE | FEATURE_OUT_FILE; + if (!fout.good()) + return FEATURE_PANIC_FILE | FEATURE_OUT_FILE; - out = std::make_unique(std::move(fout)); - } else if (!(result & FEATURE_NCURSES)) - out = std::make_unique(std::cout); + out = std::make_unique(std::move(fout)); + } else if (!(result & FEATURE_NCURSES)) + out = std::make_unique(std::cout); - if (result & FEATURE_LOG) { - std::ofstream lout(fn_lout); + if (result & FEATURE_LOG) { + std::ofstream lout(fn_lout); - if (!lout.good()) - return FEATURE_PANIC_FILE | FEATURE_LOG; + if (!lout.good()) + return FEATURE_PANIC_FILE | FEATURE_LOG; - log = std::make_unique(std::move(lout)); - } + log = std::make_unique(std::move(lout)); + } - if (result & FEATURE_NCURSES) { - curse = std::make_unique(); - in = std::make_unique(*curse); - out = std::make_unique(*curse); - } + if (result & FEATURE_NCURSES) { + curse = std::make_unique(); + in = std::make_unique(*curse); + out = std::make_unique(*curse); + } - if (result & FEATURE_SEED) { - std::istringstream iss {seed}; - unsigned int tmp; - iss >> tmp; + if (result & FEATURE_SEED) { + std::istringstream iss {seed}; + unsigned int tmp; + iss >> tmp; - if (!iss.good()) - return FEATURE_PANIC_SEED; + if (!iss.good()) + return FEATURE_PANIC_SEED; - rng = std::make_unique(tmp); - } + rng = std::make_unique(tmp); + } - return result; + return result; } // IMPORTANT: This is meant for already panicking void panic_args(feature panic) { - using namespace std; + using namespace std; - if (panic & FEATURE_PANIC) - cerr << "Invalid argument No. " << (panic ^ FEATURE_PANIC) - << " !" << endl; - else if (panic & FEATURE_CONFLICT) - cerr << "Argument No. " << (panic ^ FEATURE_CONFLICT) - << " conflicts with a previous argument!" << endl; - else if (panic & FEATURE_PANIC_FILE) { - switch (panic ^ FEATURE_PANIC_FILE) { - case FEATURE_IN_FILE: - cerr << "Cannot open specified input file!" << endl; - break; + if (panic & FEATURE_PANIC) + cerr << "Invalid argument No. " << (panic ^ FEATURE_PANIC) + << " !" << endl; + else if (panic & FEATURE_CONFLICT) + cerr << "Argument No. " << (panic ^ FEATURE_CONFLICT) + << " conflicts with a previous argument!" << endl; + else if (panic & FEATURE_PANIC_FILE) { + switch (panic ^ FEATURE_PANIC_FILE) { + case FEATURE_IN_FILE: + cerr << "Cannot open specified input file!" << endl; + break; - case FEATURE_OUT_FILE: - cerr << "Cannot open specified output file!" << endl; - break; + case FEATURE_OUT_FILE: + cerr << "Cannot open specified output file!" << endl; + break; - case FEATURE_LOG: - cerr << "Cannot open specified log file!" << endl; - break; + case FEATURE_LOG: + cerr << "Cannot open specified log file!" << endl; + break; - default: - cerr << "Something must have went really, really, wrong..." - << endl; - } - } else if (panic & FEATURE_PANIC_SEED) { - cerr << "Invalid seed" << endl; - } else - cerr << "Something must have went really, really, wrong..." - << endl; + default: + cerr << "Something must have went really, really, wrong..." + << endl; + } + } else if (panic & FEATURE_PANIC_SEED) { + cerr << "Invalid seed" << endl; + } else + cerr << "Something must have went really, really, wrong..." + << endl; } diff --git a/src/arguments.h b/src/arguments.h index 9af55de..8226b97 100644 --- a/src/arguments.h +++ b/src/arguments.h @@ -7,7 +7,6 @@ #include "input.h" #include "rng.h" - #include "constants.h" /* Arguments diff --git a/src/boost_atk.cc b/src/boost_atk.cc index 2c4c00d..5bb1d48 100644 --- a/src/boost_atk.cc +++ b/src/boost_atk.cc @@ -6,23 +6,20 @@ const int BOOST_ATK = 5; const int BOOST_ATK_DROW = 7; boost_atk::boost_atk(): - potion{potion_type::boost_atk, -1} {} + potion{potion_type::boost_atk, -1} {} void boost_atk::apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - ATK += BOOST_ATK_DROW; - else - ATK += BOOST_ATK; + float &base_hit_rate) { + if (remaining_duration > 0) { + if (race == rdrow) + ATK += BOOST_ATK_DROW; + else + ATK += BOOST_ATK; - --remaining_duration; - } + --remaining_duration; + } } int boost_atk::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } - - - diff --git a/src/boost_atk.h b/src/boost_atk.h index aea5029..5145667 100644 --- a/src/boost_atk.h +++ b/src/boost_atk.h @@ -5,11 +5,10 @@ class boost_atk final: public potion { public: - boost_atk(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + boost_atk(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif - diff --git a/src/boost_def.cc b/src/boost_def.cc index 77b5d01..59352f4 100644 --- a/src/boost_def.cc +++ b/src/boost_def.cc @@ -5,22 +5,21 @@ const int BOOST_DEF = 5; const int BOOST_DEF_DROW = 7; - boost_def::boost_def(): - potion{potion_type::boost_def, -1} {} + potion{potion_type::boost_def, -1} {} void boost_def::apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - DEF += BOOST_DEF_DROW; - else - DEF += BOOST_DEF; + float &base_hit_rate) { + if (remaining_duration > 0) { + if (race == rdrow) + DEF += BOOST_DEF_DROW; + else + DEF += BOOST_DEF; - --remaining_duration; - } + --remaining_duration; + } } int boost_def::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } \ No newline at end of file diff --git a/src/boost_def.h b/src/boost_def.h index aa4ce36..09f0608 100644 --- a/src/boost_def.h +++ b/src/boost_def.h @@ -5,10 +5,10 @@ class boost_def final: public potion { public: - boost_def(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + boost_def(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif diff --git a/src/characters.cc b/src/characters.cc index 48a0931..1e42ecd 100644 --- a/src/characters.cc +++ b/src/characters.cc @@ -3,156 +3,154 @@ #include character::character(RNG &rng, const enum race &nrace): - rng{rng}, - race{nrace}, HP{STARTING_HP[race]}, - ATK{STARTING_ATK[race]}, DEF{STARTING_DEF[race]} {} + rng{rng}, + race{nrace}, HP{STARTING_HP[race]}, + ATK{STARTING_ATK[race]}, DEF{STARTING_DEF[race]} {} enum race character::get_race() const { - return race; + return race; } position character::get_position() const { - return pos; + return pos; } int character::get_HP() const { - return HP; + return HP; } int character::get_ATK() const { - return ATK; + return ATK; } int character::get_DEF() const { - return DEF; + return DEF; } int character::get_gold() const { - return gold; + return gold; } float character::get_hitrate() const { - return base_hit_rate; + return base_hit_rate; } bool character::is_hostile() const { - return hostile; + return hostile; } void character::set_position(const position &npos) { - pos = npos; + pos = npos; } void character::set_HP(const int nHP) { - HP = nHP; + HP = nHP; } void character::set_ATK(const int nATK) { - ATK = nATK; + ATK = nATK; } void character::set_DEF(const int nDEF) { - DEF = nDEF; + DEF = nDEF; } void character::set_gold(const int ngold) { - gold = ngold; + gold = ngold; } void character::set_hitrate(const float nhitrate) { - base_hit_rate = nhitrate; + base_hit_rate = nhitrate; } void character::set_hostile(const bool is_hostile) { - hostile = is_hostile; + hostile = is_hostile; } void character::apply_buff(const stat_name statn, const int amount) { - // TODO: add checks for bounds - switch (statn) { - case stat_name::HP: - HP += amount; - break; + // TODO: add checks for bounds + switch (statn) { + case stat_name::HP: + HP += amount; + break; - case stat_name::ATK: - ATK += amount; - break; + case stat_name::ATK: + ATK += amount; + break; - case stat_name::DEF: - DEF += amount; - break; + case stat_name::DEF: + DEF += amount; + break; - case stat_name::hostile: { - if (amount > 0) - hostile = true; - else - hostile = false; + case stat_name::hostile: { + if (amount > 0) + hostile = true; + else + hostile = false; - break; - } - } + break; + } + } } direction_list character::moveable(const position_list &available_positions) const { - direction_list result; + direction_list result; - for (int i = 0; i < DIRECTION_CNT; ++i) - if (find(available_positions, pos + MOVE[i]) - != available_positions.size()) - result.push_back((direction)i); + for (int i = 0; i < DIRECTION_CNT; ++i) + if (find(available_positions, pos + MOVE[i]) + != available_positions.size()) + result.push_back((direction)i); - return result; + return result; } result character::apply(direction &dir, const potion_list &potions) { - // TODO: implement this after implementing potions - return result::fine; + // TODO: implement this after implementing potions + return result::fine; } position_list remove_from_list(const position_list &sorted_positions, position_list excluded) { - std::sort(excluded.begin(), excluded.end()); + std::sort(excluded.begin(), excluded.end()); - position_list result{sorted_positions.size() - excluded.size()}; + position_list result{sorted_positions.size() - excluded.size()}; - auto exc = excluded.begin(); + auto exc = excluded.begin(); - for (auto src : sorted_positions) { - if (exc != excluded.end() && src == *exc) - ++exc; - else - result.push_back(src); - } + for (auto src : sorted_positions) { + if (exc != excluded.end() && src == *exc) + ++exc; + else + result.push_back(src); + } - return result; + return result; } // IMPORTANT: remember to check if player is on the stairs result character::move(const direction dir, const position_list &available_positions) { - if (find(available_positions, pos + MOVE[dir]) + if (find(available_positions, pos + MOVE[dir]) != available_positions.size()) { - pos += MOVE[dir]; - return result::moved; - } + pos += MOVE[dir]; + return result::moved; + } - return result::fine; + return result::fine; } result character::move_or_attack(const direction dir, const position_list &available_positions, character_list &chlist) { - auto res = this->move(dir, available_positions); + auto res = this->move(dir, available_positions); - if (res != result::fine) - return res; + if (res != result::fine) + return res; - return this->attack(dir, chlist); + return this->attack(dir, chlist); } - int calc_dmg(const int ATK, const int DEF) { - return ceil((100 / (100 + DEF)) * ATK); + return ceil((100 / (100 + DEF)) * ATK); } - diff --git a/src/characters.h b/src/characters.h index 4c5a04c..07e30d5 100644 --- a/src/characters.h +++ b/src/characters.h @@ -25,71 +25,70 @@ typedef std::vector character_list; class character { public: - character(RNG &rng, const race &nrace); // fills out the starting stats + character(RNG &rng, const race &nrace); // fills out the starting stats - // usually I wouldn't do this but considering that the map has - // a super small size an O(n) solution is acceptable - // IMPORTANT: available_positions do NOT have characters in them - direction_list moveable(const position_list &available_positions) const; - virtual result move(const direction dir, - const position_list &available_positions); - virtual result attack(const direction dir, - character_list &chlist) = 0; - virtual result move_or_attack(const direction dir, - const position_list &available_positions, - character_list &chlist); - virtual result apply(direction &dir, - const potion_list &potions); - virtual result get_hit(const enum race &race, const int atk, - const float hitrate) = 0; + // usually I wouldn't do this but considering that the map has + // a super small size an O(n) solution is acceptable + // IMPORTANT: available_positions do NOT have characters in them + direction_list moveable(const position_list &available_positions) const; + virtual result move(const direction dir, + const position_list &available_positions); + virtual result attack(const direction dir, + character_list &chlist) = 0; + virtual result move_or_attack(const direction dir, + const position_list &available_positions, + character_list &chlist); + virtual result apply(direction &dir, + const potion_list &potions); + virtual result get_hit(const enum race &race, const int atk, + const float hitrate) = 0; - enum race get_race() const; - position get_position() const; - int get_HP() const; - int get_ATK() const; - int get_DEF() const; - int get_gold() const; - float get_hitrate() const; - bool is_hostile() const; + enum race get_race() const; + position get_position() const; + int get_HP() const; + int get_ATK() const; + int get_DEF() const; + int get_gold() const; + float get_hitrate() const; + bool is_hostile() const; - void set_position(const position &npos); - void set_HP(const int nHP); - void set_ATK(const int nATK); - void set_DEF(const int nDEF); - void set_gold(const int ngold); - void set_hitrate(const float nhitrate); - void set_hostile(const bool is_hostile); + void set_position(const position &npos); + void set_HP(const int nHP); + void set_ATK(const int nATK); + void set_DEF(const int nDEF); + void set_gold(const int ngold); + void set_hitrate(const float nhitrate); + void set_hostile(const bool is_hostile); - // if stat is hostile, positive to set it to hostile, - // negative to set it to peaceful - void apply_buff(const stat_name statn, const int amount); - // void apply_buff(const stat_name statn, const float mul); - // reserved for later + // if stat is hostile, positive to set it to hostile, + // negative to set it to peaceful + void apply_buff(const stat_name statn, const int amount); + // void apply_buff(const stat_name statn, const float mul); + // reserved for later protected: - RNG &rng; - const enum race race; + RNG &rng; + const enum race race; - int HP; + int HP; - // IMPORTANT: keep track of ATK and DEF in game at turn time - int ATK; - int DEF; + // IMPORTANT: keep track of ATK and DEF in game at turn time + int ATK; + int DEF; - position pos; + position pos; - int gold; // characters spawn with gold - potion_list potions;// inventory inventory; // Reserved + int gold; // characters spawn with gold + potion_list potions;// inventory inventory; // Reserved - float base_hit_rate; // requires: between [0,1] + float base_hit_rate; // requires: between [0,1] - bool hostile; + bool hostile; }; // requires: all elements of excluded are in sorted_positions position_list remove_from_list(const position_list &sorted_positions, position_list excluded); - int calc_dmg(const int ATK, const int DEF); #endif diff --git a/src/console_input.h b/src/console_input.h index 4ec4ffe..c2c9b46 100644 --- a/src/console_input.h +++ b/src/console_input.h @@ -6,11 +6,11 @@ class console_input final : public input { private: - std::istream ∈ + std::istream ∈ public: - // This is for cin - console_input(std::istream &cin); - game_command get_command() override; + // This is for cin + console_input(std::istream &cin); + game_command get_command() override; }; #endif diff --git a/src/console_output.cc b/src/console_output.cc index 91d89ae..2be7fef 100644 --- a/src/console_output.cc +++ b/src/console_output.cc @@ -4,7 +4,6 @@ #include #include - console_output::console_output(std::ostream &cout): out{cout} {} /* Attributes @@ -30,70 +29,70 @@ console_output::console_output(std::ostream &cout): out{cout} {} */ std::string console_output::get_code(const int attrs) { - if (attrs < 255) - return "\033[0m"; + if (attrs < 255) + return "\033[0m"; - std::string result = "\033[0m\033["; + std::string result = "\033[0m\033["; - if (attrs & A_BOLD) - result += "1;"; + if (attrs & A_BOLD) + result += "1;"; - if (attrs & A_UNDERLINE) - result += "4;"; + if (attrs & A_UNDERLINE) + result += "4;"; - if (attrs & A_STANDOUT) - result += "7;"; + if (attrs & A_STANDOUT) + result += "7;"; - if ((attrs & COLOR_PAIR(COLOR_WHITE)) == COLOR_PAIR(COLOR_WHITE)) - result += "37;"; - else if ((attrs & COLOR_PAIR(COLOR_CYAN)) == COLOR_PAIR(COLOR_CYAN)) - result += "36;"; - else if ((attrs & COLOR_PAIR(COLOR_MAGENTA)) == COLOR_PAIR(COLOR_MAGENTA)) - result += "35;"; - else if ((attrs & COLOR_PAIR(COLOR_BLUE)) == COLOR_PAIR(COLOR_BLUE)) - result += "34;"; - else if ((attrs & COLOR_PAIR(COLOR_YELLOW)) == COLOR_PAIR(COLOR_YELLOW)) - result += "33;"; - else if ((attrs & COLOR_PAIR(COLOR_RED)) == COLOR_PAIR(COLOR_RED)) - result += "31;"; - else if ((attrs & COLOR_PAIR(COLOR_GREEN)) == COLOR_PAIR(COLOR_GREEN)) - result += "32;"; - else if ((attrs & COLOR_PAIR(COLOR_BLACK_ON_WHITE)) == COLOR_BLACK_ON_WHITE) - result += "30;47;"; + if ((attrs & COLOR_PAIR(COLOR_WHITE)) == COLOR_PAIR(COLOR_WHITE)) + result += "37;"; + else if ((attrs & COLOR_PAIR(COLOR_CYAN)) == COLOR_PAIR(COLOR_CYAN)) + result += "36;"; + else if ((attrs & COLOR_PAIR(COLOR_MAGENTA)) == COLOR_PAIR(COLOR_MAGENTA)) + result += "35;"; + else if ((attrs & COLOR_PAIR(COLOR_BLUE)) == COLOR_PAIR(COLOR_BLUE)) + result += "34;"; + else if ((attrs & COLOR_PAIR(COLOR_YELLOW)) == COLOR_PAIR(COLOR_YELLOW)) + result += "33;"; + else if ((attrs & COLOR_PAIR(COLOR_RED)) == COLOR_PAIR(COLOR_RED)) + result += "31;"; + else if ((attrs & COLOR_PAIR(COLOR_GREEN)) == COLOR_PAIR(COLOR_GREEN)) + result += "32;"; + else if ((attrs & COLOR_PAIR(COLOR_BLACK_ON_WHITE)) == COLOR_BLACK_ON_WHITE) + result += "30;47;"; - result[result.length() - 1] = 'm'; - return result; + result[result.length() - 1] = 'm'; + return result; } void console_output::render() { - out << "\x1B[2J\x1B[H"; + out << "\x1B[2J\x1B[H"; - for (std::size_t idx = 0; idx < contents.size(); ++idx) { - if (idx % DISPLAY_WIDTH == 0 && idx) - out << std::endl; + for (std::size_t idx = 0; idx < contents.size(); ++idx) { + if (idx % DISPLAY_WIDTH == 0 && idx) + out << std::endl; - out << get_code(contents[idx]) - << (char)(contents[idx] ? contents[idx] : ' '); - } + out << get_code(contents[idx]) + << (char)(contents[idx] ? contents[idx] : ' '); + } - out << std::endl; + out << std::endl; } void console_output::print_char(const position &pos, const char ch, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - contents[pos.y * DISPLAY_WIDTH + pos.x] = attrs | ch; + contents[pos.y * DISPLAY_WIDTH + pos.x] = attrs | ch; } void console_output::print_str(const position &pos, const std::string &str, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - int head = pos.y * DISPLAY_WIDTH + pos.x; + int head = pos.y * DISPLAY_WIDTH + pos.x; - for (std::size_t i = 0; i < str.length(); ++i) - contents[i + head] = attrs | str[i]; + for (std::size_t i = 0; i < str.length(); ++i) + contents[i + head] = attrs | str[i]; } diff --git a/src/console_output.h b/src/console_output.h index 677d40b..91a8138 100644 --- a/src/console_output.h +++ b/src/console_output.h @@ -6,16 +6,16 @@ class console_output final : public display { private: - std::ostream &out; - std::string get_code(const int attrs); + std::ostream &out; + std::string get_code(const int attrs); public: - console_output(std::ostream &cout); + console_output(std::ostream &cout); - void render() override; - void print_char(const position &pos, - const char ch, const int attrs) override; - void print_str(const position &pos, - const std::string &str, const int attrs) override; + void render() override; + void print_char(const position &pos, + const char ch, const int attrs) override; + void print_str(const position &pos, + const std::string &str, const int attrs) override; }; #endif diff --git a/src/constants.h b/src/constants.h index f4316de..6f9b6f2 100644 --- a/src/constants.h +++ b/src/constants.h @@ -53,8 +53,6 @@ const int CALC_ADD_LATER = 2; const int CALC_MUL_LATER = 3; const int CALC_ADD_FIXED = 4; - - const int DIRECTION_CNT = 8; // IMPORTANT: east is positive for x and SOUTH is positive for y // initializes all directions to an int @@ -63,8 +61,8 @@ enum direction { north = 0, south, east, west, northeast, }; const position MOVE[DIRECTION_CNT] = { - {0, -1}, {0, 1}, {1, 0}, {-1, 0}, - {1, -1}, {-1, -1}, {1, 1}, {-1, 1} + {0, -1}, {0, 1}, {1, 0}, {-1, 0}, + {1, -1}, {-1, -1}, {1, 1}, {-1, 1} }; const int MAP_HEIGHT = 25; diff --git a/src/curses_input.cc b/src/curses_input.cc index 44319c3..7d077db 100644 --- a/src/curses_input.cc +++ b/src/curses_input.cc @@ -1,84 +1,84 @@ #include "curses_input.h" curses_input::curses_input(cursor &new_curse): - curse{new_curse} {} + curse{new_curse} {} game_command curses_input::get_command() { - switch (curse.getcmd()) { - case 'h': - return game_command::move_west; + switch (curse.getcmd()) { + case 'h': + return game_command::move_west; - case 'j': - return game_command::move_south; + case 'j': + return game_command::move_south; - case 'k': - return game_command::move_north; + case 'k': + return game_command::move_north; - case 'l': - return game_command::move_east; + case 'l': + return game_command::move_east; - case 'y': - return game_command::move_northwest; + case 'y': + return game_command::move_northwest; - case 'u': - return game_command::move_northeast; + case 'u': + return game_command::move_northeast; - case 'b': - return game_command::move_southwest; + case 'b': + return game_command::move_southwest; - case 'n': - return game_command::move_southeast; + case 'n': + return game_command::move_southeast; - case 'a': - break; // wait for another command + case 'a': + break; // wait for another command - case '<': - return game_command::up_stairs; + case '<': + return game_command::up_stairs; - case '>': - return game_command::down_stairs; + case '>': + return game_command::down_stairs; - case 'q': - return game_command_terminate; + case 'q': + return game_command_terminate; - case 'f': - return game_command::the_world; + case 'f': + return game_command::the_world; - case 'r': - return game_restart; + case 'r': + return game_restart; - default: - return game_command_pass; - } + default: + return game_command_pass; + } - switch (curse.getcmd()) { - case 'h': - return game_command::apply_west; + switch (curse.getcmd()) { + case 'h': + return game_command::apply_west; - case 'j': - return game_command::apply_south; + case 'j': + return game_command::apply_south; - case 'k': - return game_command::apply_north; + case 'k': + return game_command::apply_north; - case 'l': - return game_command::apply_east; + case 'l': + return game_command::apply_east; - case 'y': - return game_command::apply_northwest; + case 'y': + return game_command::apply_northwest; - case 'u': - return game_command::apply_northeast; + case 'u': + return game_command::apply_northeast; - case 'b': - return game_command::apply_southwest; + case 'b': + return game_command::apply_southwest; - case 'n': - return game_command::apply_southeast; + case 'n': + return game_command::apply_southeast; - default: - return game_command::apply_panic; - } + default: + return game_command::apply_panic; + } - return game_command::game_command_panic; + return game_command::game_command_panic; } diff --git a/src/curses_input.h b/src/curses_input.h index 0f7808a..c36e8df 100644 --- a/src/curses_input.h +++ b/src/curses_input.h @@ -8,10 +8,10 @@ class curses_input final: public input { private: - cursor &curse; + cursor &curse; public: - curses_input(cursor &new_curse); - game_command get_command() override; + curses_input(cursor &new_curse); + game_command get_command() override; }; #endif diff --git a/src/curses_output.cc b/src/curses_output.cc index ac4d8e8..c6e8205 100644 --- a/src/curses_output.cc +++ b/src/curses_output.cc @@ -1,36 +1,36 @@ #include "curses_output.h" curses_output::curses_output(cursor &new_curse): - curse{new_curse} {} + curse{new_curse} {} void curses_output::render() { - curse.show(); + curse.show(); } void curses_output::clear() { - curse.clear(); + curse.clear(); } void curses_output::print_char(const position &pos, const char ch, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - curse.print_char(pos, ch, attrs); + curse.print_char(pos, ch, attrs); } void curses_output::print_str(const position &pos, const std::string &str, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - position tmp = pos; + position tmp = pos; - for (std::size_t i = 0; i < str.length(); ++i) { - curse.print_char(tmp, str[i], attrs); - tmp += {1, 0}; + for (std::size_t i = 0; i < str.length(); ++i) { + curse.print_char(tmp, str[i], attrs); + tmp += {1, 0}; - if (tmp.x >= DISPLAY_WIDTH) - tmp = {0, tmp.y + 1}; - } + if (tmp.x >= DISPLAY_WIDTH) + tmp = {0, tmp.y + 1}; + } } diff --git a/src/curses_output.h b/src/curses_output.h index 7024ec6..09703f1 100644 --- a/src/curses_output.h +++ b/src/curses_output.h @@ -8,16 +8,16 @@ class curses_output final : public display { private: - cursor &curse; + cursor &curse; public: - curses_output(cursor &new_curse); + curses_output(cursor &new_curse); - void render() override; - void clear() override; - void print_char(const position &pos, - const char ch, const int attrs) override; - void print_str(const position &pos, - const std::string &str, const int attrs) override; + void render() override; + void clear() override; + void print_char(const position &pos, + const char ch, const int attrs) override; + void print_str(const position &pos, + const std::string &str, const int attrs) override; }; #endif diff --git a/src/cursor.cc b/src/cursor.cc index c3d04f8..fcf9bdf 100644 --- a/src/cursor.cc +++ b/src/cursor.cc @@ -2,53 +2,53 @@ #include "constants.h" cursor::cursor() { - initscr(); + initscr(); - if (has_colors()) { - start_color(); - init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK); - init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK); - init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK); - init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK); - init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK); - init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK); - init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK); - init_pair(COLOR_BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE); - } + if (has_colors()) { + start_color(); + init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK); + init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK); + init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK); + init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK); + init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK); + init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK); + init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK); + init_pair(COLOR_BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE); + } } cursor::~cursor() { - endwin(); + endwin(); } int cursor::getcmd() const { - return getch(); + return getch(); } void cursor::show() const { - refresh(); + refresh(); } void cursor::clear() const { - ::clear(); + ::clear(); } void cursor::print_char(const position &pos, const char ch, const int attrs) const { - attrset(attrs); - mvaddch(pos.y, pos.x, ch); + attrset(attrs); + mvaddch(pos.y, pos.x, ch); } void cursor::print_str(const position &pos, const std::string str, const int attrs) const { - attrset(attrs); - mvaddstr(pos.y, pos.x, str.c_str()); + attrset(attrs); + mvaddstr(pos.y, pos.x, str.c_str()); } bool check_terminal_size() { - int max_x; - int max_y; - getmaxyx(stdscr, max_y, max_x); + int max_x; + int max_y; + getmaxyx(stdscr, max_y, max_x); - return max_x >= DISPLAY_WIDTH && max_y >= DISPLAY_HEIGHT; + return max_x >= DISPLAY_WIDTH && max_y >= DISPLAY_HEIGHT; } diff --git a/src/cursor.h b/src/cursor.h index c0e064a..52fde78 100644 --- a/src/cursor.h +++ b/src/cursor.h @@ -37,20 +37,20 @@ class cursor final { private: public: - cursor(); + cursor(); - ~cursor(); + ~cursor(); - int getcmd() const; + int getcmd() const; - void show() const; + void show() const; - void clear() const ; + void clear() const ; - void print_char(const position &pos, const char ch, const int attrs) const; + void print_char(const position &pos, const char ch, const int attrs) const; - void print_str(const position &head, const std::string str, - const int attrs) const; + void print_str(const position &head, const std::string str, + const int attrs) const; }; // IMPORTANT: this will fail when terminal size changes diff --git a/src/display.cc b/src/display.cc index 4b9d63d..5fd0463 100644 --- a/src/display.cc +++ b/src/display.cc @@ -1,15 +1,15 @@ #include "display.h" display::display(): - contents{DISPLAY_BUFFER_SIZE, 0} { - for (int i = 0; i < DISPLAY_BUFFER_SIZE; ++i) - contents.push_back(0); + contents{DISPLAY_BUFFER_SIZE, 0} { + for (int i = 0; i < DISPLAY_BUFFER_SIZE; ++i) + contents.push_back(0); } void display::clear() { - contents.clear(); - contents.reserve(DISPLAY_BUFFER_SIZE); + contents.clear(); + contents.reserve(DISPLAY_BUFFER_SIZE); - for (int i = 0; i < DISPLAY_BUFFER_SIZE; ++i) - contents.push_back(0); + for (int i = 0; i < DISPLAY_BUFFER_SIZE; ++i) + contents.push_back(0); } diff --git a/src/display.h b/src/display.h index 1e1ad1d..9a4a4d5 100644 --- a/src/display.h +++ b/src/display.h @@ -8,28 +8,28 @@ class display { protected: - // use an array of ints to keep track of what's on the screen - // This will have a bit of buffer for the last line - // just in case it overflows - std::vector contents; + // use an array of ints to keep track of what's on the screen + // This will have a bit of buffer for the last line + // just in case it overflows + std::vector contents; public: - display(); + display(); - virtual ~display() = default; + virtual ~display() = default; - // Only call this to refresh the entire output - virtual void render() = 0; + // Only call this to refresh the entire output + virtual void render() = 0; - // Clears the contents buffer - virtual void clear(); + // Clears the contents buffer + virtual void clear(); - virtual void print_char(const position &pos, const char ch, - const int attrs = - A_NORMAL | COLOR_PAIR(COLOR_WHITE)) = 0; - virtual void print_str(const position &pos, const std::string &str, - const int attrs = - A_NORMAL | COLOR_PAIR(COLOR_WHITE)) = 0; - // default arguments are to be set in the base class's declaration + virtual void print_char(const position &pos, const char ch, + const int attrs = + A_NORMAL | COLOR_PAIR(COLOR_WHITE)) = 0; + virtual void print_str(const position &pos, const std::string &str, + const int attrs = + A_NORMAL | COLOR_PAIR(COLOR_WHITE)) = 0; + // default arguments are to be set in the base class's declaration }; #endif diff --git a/src/drow.cc b/src/drow.cc index 5158d1d..7d4090f 100644 --- a/src/drow.cc +++ b/src/drow.cc @@ -3,30 +3,30 @@ #include drow::drow(RNG &rng, const position_list &available_positions): - character{rng, race::rdrow} { - pos = available_positions[rng.rand_under(available_positions.size())]; - gold = 0; - hostile = true; + character{rng, race::rdrow} { + pos = available_positions[rng.rand_under(available_positions.size())]; + gold = 0; + hostile = true; } result drow::attack(const direction dir, character_list &chlist) { - position tmp{pos + MOVE[dir]}; + position tmp{pos + MOVE[dir]}; - for (auto &ch : chlist) - if (tmp == ch.get_position()) { - return ch.get_hit(race, ATK, base_hit_rate); - } + for (auto &ch : chlist) + if (tmp == ch.get_position()) { + return ch.get_hit(race, ATK, base_hit_rate); + } - return result::fine; + return result::fine; } result drow::get_hit(const enum race &race, const int atk, - const float hitrate) { - if (rng.rand_num() <= hitrate * (float)RAND_MAX) - HP = std::max(HP - calc_dmg(atk, DEF), 0); + const float hitrate) { + if (rng.rand_num() <= hitrate * (float)RAND_MAX) + HP = std::max(HP - calc_dmg(atk, DEF), 0); - if (HP == 0) - return result::died; + if (HP == 0) + return result::died; - return result::hit; + return result::hit; } diff --git a/src/drow.h b/src/drow.h index 9d5c1fd..35271c9 100644 --- a/src/drow.h +++ b/src/drow.h @@ -4,12 +4,12 @@ class drow final: public character { public: - drow(RNG &rng, - const position_list &available_positions); - virtual result attack(const direction dir, - character_list &chlist) override; - virtual result get_hit(const enum race &race, const int atk, - const float hit_rate) override; + drow(RNG &rng, + const position_list &available_positions); + virtual result attack(const direction dir, + character_list &chlist) override; + virtual result get_hit(const enum race &race, const int atk, + const float hit_rate) override; }; #endif diff --git a/src/file_input.cc b/src/file_input.cc index ba9a762..5cbfc86 100644 --- a/src/file_input.cc +++ b/src/file_input.cc @@ -3,40 +3,40 @@ #include file_input::file_input(std::ifstream &&ifs): - in{std::move(ifs)} {} + in{std::move(ifs)} {} game_command file_input::get_command() { - std::string cmd; + std::string cmd; + in >> cmd; + game_command tmp; + + if (in.eof()) + return game_command_terminate; + + if (cmd == "q") + return game_command_terminate; + else if (cmd == "f") + return the_world; + else if (cmd == "r") + return game_restart; + else if (cmd == "u" || cmd == "a") { + bool use = cmd == "u"; + in >> cmd; - game_command tmp; if (in.eof()) - return game_command_terminate; + return game_command_panic; - if (cmd == "q") - return game_command_terminate; - else if (cmd == "f") - return the_world; - else if (cmd == "r") - return game_restart; - else if (cmd == "u" || cmd == "a") { - bool use = cmd == "u"; + return (game_command)((tmp = get_direction(cmd)) == + game_command_panic + ? tmp : tmp - move_north + + (use ? apply_north : attack_north)); + } else { + auto tmp = get_direction(cmd); - in >> cmd; + if (tmp != game_command_panic) + return tmp; + } - if (in.eof()) - return game_command_panic; - - return (game_command)((tmp = get_direction(cmd)) == - game_command_panic - ? tmp : tmp - move_north + - (use ? apply_north : attack_north)); - } else { - auto tmp = get_direction(cmd); - - if (tmp != game_command_panic) - return tmp; - } - - return game_command_pass; + return game_command_pass; } diff --git a/src/file_input.h b/src/file_input.h index afcb220..b3b92f4 100644 --- a/src/file_input.h +++ b/src/file_input.h @@ -6,11 +6,11 @@ class file_input final : public input { private: - std::ifstream in; + std::ifstream in; public: - // This is for cin - file_input(std::ifstream &&ifs); - game_command get_command() override; + // This is for cin + file_input(std::ifstream &&ifs); + game_command get_command() override; }; #endif diff --git a/src/file_output.cc b/src/file_output.cc index 2dfce06..710b00a 100644 --- a/src/file_output.cc +++ b/src/file_output.cc @@ -3,34 +3,34 @@ #include file_output::file_output(std::ofstream &&ofs): - out{std::move(ofs)} {} + out{std::move(ofs)} {} void file_output::render() { - for (std::size_t idx = 0; idx < contents.size(); ++idx) { - if (idx % DISPLAY_WIDTH == 0 && idx) - out << std::endl; + for (std::size_t idx = 0; idx < contents.size(); ++idx) { + if (idx % DISPLAY_WIDTH == 0 && idx) + out << std::endl; - out << (char)(contents[idx] ? contents[idx] : ' '); - } + out << (char)(contents[idx] ? contents[idx] : ' '); + } - out << std::endl; + out << std::endl; } void file_output::print_char(const position &pos, const char ch, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - contents[pos.y * DISPLAY_WIDTH + pos.x] = ch; + contents[pos.y * DISPLAY_WIDTH + pos.x] = ch; } void file_output::print_str(const position &pos, const std::string &str, const int attrs) { - if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) - return; + if (pos.x >= DISPLAY_WIDTH || pos.y >= DISPLAY_HEIGHT) + return; - int head = pos.y * DISPLAY_WIDTH + pos.x; + int head = pos.y * DISPLAY_WIDTH + pos.x; - for (std::size_t i = 0; i < str.length(); ++i) - contents[i + head] = str[i]; + for (std::size_t i = 0; i < str.length(); ++i) + contents[i + head] = str[i]; } diff --git a/src/file_output.h b/src/file_output.h index a6ef81e..8acf522 100644 --- a/src/file_output.h +++ b/src/file_output.h @@ -6,15 +6,15 @@ class file_output final : public display { private: - std::ofstream out; + std::ofstream out; public: - file_output(std::ofstream &&ofs); + file_output(std::ofstream &&ofs); - void render() override; - void print_char(const position &pos, - const char ch, const int attrs) override; - void print_str(const position &pos, - const std::string &str, const int attrs) override; + void render() override; + void print_char(const position &pos, + const char ch, const int attrs) override; + void print_str(const position &pos, + const std::string &str, const int attrs) override; }; #endif diff --git a/src/fraction.cc b/src/fraction.cc index e7c1b57..5dfbab2 100644 --- a/src/fraction.cc +++ b/src/fraction.cc @@ -1,44 +1,44 @@ #include "fraction.h" fraction fraction::operator+(const fraction &frac) { - fraction tmp = *this; - tmp.numerator = tmp.numerator * frac.denominator + - tmp.denominator * frac.numerator; - tmp.denominator = tmp.denominator * frac.denominator; - return tmp.simplify(); + fraction tmp = *this; + tmp.numerator = tmp.numerator * frac.denominator + + tmp.denominator * frac.numerator; + tmp.denominator = tmp.denominator * frac.denominator; + return tmp.simplify(); } fraction fraction::operator*(const fraction &frac) { - fraction tmp = *this; - tmp.numerator = tmp.numerator * frac.numerator; - tmp.denominator = tmp.denominator * frac.denominator; - return tmp.simplify(); + fraction tmp = *this; + tmp.numerator = tmp.numerator * frac.numerator; + tmp.denominator = tmp.denominator * frac.denominator; + return tmp.simplify(); } bool fraction::operator==(const fraction &frac) { - this->simplify(); - return gcd(frac.numerator, this->numerator) == this->numerator && - gcd(frac.denominator, this->denominator) == this->denominator; + this->simplify(); + return gcd(frac.numerator, this->numerator) == this->numerator && + gcd(frac.denominator, this->denominator) == this->denominator; } bool fraction::operator!=(const fraction &frac) { - return !(*this == frac); + return !(*this == frac); } fraction &fraction::simplify() { - int g = gcd(numerator, denominator); - numerator /= g; - denominator /= g; - return *this; + int g = gcd(numerator, denominator); + numerator /= g; + denominator /= g; + return *this; } float fraction::real() { - return (float)numerator / denominator; + return (float)numerator / denominator; } int fraction::gcd(int a, int b) { - if (a % b == 0) - return b; + if (a % b == 0) + return b; - return gcd(b, a % b); + return gcd(b, a % b); } diff --git a/src/fraction.h b/src/fraction.h index 59cd82c..ae61b36 100644 --- a/src/fraction.h +++ b/src/fraction.h @@ -2,17 +2,17 @@ #define __FRACTION_H__ struct fraction final { - int numerator; - int denominator; + int numerator; + int denominator; - fraction operator+(const fraction &frac); - fraction operator*(const fraction &frac); - bool operator==(const fraction &frac); - bool operator!=(const fraction &frac); - fraction &simplify(); - float real(); + fraction operator+(const fraction &frac); + fraction operator*(const fraction &frac); + bool operator==(const fraction &frac); + bool operator!=(const fraction &frac); + fraction &simplify(); + float real(); private: - int gcd(int a, int b); + int gcd(int a, int b); }; #endif diff --git a/src/game.h b/src/game.h index e7318ec..0b87547 100644 --- a/src/game.h +++ b/src/game.h @@ -12,21 +12,21 @@ class game final { private: - feature features; - input ∈ - display &out; - logger &log; - RNG &rng; - std::unique_ptr player; + feature features; + input ∈ + display &out; + logger &log; + RNG &rng; + std::unique_ptr player; public: - game(const feature enabled_features, - input &new_in, - display &new_out, - logger &new_log, - RNG &new_rng); - game_status run(); + game(const feature enabled_features, + input &new_in, + display &new_out, + logger &new_log, + RNG &new_rng); + game_status run(); private: - int getcmd() const; + int getcmd() const; }; #endif diff --git a/src/goblin.cc b/src/goblin.cc index 5431227..ae6c958 100644 --- a/src/goblin.cc +++ b/src/goblin.cc @@ -3,36 +3,36 @@ #include goblin::goblin(RNG &rng, const position_list &available_positions): - character{rng, race::rshade} { - pos = available_positions[rng.rand_under(available_positions.size())]; - gold = 0; - hostile = true; + character{rng, race::rshade} { + pos = available_positions[rng.rand_under(available_positions.size())]; + gold = 0; + hostile = true; } result goblin::attack(const direction dir, character_list &chlist) { - position tmp{pos + MOVE[dir]}; + position tmp{pos + MOVE[dir]}; - for (auto &ch : chlist) - if (tmp == ch.get_position()) { - auto res = ch.get_hit(race, ATK, base_hit_rate); + for (auto &ch : chlist) + if (tmp == ch.get_position()) { + auto res = ch.get_hit(race, ATK, base_hit_rate); - if (res == result::died) { - gold += GAIN_GOLD; - } + if (res == result::died) { + gold += GAIN_GOLD; + } - return res; - } + return res; + } - return result::fine; + return result::fine; } result goblin::get_hit(const enum race &race, const int atk, const float hitrate) { - if (rng.rand_num() <= hitrate * (float)RAND_MAX) - HP = std::max(HP - calc_dmg(atk, DEF), 0); + if (rng.rand_num() <= hitrate * (float)RAND_MAX) + HP = std::max(HP - calc_dmg(atk, DEF), 0); - if (HP == 0) - return result::died; + if (HP == 0) + return result::died; - return result::hit; + return result::hit; } diff --git a/src/goblin.h b/src/goblin.h index 9f85e84..97d2e7a 100644 --- a/src/goblin.h +++ b/src/goblin.h @@ -6,12 +6,12 @@ const int GAIN_GOLD = 5; class goblin final: public character { public: - goblin(RNG &rng, - const position_list &available_positions); - virtual result attack(const direction dir, - character_list &chlist) override; - virtual result get_hit(const enum race &race, const int atk, - const float hit_rate) override; + goblin(RNG &rng, + const position_list &available_positions); + virtual result attack(const direction dir, + character_list &chlist) override; + virtual result get_hit(const enum race &race, const int atk, + const float hit_rate) override; }; #endif diff --git a/src/input.cc b/src/input.cc index 2336630..59f0368 100644 --- a/src/input.cc +++ b/src/input.cc @@ -1,15 +1,14 @@ #include "input.h" - const char *COMMANDS[] = { - "no", "so", "ea", "we", "ne", "nw", "se", "sw" + "no", "so", "ea", "we", "ne", "nw", "se", "sw" }; const int COMMANDS_CNT = 8; game_command get_direction(std::string &str) { - for (int i = 0; i < COMMANDS_CNT; ++i) - if (str == COMMANDS[i]) - return (game_command)i; + for (int i = 0; i < COMMANDS_CNT; ++i) + if (str == COMMANDS[i]) + return (game_command)i; - return game_command_panic; + return game_command_panic; } diff --git a/src/input.h b/src/input.h index 8fd5d97..aa9d120 100644 --- a/src/input.h +++ b/src/input.h @@ -5,8 +5,8 @@ class input { public: - virtual ~input() = default; - virtual game_command get_command() = 0; + virtual ~input() = default; + virtual game_command get_command() = 0; }; game_command get_direction(std::string &str); diff --git a/src/log.cc b/src/log.cc index a990d9f..fe31d0b 100644 --- a/src/log.cc +++ b/src/log.cc @@ -3,7 +3,7 @@ #include logger::logger(std::ofstream &&new_out): - out{std::move(new_out)} {} + out{std::move(new_out)} {} void logger::render() { diff --git a/src/log.h b/src/log.h index 3b03754..887dcd7 100644 --- a/src/log.h +++ b/src/log.h @@ -9,20 +9,20 @@ class logger final { private: - std::ofstream out; - std::vector contents; + std::ofstream out; + std::vector contents; public: - logger(std::ofstream &&new_out); + logger(std::ofstream &&new_out); - // called once every turn - void render(); - void print_char(const position &pos, const char ch); - void print_str(const position &pos, const std::string &str); - void print_turn(const unsigned turn); - void print_player(const character &player); - void print_chlist(const character_list &chlist); - void print_gold(const gold_list &gold_piles); - void print_potions(const potion_list &potions); + // called once every turn + void render(); + void print_char(const position &pos, const char ch); + void print_str(const position &pos, const std::string &str); + void print_turn(const unsigned turn); + void print_player(const character &player); + void print_chlist(const character_list &chlist); + void print_gold(const gold_list &gold_piles); + void print_potions(const potion_list &potions); }; #endif diff --git a/src/main.cc b/src/main.cc index dec8057..a1a9ff3 100644 --- a/src/main.cc +++ b/src/main.cc @@ -2,27 +2,26 @@ #include "arguments.h" int main(int argc, char **argv) { - std::unique_ptr curse; - std::unique_ptr in; - std::unique_ptr out; - std::unique_ptr log; - std::unique_ptr rng; + std::unique_ptr curse; + std::unique_ptr in; + std::unique_ptr out; + std::unique_ptr log; + std::unique_ptr rng; + feature enabled_features = proc_args(argc, argv, + curse, in, out, log, rng); - feature enabled_features = proc_args(argc, argv, - curse, in, out, log, rng); - - if (enabled_features & + if (enabled_features & (FEATURE_PANIC | FEATURE_PANIC_FILE | FEATURE_CONFLICT | FEATURE_PANIC_SEED)) { - panic_args(enabled_features); - return RETURN_PANICKED; - } + panic_args(enabled_features); + return RETURN_PANICKED; + } - game game_proc(enabled_features, *in, *out, *log, *rng); + game game_proc(enabled_features, *in, *out, *log, *rng); - while (game_proc.run() != game_status::terminated) - out->render(); + while (game_proc.run() != game_status::terminated) + out->render(); - return RETURN_FINE; + return RETURN_FINE; } diff --git a/src/map.cc b/src/map.cc index d9827cd..5e8628d 100644 --- a/src/map.cc +++ b/src/map.cc @@ -6,63 +6,63 @@ #include game_map::game_map(int lvl) { - level = lvl; - // TODO: randomly generate a map + level = lvl; + // TODO: randomly generate a map } game_map::game_map(const std::string &map_data, int lvl) { - level = lvl; - std::istringstream iss{map_data}; + level = lvl; + std::istringstream iss{map_data}; - std::string line; + std::string line; - for (int i = 0; i < MAP_HEIGHT; ++i) { - getline(iss, line); - map[i] = line; - } + for (int i = 0; i < MAP_HEIGHT; ++i) { + getline(iss, line); + map[i] = line; + } } game_map::~game_map() {} int game_map::get_level() const { - return this->level; + return this->level; } std::vector game_map::get_available_positions() const { - std::vector result; + std::vector result; - for (int line = 0; line < MAP_HEIGHT; ++line) - for (int x = 0; x < MAP_WIDTH; ++x) - if (map[line][x] == '.' || - map[line][x] == '#' || - map[line][x] == '+') - result.push_back(position{x, line}); - return result; + for (int line = 0; line < MAP_HEIGHT; ++line) + for (int x = 0; x < MAP_WIDTH; ++x) + if (map[line][x] == '.' || + map[line][x] == '#' || + map[line][x] == '+') + result.push_back(position{x, line}); + return result; } void game_map::print() const { - // TODO: write a print function using ncurses + // TODO: write a print function using ncurses } void game_map::print(display &display) const { - for (int i = 0; i < MAP_HEIGHT; ++i) - display.print_str(position{0, i}, map[i]); + for (int i = 0; i < MAP_HEIGHT; ++i) + display.print_str(position{0, i}, map[i]); } void game_map::apply_potion(character *who, const stat_name statn, const int amount) { - effects.push_back(effect{who, statn, amount}); - who->apply_buff(statn, amount); + effects.push_back(effect{who, statn, amount}); + who->apply_buff(statn, amount); } void game_map::enter_level(character *who) { - for (auto eff : effects) - if (eff.who == who) - who->apply_buff(eff.statn, eff.amount); + for (auto eff : effects) + if (eff.who == who) + who->apply_buff(eff.statn, eff.amount); } void game_map::leave_level(character *who) { - who->set_ATK(STARTING_ATK[who->get_race()]); - who->set_DEF(STARTING_DEF[who->get_race()]); + who->set_ATK(STARTING_ATK[who->get_race()]); + who->set_DEF(STARTING_DEF[who->get_race()]); } diff --git a/src/map.h b/src/map.h index 58fe7c2..501ae0a 100644 --- a/src/map.h +++ b/src/map.h @@ -15,46 +15,46 @@ class game_map final { public: - game_map(int lvl = 0); // randomly generate one - // initialize using stored data - game_map(const std::string &map_data, int lvl); - ~game_map(); // placeholder + game_map(int lvl = 0); // randomly generate one + // initialize using stored data + game_map(const std::string &map_data, int lvl); + ~game_map(); // placeholder - int get_level() const; + int get_level() const; - position_list get_available_positions() const; + position_list get_available_positions() const; - // IMPORTANT: always print a map before anything else + // IMPORTANT: always print a map before anything else - // prints using ncurses - void print() const; + // prints using ncurses + void print() const; - // prints to a string - void print(display &display) const; + // prints to a string + void print(display &display) const; - // This is implemented this way to do two things: - // 1. avoid directly accessing heap memory (bonus points) - // 2. make a level revisitable - void apply_potion(character *who, const stat_name statn, const int amount); + // This is implemented this way to do two things: + // 1. avoid directly accessing heap memory (bonus points) + // 2. make a level revisitable + void apply_potion(character *who, const stat_name statn, const int amount); - // just in case you want to retain the potion effects - void enter_level(character *who); - void leave_level(character *who); + // just in case you want to retain the potion effects + void enter_level(character *who); + void leave_level(character *who); public: - struct effect { - character *who; - stat_name statn; - int amount; - }; + struct effect { + character *who; + stat_name statn; + int amount; + }; - std::string map[MAP_HEIGHT]; - int level; + std::string map[MAP_HEIGHT]; + int level; - // use this to remember every applied potion - std::vector effects; + // use this to remember every applied potion + std::vector effects; }; const std::string default_map = - "|-----------------------------------------------------------------------------|\n| |\n| |--------------------------| |-----------------------| |\n| |..........................| |.......................| |\n| |..........................+########+.......................|-------| |\n| |..........................| # |...............................|--| |\n| |..........................| # |..................................|--| |\n| |----------+---------------| # |----+----------------|...............| |\n| # ############# |...............| |\n| # # |-----+------| |...............| |\n| # # |............| |...............| |\n| ################### |............| ######+...............| |\n| # # |............| # |...............| |\n| # # |-----+------| # |--------+------| |\n| |---------+-----------| # # # # |\n| |.....................| # # # |----+------| |\n| |.....................| ######################## |...........| |\n| |.....................| # # |...........| |\n| |.....................| # |------+--------------------|...........| |\n| |.....................| # |.......................................| |\n| |.....................+##########+.......................................| |\n| |.....................| |.......................................| |\n| |---------------------| |---------------------------------------| |\n| |\n|-----------------------------------------------------------------------------|"; + "|-----------------------------------------------------------------------------|\n| |\n| |--------------------------| |-----------------------| |\n| |..........................| |.......................| |\n| |..........................+########+.......................|-------| |\n| |..........................| # |...............................|--| |\n| |..........................| # |..................................|--| |\n| |----------+---------------| # |----+----------------|...............| |\n| # ############# |...............| |\n| # # |-----+------| |...............| |\n| # # |............| |...............| |\n| ################### |............| ######+...............| |\n| # # |............| # |...............| |\n| # # |-----+------| # |--------+------| |\n| |---------+-----------| # # # # |\n| |.....................| # # # |----+------| |\n| |.....................| ######################## |...........| |\n| |.....................| # # |...........| |\n| |.....................| # |------+--------------------|...........| |\n| |.....................| # |.......................................| |\n| |.....................+##########+.......................................| |\n| |.....................| |.......................................| |\n| |---------------------| |---------------------------------------| |\n| |\n|-----------------------------------------------------------------------------|"; #endif diff --git a/src/poison_health.cc b/src/poison_health.cc index 6b49fc0..b8401e9 100644 --- a/src/poison_health.cc +++ b/src/poison_health.cc @@ -3,20 +3,20 @@ #include poison_health::poison_health(): - potion{potion_type::poison_health, 1} {} + potion{potion_type::poison_health, 1} {} void poison_health::apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - HP = std::max(HP - 7, 0); - else - HP = std::max(HP - 5, 0); + float &base_hit_rate) { + if (remaining_duration > 0) { + if (race == rdrow) + HP = std::max(HP - 7, 0); + else + HP = std::max(HP - 5, 0); - --remaining_duration; - } + --remaining_duration; + } } int poison_health::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } diff --git a/src/poison_health.h b/src/poison_health.h index 49263fd..5242bf2 100644 --- a/src/poison_health.h +++ b/src/poison_health.h @@ -5,10 +5,10 @@ class poison_health final: public potion { public: - poison_health(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + poison_health(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif diff --git a/src/position.cc b/src/position.cc index 63609e5..57437c3 100644 --- a/src/position.cc +++ b/src/position.cc @@ -5,41 +5,41 @@ position::position(): x{0}, y{0} {} position::position(int nx, int ny): x{nx}, y{ny} {} position position::operator+(const position &other) const { - position result{x + other.x, y + other.y}; - return result; + position result{x + other.x, y + other.y}; + return result; } position &position::operator=(const position &other) { - x = other.x; - y = other.y; - return *this; + x = other.x; + y = other.y; + return *this; } position &position::operator+=(const position &other) { - return *this = *this + other; + return *this = *this + other; } bool position::operator==(const position &other) const { - return x == other.x && y == other.y; + return x == other.x && y == other.y; } bool position::operator!=(const position &other) const { - return x != other.x || y != other.y; + return x != other.x || y != other.y; } bool position::operator<(const position &other) const { - return y < other.y || x < other.x; + return y < other.y || x < other.x; } #include size_t find(const std::vector &sorted_list, const position &target) { - // TODO: implement binary searching + // TODO: implement binary searching - for (size_t i = 0; i < sorted_list.size(); ++i) - if (sorted_list[i] == target) - return i; + for (size_t i = 0; i < sorted_list.size(); ++i) + if (sorted_list[i] == target) + return i; - return sorted_list.size(); + return sorted_list.size(); } diff --git a/src/position.h b/src/position.h index 6d794a5..1d5e383 100644 --- a/src/position.h +++ b/src/position.h @@ -9,18 +9,18 @@ #include typedef struct position { - int x; - int y; + int x; + int y; - position(); - position(int nx, int ny); + position(); + position(int nx, int ny); - position operator+(const position &other) const; - position &operator=(const position &other); - position &operator+=(const position &other); - bool operator==(const position &other) const; - bool operator!=(const position &other) const; - bool operator<(const position &other) const; + position operator+(const position &other) const; + position &operator=(const position &other); + position &operator+=(const position &other); + bool operator==(const position &other) const; + bool operator!=(const position &other) const; + bool operator<(const position &other) const; } position; std::size_t find(const std::vector &sorted_list, diff --git a/src/potion.cc b/src/potion.cc index 2f9fab6..14e523b 100644 --- a/src/potion.cc +++ b/src/potion.cc @@ -1,12 +1,12 @@ #include "potion.h" potion::potion(const potion_type type, const int duration): - type{type}, remaining_duration{duration} {} + type{type}, remaining_duration{duration} {} potion_type potion::get_type() const { - return type; + return type; } int potion::get_duration() const { - return remaining_duration; + return remaining_duration; } diff --git a/src/potion.h b/src/potion.h index 00396bb..d11f7a5 100644 --- a/src/potion.h +++ b/src/potion.h @@ -9,20 +9,20 @@ class potion { protected: - // Use -1 to denote that the effect will last until leaving the level - // Otherwise, use a positive number - // Single use potions have a starting duration of 1 - const potion_type type; - int remaining_duration; + // Use -1 to denote that the effect will last until leaving the level + // Otherwise, use a positive number + // Single use potions have a starting duration of 1 + const potion_type type; + int remaining_duration; public: - potion(const potion_type type, const int duration); - // apply decrements remaining_duration if it's positive, and - // won't do anything if it's non-negative - virtual void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) = 0; - virtual int get_priority() const = 0; - potion_type get_type() const; - int get_duration() const; + potion(const potion_type type, const int duration); + // apply decrements remaining_duration if it's positive, and + // won't do anything if it's non-negative + virtual void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) = 0; + virtual int get_priority() const = 0; + potion_type get_type() const; + int get_duration() const; }; typedef std::vector potion_list; diff --git a/src/restore_health.cc b/src/restore_health.cc index 961708c..de08bcf 100644 --- a/src/restore_health.cc +++ b/src/restore_health.cc @@ -3,20 +3,20 @@ #include restore_health::restore_health(): - potion{potion_type::restore_health, 1} {} + potion{potion_type::restore_health, 1} {} void restore_health::apply(enum race &race, int &HP, int &ATK, int &DEF, float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - HP = std::min(HP + 7, MAX_HP[race]); - else - HP = std::min(HP + 5, MAX_HP[race]); + if (remaining_duration > 0) { + if (race == rdrow) + HP = std::min(HP + 7, MAX_HP[race]); + else + HP = std::min(HP + 5, MAX_HP[race]); - --remaining_duration; - } + --remaining_duration; + } } int restore_health::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } diff --git a/src/restore_health.h b/src/restore_health.h index 1e7a594..a1b0b39 100644 --- a/src/restore_health.h +++ b/src/restore_health.h @@ -5,10 +5,10 @@ class restore_health final: public potion { public: - restore_health(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + restore_health(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif diff --git a/src/rng.cc b/src/rng.cc index 2cd54bb..e2610a0 100644 --- a/src/rng.cc +++ b/src/rng.cc @@ -1,43 +1,43 @@ #include "rng.h" RNG::RNG(): init_seed(time(0)), curr_rand_num(0) { - srand(init_seed); + srand(init_seed); } RNG::RNG(const unsigned int seed): init_seed(seed), curr_rand_num(0) { - srand(init_seed); + srand(init_seed); } int RNG::rand_num() { - return curr_rand_num = rand(); + return curr_rand_num = rand(); } int RNG::rand_between(const int lower_bound, const int upper_bound) { - curr_rand_num = rand(); + curr_rand_num = rand(); - return lower_bound + (curr_rand_num % (upper_bound - lower_bound)); + return lower_bound + (curr_rand_num % (upper_bound - lower_bound)); } int RNG::rand_under(const int upper_bound) { - curr_rand_num = rand(); + curr_rand_num = rand(); - return curr_rand_num % upper_bound; + return curr_rand_num % upper_bound; } unsigned int RNG::get_init_seed() const { - return init_seed; + return init_seed; } int RNG::get_curr_rand_num() const { - return curr_rand_num; + return curr_rand_num; } bool RNG::trial(fraction &psuccess) { - return (rand() % psuccess.denominator) < psuccess.numerator; + return (rand() % psuccess.denominator) < psuccess.numerator; } template T &RNG::get_rand_in_vector(const std::vector &vec) { - curr_rand_num = rand(); + curr_rand_num = rand(); - return vec[curr_rand_num % vec.size()]; + return vec[curr_rand_num % vec.size()]; } diff --git a/src/rng.h b/src/rng.h index 037d6bb..f86b4d7 100644 --- a/src/rng.h +++ b/src/rng.h @@ -11,24 +11,24 @@ // IMPORTANT: pass all RNG objects as references class RNG final { private: - const unsigned int init_seed; - int curr_rand_num; + const unsigned int init_seed; + int curr_rand_num; public: - RNG(); // use time(0) as the seed - RNG(const unsigned int seed); // use a seed + RNG(); // use time(0) as the seed + RNG(const unsigned int seed); // use a seed - int rand_num(); // returns a random number between 0 and RAND_MAX + int rand_num(); // returns a random number between 0 and RAND_MAX - // IMPORTANT: all upper bounds are not included, all lower bounds are - int rand_between(const int lower_bound, const int upper_bound); - // returns a random number between 0 and upper_bound - int rand_under(const int upper_bound); - unsigned int get_init_seed() const; - int get_curr_rand_num() const; + // IMPORTANT: all upper bounds are not included, all lower bounds are + int rand_between(const int lower_bound, const int upper_bound); + // returns a random number between 0 and upper_bound + int rand_under(const int upper_bound); + unsigned int get_init_seed() const; + int get_curr_rand_num() const; - bool trial(fraction &psuccess); + bool trial(fraction &psuccess); - template T &get_rand_in_vector(const std::vector &vec); + template T &get_rand_in_vector(const std::vector &vec); }; #endif diff --git a/src/room.h b/src/room.h index f0a7b58..1c4196e 100644 --- a/src/room.h +++ b/src/room.h @@ -1,6 +1,4 @@ #ifndef __ROOM_H__ #define __ROOM_H__ - - #endif diff --git a/src/shade.cc b/src/shade.cc index 1e915fe..52527d5 100644 --- a/src/shade.cc +++ b/src/shade.cc @@ -4,31 +4,30 @@ #include shade::shade(RNG &rng, const position_list &available_positions): - character{rng, race::rshade} { - pos = available_positions[rng.rand_under(available_positions.size())]; - gold = 0; - hostile = true; + character{rng, race::rshade} { + pos = available_positions[rng.rand_under(available_positions.size())]; + gold = 0; + hostile = true; } result shade::attack(const direction dir, character_list &chlist) { - position tmp{pos + MOVE[dir]}; + position tmp{pos + MOVE[dir]}; - for (auto &ch : chlist) - if (tmp == ch.get_position()) { - return ch.get_hit(race, ATK, base_hit_rate); - } + for (auto &ch : chlist) + if (tmp == ch.get_position()) { + return ch.get_hit(race, ATK, base_hit_rate); + } - return result::fine; + return result::fine; } result shade::get_hit(const enum race &race, const int atk, const float hitrate) { - if (rng.rand_num() <= hitrate * (float)RAND_MAX) // This is a hit! - HP = std::max(HP - calc_dmg(atk, DEF), 0); + if (rng.rand_num() <= hitrate * (float)RAND_MAX) // This is a hit! + HP = std::max(HP - calc_dmg(atk, DEF), 0); - if (HP == 0) - return result::died; + if (HP == 0) + return result::died; - return result::hit; + return result::hit; } - diff --git a/src/shade.h b/src/shade.h index 838d437..bfff903 100644 --- a/src/shade.h +++ b/src/shade.h @@ -5,12 +5,12 @@ class shade final: public character { public: - shade(RNG &rng, const position_list - &available_positions); // spawn at a random place - virtual result attack(const direction dir, - character_list &chlist) override; - virtual result get_hit(const enum race &race, const int atk, - const float hit_rate) override; + shade(RNG &rng, const position_list + &available_positions); // spawn at a random place + virtual result attack(const direction dir, + character_list &chlist) override; + virtual result get_hit(const enum race &race, const int atk, + const float hit_rate) override; }; #endif diff --git a/src/vampire.cc b/src/vampire.cc index 79bfd94..60498e9 100644 --- a/src/vampire.cc +++ b/src/vampire.cc @@ -3,36 +3,36 @@ #include vampire::vampire(RNG &rng, const position_list &available_positions): - character{rng, race::rvampire} { - pos = available_positions[rng.rand_under(available_positions.size())]; - gold = 0; - hostile = true; + character{rng, race::rvampire} { + pos = available_positions[rng.rand_under(available_positions.size())]; + gold = 0; + hostile = true; } result vampire::attack(const direction dir, character_list &chlist) { - position tmp{pos + MOVE[dir]}; + position tmp{pos + MOVE[dir]}; - for (auto &ch : chlist) - if (tmp == ch.get_position()) { - auto res = ch.get_hit(race, ATK, base_hit_rate); + for (auto &ch : chlist) + if (tmp == ch.get_position()) { + auto res = ch.get_hit(race, ATK, base_hit_rate); - if (res != result::miss) { - HP += GAIN_HP; - } + if (res != result::miss) { + HP += GAIN_HP; + } - return res; - } + return res; + } - return result::fine; + return result::fine; } result vampire::get_hit(const enum race &race, const int atk, const float hitrate) { - if (rng.rand_num() <= hitrate * (float)RAND_MAX) - HP = std::max(HP - calc_dmg(atk, DEF), 0); + if (rng.rand_num() <= hitrate * (float)RAND_MAX) + HP = std::max(HP - calc_dmg(atk, DEF), 0); - if (HP == 0) - return result::died; + if (HP == 0) + return result::died; - return result::hit; + return result::hit; } diff --git a/src/vampire.h b/src/vampire.h index 04a89de..e44e572 100644 --- a/src/vampire.h +++ b/src/vampire.h @@ -6,12 +6,12 @@ const int GAIN_HP = 5; class vampire final: public character { public: - vampire(RNG &rng, - const position_list &available_positions); - virtual result attack(const direction dir, - character_list &chlist) override; - virtual result get_hit(const enum race &race, const int atk, - const float hit_rate) override; + vampire(RNG &rng, + const position_list &available_positions); + virtual result attack(const direction dir, + character_list &chlist) override; + virtual result get_hit(const enum race &race, const int atk, + const float hit_rate) override; }; #endif diff --git a/src/wound_atk.cc b/src/wound_atk.cc index 9a0af32..60d9d34 100644 --- a/src/wound_atk.cc +++ b/src/wound_atk.cc @@ -6,21 +6,20 @@ const int WOUND_ATK = 5; const int WOUND_ATK_DROW = 7; wound_atk::wound_atk(): - potion{potion_type::wound_atk, -1} {} + potion{potion_type::wound_atk, -1} {} void wound_atk::apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - ATK = std::max(ATK - WOUND_ATK_DROW, 0); - else - ATK = std::max(ATK - WOUND_ATK, 0); + float &base_hit_rate) { + if (remaining_duration > 0) { + if (race == rdrow) + ATK = std::max(ATK - WOUND_ATK_DROW, 0); + else + ATK = std::max(ATK - WOUND_ATK, 0); - --remaining_duration; - } + --remaining_duration; + } } int wound_atk::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } - diff --git a/src/wound_atk.h b/src/wound_atk.h index bf1bdb6..81890be 100644 --- a/src/wound_atk.h +++ b/src/wound_atk.h @@ -5,10 +5,10 @@ class wound_atk final: public potion { public: - wound_atk(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + wound_atk(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif diff --git a/src/wound_def.cc b/src/wound_def.cc index 7025361..1916e11 100644 --- a/src/wound_def.cc +++ b/src/wound_def.cc @@ -6,20 +6,20 @@ const int WOUND_DEF = 5; const int WOUND_DEF_DROW = 7; wound_def::wound_def(): - potion{potion_type::wound_def, -1} {} + potion{potion_type::wound_def, -1} {} void wound_def::apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) { - if (remaining_duration > 0) { - if (race == rdrow) - DEF = std::max(DEF - WOUND_DEF_DROW, 0); - else - DEF = std::max(DEF - WOUND_DEF, 0); + float &base_hit_rate) { + if (remaining_duration > 0) { + if (race == rdrow) + DEF = std::max(DEF - WOUND_DEF_DROW, 0); + else + DEF = std::max(DEF - WOUND_DEF, 0); - --remaining_duration; - } + --remaining_duration; + } } int wound_def::get_priority() const { - return CALC_ADD_BASE; + return CALC_ADD_BASE; } diff --git a/src/wound_def.h b/src/wound_def.h index 2f40cf0..7d22f68 100644 --- a/src/wound_def.h +++ b/src/wound_def.h @@ -5,10 +5,10 @@ class wound_def final: public potion { public: - wound_def(); - void apply(enum race &race, int &HP, int &ATK, int &DEF, - float &base_hit_rate) override; - int get_priority() const override; + wound_def(); + void apply(enum race &race, int &HP, int &ATK, int &DEF, + float &base_hit_rate) override; + int get_priority() const override; }; #endif