298 lines
9.4 KiB
C++
298 lines
9.4 KiB
C++
#include "game.h"
|
|
|
|
#include "races.h"
|
|
|
|
game::game(const enum race starting_race,
|
|
const feature enabled_features,
|
|
input *new_in,
|
|
display *new_out,
|
|
logger *new_log,
|
|
RNG *new_rng):
|
|
enabled_features{enabled_features},
|
|
in{new_in}, out{new_out}, log{new_log}, rng{new_rng},
|
|
curr_turn{0} {
|
|
const position nil{0, 0};
|
|
the_world = false;
|
|
|
|
// TODO: add the other races
|
|
switch (starting_race) {
|
|
case race::rshade:
|
|
player = std::make_unique<shade>(rng, nil);
|
|
break;
|
|
}
|
|
|
|
if (enabled_features & FEATURE_EXTRA_LEVELS)
|
|
max_level = rng->rand_between(MIN_LEVEL_CNT, MAX_LEVEL_CNT + 1);
|
|
else
|
|
max_level = DEFAULT_MAX_LEVEL;
|
|
|
|
levels.reserve(max_level);
|
|
curr_level = 0;
|
|
|
|
hostile_merchants = false;
|
|
|
|
new_level();
|
|
msg += "Player character has spawned. ";
|
|
print();
|
|
}
|
|
|
|
void game::new_level() {
|
|
if (enabled_features & FEATURE_RAND_MAP)
|
|
levels.push_back(std::make_unique<level>(player.get(),
|
|
rng, enabled_features));
|
|
else
|
|
levels.push_back(std::make_unique<level>(default_map, player.get(),
|
|
rng, enabled_features));
|
|
}
|
|
|
|
result game::player_moves(game_command cmd) {
|
|
if (cmd == game_command_terminate) {
|
|
return result::terminate;
|
|
} else if (cmd >= move_north && cmd <= move_southwest) { // Tried to move
|
|
if (enabled_features & FEATURE_NCURSES)
|
|
return player_move_or_attack((direction)(cmd - move_north));
|
|
|
|
return player->move((direction)(cmd - move_north),
|
|
levels[curr_level]->get_available_around(
|
|
player->get_position()));
|
|
} else if (cmd >= apply_north && cmd <= apply_southwest) {
|
|
auto res = player->apply((direction)(cmd - apply_north),
|
|
levels[curr_level]->get_plist());
|
|
|
|
if (res.res == applied) {
|
|
msg += "PC used potion ";
|
|
msg += POTION_REAL_NAME[res.which->get_type()];
|
|
msg += ". ";
|
|
} else {
|
|
msg += "PC tried to drink thin air. ";
|
|
}
|
|
|
|
return res.res;
|
|
} else if (cmd == apply_panic) {
|
|
msg += "PC tried to use in some non-existent direction. ";
|
|
return fine;
|
|
} else if (cmd >= attack_north && cmd <= attack_southwest) {
|
|
auto res = player->attack((direction)(cmd - attack_north),
|
|
levels[curr_level]->get_chlist());
|
|
|
|
if (res.res == hit) {
|
|
msg += "PC deals " + std::to_string(res.dmg_dealt) +
|
|
" damage to " +
|
|
CHARACTER_REP[res.which->get_race()] +
|
|
" (" + std::to_string(res.remaining_HP) +
|
|
" HP). ";
|
|
} else if (res.res == miss) {
|
|
msg += "PC missed ";
|
|
msg += CHARACTER_REP[res.which->get_race()];
|
|
msg += ". ";
|
|
} else {
|
|
msg += "PC tried to attack thin air. ";
|
|
}
|
|
|
|
if (res.which->get_race() == rmerchant)
|
|
hostile_merchants = true;
|
|
|
|
return res.res;
|
|
} else if (cmd == up_stairs) {
|
|
if (player->get_position() ==
|
|
levels[curr_level]->get_up_stairs())
|
|
return go_up;
|
|
|
|
msg += "PC tried to fly through the ceiling. ";
|
|
return fine;
|
|
} else if (cmd == down_stairs) {
|
|
if (player->get_position() ==
|
|
levels[curr_level]->get_down_stairs())
|
|
return go_down;
|
|
|
|
msg += "PC tried to dig through the floor. ";
|
|
return fine;
|
|
} else if (cmd == the_world) {
|
|
msg += "PC toggled Stand: The World! ";
|
|
return toggle_the_world;
|
|
} else if (cmd == game_restart) {
|
|
return restart_game;
|
|
} else if (cmd == game_command_pass) {
|
|
return fine;
|
|
} else if (cmd == game_command_panic) {
|
|
msg += "PC tried to produce some undefined behaviour. ";
|
|
return unknown;
|
|
}
|
|
|
|
msg += "PC tried to produce some undefined behaviour. ";
|
|
return unknown;
|
|
}
|
|
|
|
#include <algorithm>
|
|
bool compare_characters(character *&a, character *&b) {
|
|
return a->get_position() < b->get_position();
|
|
}
|
|
|
|
void game::move_enemies() {
|
|
if (the_world)
|
|
return;
|
|
|
|
character_list enemies = levels[curr_level]->get_chlist();
|
|
std::sort(enemies.begin(), enemies.end(), &game::compare_characters);
|
|
|
|
for (auto ch : enemies) {
|
|
|
|
}
|
|
}
|
|
|
|
game_status game::run() {
|
|
msg = "";
|
|
auto res = player_moves(in->get_command());
|
|
|
|
if (!(enabled_features & FEATURE_NCURSES) &&
|
|
res == result::moved &&
|
|
(player->get_position() ==
|
|
levels[curr_level]->get_down_stairs()))
|
|
res = go_down;
|
|
|
|
if (!(enabled_features & FEATURE_NCURSES) &&
|
|
res == result::moved &&
|
|
(player->get_position() ==
|
|
levels[curr_level]->get_up_stairs()))
|
|
res = go_up;
|
|
|
|
switch (res) {
|
|
case result::terminate:
|
|
return terminated;
|
|
|
|
case result::died:
|
|
return game_status::dead;
|
|
|
|
case result::go_down: {
|
|
if (curr_level == max_level - 1)
|
|
return game_status::won;
|
|
|
|
player->discard_level_effects();
|
|
++curr_level;
|
|
new_level();
|
|
msg += "PC went down a floor. ";
|
|
break;
|
|
}
|
|
|
|
case result::go_up: {
|
|
if (curr_level == 0)
|
|
return game_status::escaped;
|
|
|
|
player->discard_level_effects();
|
|
--curr_level;
|
|
player->set_position(levels[curr_level]->get_down_stairs());
|
|
msg += "PC went up a floor. ";
|
|
break;
|
|
}
|
|
|
|
case toggle_the_world:
|
|
the_world = !the_world;
|
|
break;
|
|
|
|
case restart_game:
|
|
return restart;
|
|
|
|
case unknown:
|
|
case fine:
|
|
case applied_nothing:
|
|
++curr_turn;
|
|
return game_status::in_game;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
player->start_turn();
|
|
player->apply_effects();
|
|
|
|
if (player->get_HP() <= 0)
|
|
return game_status::dead;
|
|
|
|
move_enemies();
|
|
|
|
if (player->get_HP() <= 0)
|
|
return game_status::dead;
|
|
|
|
++curr_turn;
|
|
return game_status::in_game;
|
|
}
|
|
|
|
const position STATUS_RACE{0, 25};
|
|
const position STATUS_FLOOR{69, 25};
|
|
const position STATUS_HP{0, 26};
|
|
const position STATUS_ATK{0, 27};
|
|
const position STATUS_DEF{0, 28};
|
|
const position STATUS_ACTION{0, 29};
|
|
const char *ASK_ATK_MERCHANT =
|
|
"Action: Do you really want to attack the peaceful merchant? [Y/N]";
|
|
|
|
size_t game::get_curr_turn() const {
|
|
return curr_turn;
|
|
}
|
|
|
|
void game::print() {
|
|
if (msg.length() > MAX_MSG_LENGTH) {
|
|
msg.resize(MAX_MSG_LENGTH);
|
|
msg += "...";
|
|
}
|
|
|
|
levels[curr_level]->print(out);
|
|
player->print(out, true);
|
|
|
|
std::string tmp = "Race: ";
|
|
tmp += RACE_NAME[player->get_race()];
|
|
tmp += " Gold: " + std::to_string(player->get_gold());
|
|
out->print_str(STATUS_RACE, tmp);
|
|
|
|
tmp = "Floor " + std::to_string(curr_level + 1);
|
|
out->print_str(STATUS_FLOOR, tmp);
|
|
|
|
tmp = "Atk: " + std::to_string(player->get_ATK());
|
|
out->print_str(STATUS_ATK, tmp);
|
|
|
|
tmp = "Def: " + std::to_string(player->get_DEF());
|
|
out->print_str(STATUS_DEF, tmp);
|
|
|
|
tmp = "Action: " + msg;
|
|
out->print_str(STATUS_ACTION, tmp);
|
|
}
|
|
|
|
result game::player_move_or_attack(const direction &dir) {
|
|
auto avlbl = levels[curr_level]->get_available_around(
|
|
player->get_position());
|
|
|
|
if (find(avlbl, player->get_position() + MOVE[dir])
|
|
!= avlbl.size()) {
|
|
player->set_position(player->get_position() + MOVE[dir]);
|
|
return result::moved;
|
|
}
|
|
|
|
auto tmp = player->get_position() + MOVE[dir];
|
|
character *target;
|
|
|
|
for (auto ch : levels[curr_level]->get_chlist())
|
|
if (tmp == ch->get_position()) {
|
|
target = ch;
|
|
}
|
|
|
|
auto res = player->attack(dir, target);
|
|
|
|
if (target->get_race() == rmerchant)
|
|
hostile_merchants = true;
|
|
|
|
if (res.res == hit) {
|
|
msg += "PC deals " +
|
|
std::to_string(res.dmg_dealt) + " damage to " +
|
|
CHARACTER_REP[res.which->get_race()] + " (" +
|
|
std::to_string(res.remaining_HP) + " HP). ";
|
|
} else if (res.res == miss) {
|
|
msg += "PC missed ";
|
|
msg += CHARACTER_REP[res.which->get_race()];
|
|
msg += ". ";
|
|
} else {
|
|
msg += "PC tried to attack thin air. ";
|
|
}
|
|
|
|
return res.res;
|
|
}
|