WoWFolder.cpp

Go to the documentation of this file.

#include "WoWFolder.h"
#include <filesystem>
#include <format>
#include <fstream>
#include <string>
#include "CASCFile.h"
#include "Game.h"
#include "string_utils.h"
#include "HardDriveFile.h"
#include "Logger.h"
 
wow::WoWFolder::WoWFolder(const std::string& path) : GameFolder(path)
{
}
 
void wow::WoWFolder::init()
{
    m_CASCFolder.init(path());
}
 
void wow::WoWFolder::initFromListfile(const std::string& filename)
{
    const std::string fullPath = core::Game::instance().configFolder() + filename;
    std::ifstream file(fullPath);
    if (!file.is_open())
    {
        LOG_ERROR << "Failed to open" << filename;
        return;
    }
 
    // Get total file size for progress tracking
    file.seekg(0, std::ios::end);
    const auto totalSize = file.tellg();
    file.seekg(0, std::ios::beg);
    int lineCount = 0;
 
    LOG_INFO << "WoWFolder - Starting to build object hierarchy";
    std::string stdline;
    while (std::getline(file, stdline))
    {
        std::string line = core::toLower(stdline);
        auto lineData = core::split(line, ';');
        if (lineData.size() < 2)
            continue;
        int id = std::stoi(lineData[0]);
        std::string fileName = lineData[1];
        // Add the file to the name-ID mappings even if it can't be found in CASC,
        // as it could be a custom file added by the user:
        m_idNameMap[id] = fileName;
        m_nameIdMap[fileName] = id;
        if (m_CASCFolder.fileExists(id))
        {
            CASCFile* File = new CASCFile(fileName, id);
            auto lastSlash = line.rfind('/');
            File->setName(lastSlash != std::string::npos ? line.substr(lastSlash + 1) : line);
            addChild(File);
        }
        if (m_progressCallback && ++lineCount % 500 == 0 && totalSize > 0)
            m_progressCallback(static_cast<int>(file.tellg()), static_cast<int>(totalSize));
    }
    LOG_INFO << "WoWFolder - Hierarchy creation done";
}
 
void wow::WoWFolder::addCustomFiles(const std::string& path, bool bypassOriginalFiles)
{
    LOG_INFO << "Add customFiles from folder" << path;
    namespace fs = std::filesystem;
 
    std::error_code ec;
    for (const auto& entry : fs::recursive_directory_iterator(path, ec))
    {
        if (!entry.is_regular_file())
            continue;
 
        std::string filePath = core::toLower(entry.path().string());
        std::string absPath = filePath;
 
        std::string toRemove = path + "\\";
        if (filePath.find(toRemove) == 0)
            filePath.erase(0, toRemove.size());
 
        GameFile* originalFile = GameFolder::getFile(filePath);
        bool addnewfile = true;
        int originalId = -1;
        if (originalFile)
        {
            if (bypassOriginalFiles)
            {
                originalId = originalFile->fileDataId();
                removeChild(originalFile);
                delete originalFile;
                originalFile = nullptr;
            }
            else
            {
                addnewfile = false;
            }
        }
        else
        {
            // Even though the file wasn't found in the game database, it's possible to assign it
            // a specific ID in the listfile (useful in some situations) :
            auto it = m_nameIdMap.find(filePath);
            if (it != m_nameIdMap.end())
                originalId = it->second;
        }
        if (addnewfile)
        {
            LOG_INFO << "Add custom file" << filePath << "(ID:" << originalId << ")from hard drive location" <<
                absPath;
            HardDriveFile* file = new HardDriveFile(filePath, absPath, originalId);
            auto lastSlash = filePath.rfind('/');
            file->setName(lastSlash != std::string::npos ? filePath.substr(lastSlash + 1) : filePath);
            addChild(file);
        }
    }
}
 
GameFile* wow::WoWFolder::getFile(int id)
{
    GameFile* result = nullptr;
 
    if (id <= 0) // bad id given
        return result;
 
    const auto it = m_idMap.find(id);
    if (it != m_idMap.end())
        result = it->second;
 
    if (!result) // if not found, try to force open by id
    {
        // Build File########.unk filename needed for CASC lib to open file based on id
        const std::string filename = std::format("File{:08x}.unk", id);
        LOG_INFO << "File with id" << id << "not found in listfile. Trying to open" << filename;
 
        HANDLE newfile;
        if (m_CASCFolder.openFile(id, &newfile))
        {
            LOG_INFO << "Succesfully opened";
            m_CASCFolder.closeFile(newfile);
            CASCFile* file = new CASCFile(filename, id);
            file->setName(filename);
            addChild(file);
            result = file;
        }
    }
 
    return result;
}
 
bool wow::WoWFolder::openFile(int id, HANDLE* result)
{
    return m_CASCFolder.openFile(id, result);
}
 
bool wow::WoWFolder::openFile(std::string file, HANDLE* result)
{
    const auto it = m_nameIdMap.find(file);
    if (it == m_nameIdMap.end())
        return false;
    return m_CASCFolder.openFile(it->second, result);
}
 
std::string wow::WoWFolder::version()
{
    return m_CASCFolder.version();
}
 
int wow::WoWFolder::majorVersion()
{
    auto v = core::split(version(), '.');
    return std::stoi(v[0]);
}
 
std::string wow::WoWFolder::locale()
{
    return m_CASCFolder.locale();
}
 
bool wow::WoWFolder::setConfig(core::GameConfig config)
{
    return m_CASCFolder.setConfig(config);
}
 
std::vector<core::GameConfig> wow::WoWFolder::configsFound()
{
    return m_CASCFolder.configsFound();
}
 
int wow::WoWFolder::lastError()
{
    return m_CASCFolder.lastError();
}
 
void wow::WoWFolder::onChildAdded(GameFile* child)
{
    GameFolder::onChildAdded(child);
    m_idMap[child->fileDataId()] = child;
}
 
void wow::WoWFolder::onChildRemoved(GameFile* child)
{
    GameFolder::onChildRemoved(child);
    m_idMap.erase(child->fileDataId());
}
 
std::string wow::WoWFolder::fileName(int id)
{
    const auto it = m_idNameMap.find(id);
    if (it == m_idNameMap.end())
        return std::string();
    return it->second;
}
 
int wow::WoWFolder::fileID(const std::string& fileName)
{
    const auto it = m_nameIdMap.find(fileName);
    if (it == m_nameIdMap.end())
        return -1;
    return it->second;
}