261 lines
6.6 KiB
C++
261 lines
6.6 KiB
C++
#include <SDL3/SDL.h>
|
|
#include "libtcod.hpp"
|
|
#include "Ai.h"
|
|
#include "Actor.h"
|
|
#include "Engine.h"
|
|
#include "Map.h"
|
|
#include "Destructible.h"
|
|
#include "Attacker.h"
|
|
#include "Gui.h"
|
|
#include "Pickable.h"
|
|
#include "Container.h"
|
|
|
|
void PlayerAi::update(Actor* owner) {
|
|
SDL_Event event;
|
|
int dx = 0, dy = 0;
|
|
|
|
if (owner->destructible && owner->destructible->isDead()) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch (event.type) {
|
|
case SDL_EVENT_QUIT:
|
|
engine->gameStatus = Engine::QUIT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
while (SDL_PollEvent(&event)) {
|
|
engine->context->convert_event_coordinates(event);
|
|
switch (event.type) {
|
|
case SDL_EVENT_MOUSE_MOTION:
|
|
engine->mouse.cx = event.motion.x;
|
|
engine->mouse.cy = event.motion.y;
|
|
break;
|
|
case SDL_EVENT_KEY_UP:
|
|
switch (event.key.key) {
|
|
case SDLK_UP:
|
|
dy = -1;
|
|
break;
|
|
case SDLK_DOWN:
|
|
dy = 1;
|
|
break;
|
|
case SDLK_LEFT:
|
|
dx = -1;
|
|
break;
|
|
case SDLK_RIGHT:
|
|
dx = 1;
|
|
break;
|
|
default:
|
|
if (event.key.key >= SDLK_A && event.key.key <= SDLK_Z) {
|
|
handleActionKey(owner, event.key.key);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case SDL_EVENT_QUIT:
|
|
engine->gameStatus = Engine::QUIT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (dx != 0 || dy != 0) {
|
|
engine->gameStatus = Engine::NEW_TURN;
|
|
if (moveOrAttack(owner, owner->x + dx, owner->y + dy)) {
|
|
engine->map->computeFov();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlayerAi::handleActionKey(Actor* owner, int sdlkey) {
|
|
switch (sdlkey) {
|
|
case SDLK_G: // pickup item
|
|
{
|
|
bool found = false;
|
|
for (Actor** iterator = engine->actors.begin();
|
|
iterator != engine->actors.end(); iterator++) {
|
|
Actor* actor = *iterator;
|
|
if (actor->pickable && actor->x == owner->x && actor->y == owner->y) {
|
|
if (actor->pickable->pick(actor, owner)) {
|
|
found = true;
|
|
engine->gui->message(TCOD_ColorRGB(200,200,200), "You pick up the %s.",
|
|
actor->name.c_str());
|
|
break;
|
|
}
|
|
else if (!found) {
|
|
found = true;
|
|
engine->gui->message(TCOD_ColorRGB(255,0,0), "Your inventory is full.");
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
engine->gui->message(TCOD_ColorRGB(200,200,200), "There's nothing here that you can pick up.");
|
|
}
|
|
if (engine->gameStatus != Engine::QUIT)
|
|
engine->gameStatus = Engine::NEW_TURN;
|
|
}
|
|
break;
|
|
case SDLK_I:
|
|
{
|
|
Actor* actor = choseFromInventory(owner);
|
|
if (actor) {
|
|
actor->pickable->use(actor, owner);
|
|
if (engine->gameStatus != Engine::QUIT)
|
|
engine->gameStatus = Engine::NEW_TURN;
|
|
}
|
|
}
|
|
break;
|
|
case SDLK_D: // drop item
|
|
{
|
|
Actor* actor = choseFromInventory(owner);
|
|
if (actor) {
|
|
actor->pickable->drop(actor, owner);
|
|
if (engine->gameStatus != Engine::QUIT)
|
|
engine->gameStatus = Engine::NEW_TURN;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool PlayerAi::moveOrAttack(Actor* owner, int targetx, int targety) {
|
|
if (engine->map->isWall(targetx, targety)) return false;
|
|
// look for living actors to attack
|
|
for (Actor** iterator = engine->actors.begin();
|
|
iterator != engine->actors.end(); iterator++) {
|
|
Actor* actor = *iterator;
|
|
if (actor->destructible && !actor->destructible->isDead()
|
|
&& actor->x == targetx && actor->y == targety) {
|
|
owner->attacker->attack(owner, actor);
|
|
return false;
|
|
}
|
|
}
|
|
for (Actor** iterator = engine->actors.begin();
|
|
iterator != engine->actors.end(); iterator++) {
|
|
Actor* actor = *iterator;
|
|
bool corpseOrItem = (actor->destructible && actor->destructible->isDead())
|
|
|| actor->pickable;
|
|
if (corpseOrItem
|
|
&& actor->x == targetx && actor->y == targety) {
|
|
engine->gui->message(TCOD_ColorRGB(200,200,200), "There's a %s here.", actor->name.c_str());
|
|
}
|
|
}
|
|
owner->x = targetx;
|
|
owner->y = targety;
|
|
return true;
|
|
}
|
|
|
|
Actor* PlayerAi::choseFromInventory(Actor* owner) {
|
|
static const int INVENTORY_WIDTH = 50;
|
|
static const int INVENTORY_HEIGHT = 28;
|
|
|
|
tcod::Console con = engine->context->new_console(INVENTORY_WIDTH, INVENTORY_HEIGHT);
|
|
|
|
TCOD_ColorRGB fg(200, 180, 50);
|
|
TCOD_ColorRGB bg(0, 0, 0);
|
|
tcod::print_frame(con, { 0, 0, INVENTORY_WIDTH, INVENTORY_HEIGHT }, "Inventory", &fg, &bg);
|
|
|
|
char shortcut = 'a';
|
|
int y = 1;
|
|
for (Actor** it = owner->container->inventory.begin();
|
|
it != owner->container->inventory.end(); it++) {
|
|
Actor* actor = *it;
|
|
tcod::print(con, { 1, y }, std::string("(") + shortcut + ") " + actor->name, TCOD_ColorRGB(255, 255, 255), std::nullopt, TCOD_LEFT);
|
|
y++;
|
|
shortcut++;
|
|
}
|
|
tcod::blit(*engine->console, con, { engine->screenWidth / 2 - INVENTORY_WIDTH / 2, engine->screenHeight / 2 - INVENTORY_HEIGHT / 2 }, { 0, 0, INVENTORY_WIDTH, INVENTORY_HEIGHT });
|
|
|
|
engine->context->present(*engine->console);
|
|
SDL_Event event;
|
|
while (1) {
|
|
SDL_WaitEvent(&event);
|
|
if (event.type == SDL_EVENT_KEY_UP) {
|
|
if (event.key.key >= SDLK_A && event.key.key < SDLK_A + owner->container->inventory.size()) {
|
|
return owner->container->inventory.get(event.key.key - SDLK_A);
|
|
}
|
|
return nullptr;
|
|
}
|
|
if (event.type == SDL_EVENT_QUIT) {
|
|
engine->gameStatus = Engine::QUIT;
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
static const int TRACKING_TURNS = 3;
|
|
|
|
void MonsterAi::update(Actor* owner) {
|
|
if (owner->destructible && owner->destructible->isDead()) {
|
|
return;
|
|
}
|
|
if (engine->map->isInFov(owner->x, owner->y)) {
|
|
// we can see the player. move towards him
|
|
moveCount = TRACKING_TURNS;
|
|
}
|
|
else {
|
|
moveCount--;
|
|
}
|
|
if (moveCount > 0) {
|
|
// we can see the player. move towards him
|
|
moveOrAttack(owner, engine->player->x, engine->player->y);
|
|
}
|
|
}
|
|
|
|
void MonsterAi::moveOrAttack(Actor* owner, int targetx, int targety) {
|
|
int dx = targetx - owner->x;
|
|
int dy = targety - owner->y;
|
|
int stepdx = (dx > 0 ? 1 : -1);
|
|
int stepdy = (dy > 0 ? 1 : -1);
|
|
float distance = sqrtf((float)dx * (float)dx + (float)dy * (float)dy);
|
|
if (distance >= 2) {
|
|
dx = (int)(round(dx / distance));
|
|
dy = (int)(round(dy / distance));
|
|
if (engine->map->canWalk(owner->x + dx, owner->y + dy)) {
|
|
owner->x += dx;
|
|
owner->y += dy;
|
|
}
|
|
else if (engine->map->canWalk(owner->x + stepdx, owner->y)) {
|
|
owner->x += stepdx;
|
|
}
|
|
else if (engine->map->canWalk(owner->x, owner->y + stepdy)) {
|
|
owner->y += stepdy;
|
|
}
|
|
}
|
|
else if (owner->attacker) {
|
|
owner->attacker->attack(owner, engine->player);
|
|
}
|
|
}
|
|
|
|
ConfusedMonsterAi::ConfusedMonsterAi(int nbTurns, Ai* oldAi)
|
|
: nbTurns(nbTurns), oldAi(oldAi) {
|
|
}
|
|
|
|
void ConfusedMonsterAi::update(Actor* owner) {
|
|
TCODRandom* rng = TCODRandom::getInstance();
|
|
int dx = rng->getInt(-1, 1);
|
|
int dy = rng->getInt(-1, 1);
|
|
if (dx != 0 || dy != 0) {
|
|
int destx = owner->x + dx;
|
|
int desty = owner->y + dy;
|
|
if (engine->map->canWalk(destx, desty)) {
|
|
owner->x = destx;
|
|
owner->y = desty;
|
|
}
|
|
else {
|
|
Actor* actor = engine->getActor(destx, desty);
|
|
if (actor) {
|
|
owner->attacker->attack(owner, actor);
|
|
}
|
|
}
|
|
}
|
|
nbTurns--;
|
|
if (nbTurns == 0) {
|
|
owner->ai = oldAi;
|
|
delete this;
|
|
}
|
|
}
|