volcano_2022/source/enemy_engine.cpp

#include "enemy_engine.h"
#include <fstream>
#include <sstream>

// Constructor
EnemyEngine::EnemyEngine(SDL_Renderer *renderer, Asset *asset, Player *player, Map *map, std::string file)
{
    this->renderer = renderer;
    this->asset = asset;
    this->player = player;
    this->map = map;

    load(file);
}

// Destructor
EnemyEngine::~EnemyEngine()
{
    // Elimina todos los enemigos anteriores
    for (auto enemy : enemies)
    {
        delete enemy;
    }
    enemies.clear();
}

// Pinta los enemigos en pantalla
void EnemyEngine::render()
{
    for (auto enemy : enemies)
    {
        enemy->render();
    }
}

// Actualiza las variables del objeto
void EnemyEngine::update()
{
    for (auto enemy : enemies)
    {
        enemy->update();
    }
}

// Carga las variables desde un fichero
bool EnemyEngine::load(std::string file_path)
{
    // Indicador de éxito en la carga
    bool success = true;

    std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
    std::string line;
    std::ifstream file(file_path);

    // El fichero se puede abrir
    if (file.good())
    {
        // Procesa el fichero linea a linea
        printf("Reading file %s\n", filename.c_str());
        while (std::getline(file, line))
        {
            // Si la linea contiene el texto [actor] se realiza el proceso de carga de los actores
            if (line == "[path]")
            {
                enemy_t enemy;
                enemy.asset = asset;
                enemy.renderer = renderer;
                SDL_Point p1, p2;

                do
                {
                    std::getline(file, line);

                    // Encuentra la posición del caracter '='
                    int pos = line.find("=");

                    // Procesa las dos subcadenas
                    if (!setEnemy(&enemy, &p1, &p2, line.substr(0, pos), line.substr(pos + 1, line.length())))
                    {
                        printf("Warning: file %s\n, unknown parameter \"%s\"\n", filename.c_str(), line.substr(0, pos).c_str());
                        success = false;
                    }

                } while (line != "[/path]");

                printf("** enemy path loaded\n\n");
                enemies.push_back(new EnemyPath(enemy, p1, p2));
            }
        }

        // Cierra el fichero
        printf("Closing file %s\n\n", filename.c_str());
        file.close();
    }
    // El fichero no se puede abrir
    else
    {
        printf("Warning: Unable to open %s file\n", filename.c_str());
        success = false;
    }

    return success;
}

// Asigna variables a una estructura enemy_t
bool EnemyEngine::setEnemy(enemy_t *enemy, SDL_Point *p1, SDL_Point *p2, std::string var, std::string value)
{
    const int tile_size = 8;

    // Indicador de éxito en la asignación
    bool success = true;

    if (var == "tileset")
    {
        enemy->tileset = value;
    }

    else if (var == "animation")
    {
        enemy->animation = value;
    }

    else if (var == "width")
    {
        enemy->w = std::stof(value);
    }

    else if (var == "height")
    {
        enemy->h = std::stof(value);
    }

    else if (var == "x")
    {
        enemy->x = std::stof(value) * tile_size;
    }

    else if (var == "y")
    {
        enemy->y = std::stof(value) * tile_size;
    }

    else if (var == "vx")
    {
        enemy->vx = std::stof(value);
    }

    else if (var == "vy")
    {
        enemy->vy = std::stof(value);
    }

    else if (var == "x1")
    {
        p1->x = std::stoi(value) * tile_size;
    }

    else if (var == "x2")
    {
        p2->x = std::stoi(value) * tile_size;
    }

    else if (var == "y1")
    {
        p1->y = std::stoi(value) * tile_size;
    }

    else if (var == "y2")
    {
        p2->y = std::stoi(value) * tile_size;
    }

    else if (var == "[/path]")
    {
    }

    else
    {
        success = false;
    }

    return success;
}

// Comprueba las colisiones con los enemigos
bool EnemyEngine::checkEnemyCollision(SDL_Rect &rect)
{
    for (auto enemy : enemies)
    {
        if (checkCollision(rect, enemy->getCollider()))
        {
            return true;
        }
    }

    return false;
}