jail_engine/units/asset.cpp

#include "asset.h"
#include <iostream>

// Constructor
Asset::Asset(std::string executablePath)
{
	//std::cout << "Construido Asset" << std::endl;
    this->executablePath = executablePath.substr(0, executablePath.find_last_of("\\/"));
    longestName = 0;
    verbose = true;
}

// Destructot
Asset::~Asset()
{
	//std::cout << "Destruido Asset" << std::endl;
}

// Añade un elemento a la lista
void Asset::add(std::string file, enum assetType type, bool required, bool absolute)
{
    item_t temp;
    temp.file = absolute ? file : executablePath + file;
    temp.type = type;
    temp.required = required;
    fileList.push_back(temp);

    const std::string filename = file.substr(file.find_last_of("\\/") + 1);
    longestName = SDL_max(longestName, filename.size());
}

// Devuelve el fichero de un elemento de la lista a partir de una cadena
std::string Asset::get(std::string text)
{
    for (auto f : fileList)
    {
        const size_t lastIndex = f.file.find_last_of("/") + 1;
        const std::string file = f.file.substr(lastIndex, std::string::npos);

        if (file == text)
        {
            return f.file;
        }
    }

    if (verbose)
    {
        std::cout << "Warning: file " << text.c_str() << " not found" << std::endl;
    }
    return "";
}

// Comprueba que existen todos los elementos
bool Asset::check()
{
    bool success = true;

    if (verbose)
    {
        std::cout << "\n** Checking files" << std::endl;

        std::cout << "Executable path is:  " << executablePath << std::endl;
        std::cout << "Sample filepath:  " << fileList.back().file << std::endl;
    }

    // Comprueba la lista de ficheros clasificandolos por tipo
    for (int type = 0; type < t_maxAssetType; ++type)
    {
        // Comprueba si hay ficheros de ese tipo
        bool any = false;

        for (auto f : fileList)
        {
            if ((f.required) && (f.type == type))
            {
                any = true;
            }
        }

        // Si hay ficheros de ese tipo, comprueba si existen
        if (any)
        {
            if (verbose)
            {
                std::cout << "\n>> " << getTypeName(type).c_str() << " FILES" << std::endl;
            }

            for (auto f : fileList)
            {
                if ((f.required) && (f.type == type))
                {
                    success &= checkFile(f.file);
                }
            }
        }
    }

    // Resultado
    if (verbose)
    {
        if (success)
        {
            std::cout << "\n** All files OK.\n"
                      << std::endl;
        }
        else
        {
            std::cout << "\n** A file is missing. Exiting.\n"
                      << std::endl;
        }
    }

    return success;
}

// Comprueba que existe un fichero
bool Asset::checkFile(std::string path)
{
    bool success = false;
    std::string result = "ERROR";

    // Comprueba si existe el fichero
    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
    SDL_RWops *file = SDL_RWFromFile(path.c_str(), "rb");

    if (file != nullptr)
    {
        result = "OK";
        success = true;
        SDL_RWclose(file);
    }

    if (verbose)
    {
        std::cout.setf(std::ios::left, std::ios::adjustfield);
        std::cout << "Checking file: ";
        std::cout.width(longestName + 2);
        std::cout.fill('.');
        std::cout << filename + " ";
        std::cout << " [" + result + "]" << std::endl;
    }

    return success;
}

// Devuelve el nombre del tipo de recurso
std::string Asset::getTypeName(int type)
{
    switch (type)
    {
    case t_bitmap:
        return "BITMAP";
        break;

    case t_music:
        return "MUSIC";
        break;

    case t_sound:
        return "SOUND";
        break;

    case t_font:
        return "FONT";
        break;

    case t_lang:
        return "LANG";
        break;

    case t_data:
        return "DATA";
        break;

    case t_room:
        return "ROOM";
        break;

    case t_enemy:
        return "ENEMY";
        break;

    case t_item:
        return "ITEM";
        break;

    default:
        return "ERROR";
        break;
    }
}

// Establece si ha de mostrar texto por pantalla
void Asset::setVerbose(bool value)
{
    verbose = value;
}