4jcraft/Minecraft.Client/Textures/Packs/TexturePackRepository.cpp

#include "../../Platform/stdafx.h"
#include "TexturePackRepository.h"
#include "DefaultTexturePack.h"
#include "FileTexturePack.h"
#include "FolderTexturePack.h"
#include "DLCTexturePack.h"
#include "../../GameState/Options.h"
#include "../../../Minecraft.World/IO/Files/File.h"
#include "../../../Minecraft.World/Util/StringHelpers.h"
#include "../../Rendering/Minimap.h"

TexturePack* TexturePackRepository::DEFAULT_TEXTURE_PACK = nullptr;

TexturePackRepository::TexturePackRepository(File workingDirectory,
                                             Minecraft* minecraft) {
    if (!DEFAULT_TEXTURE_PACK) DEFAULT_TEXTURE_PACK = new DefaultTexturePack();

    // 4J - added
    usingWeb = false;
    selected = nullptr;
    texturePacks = new std::vector<TexturePack*>;

    this->minecraft = minecraft;

    texturePacks->push_back(DEFAULT_TEXTURE_PACK);
    cacheById[DEFAULT_TEXTURE_PACK->getId()] = DEFAULT_TEXTURE_PACK;
    selected = DEFAULT_TEXTURE_PACK;

    DEFAULT_TEXTURE_PACK->loadColourTable();

    m_dummyTexturePack = nullptr;
    m_dummyDLCTexturePack = nullptr;
    lastSelected = nullptr;

    updateList();
}

void TexturePackRepository::addDebugPacks() {
#if !defined(_CONTENT_PACKAGE)
    // File *file = new File(L"DummyTexturePack"); // Path to the test texture
    // pack m_dummyTexturePack = new
    // FolderTexturePack(FOLDER_TEST_TEXTURE_PACK_ID, L"FolderTestPack", file,
    // DEFAULT_TEXTURE_PACK); texturePacks->push_back(m_dummyTexturePack);
    // cacheById[m_dummyTexturePack->getId()] = m_dummyTexturePack;

#endif
}

void TexturePackRepository::createWorkingDirecoryUnlessExists() {
    // 4J Unused
}

bool TexturePackRepository::selectSkin(TexturePack* skin) {
    if (skin == selected) return false;

    lastSelected = selected;
    usingWeb = false;
    selected = skin;
    // minecraft->options->skin = skin->getName();
    // minecraft->options->save();
    return true;
}

void TexturePackRepository::selectWebSkin(const std::wstring& url) {
    app.DebugPrintf(
        "TexturePackRepository::selectWebSkin is not implemented\n");
}

void TexturePackRepository::downloadWebSkin(const std::wstring& url,
                                            File file) {
    app.DebugPrintf(
        "TexturePackRepository::selectWebSkin is not implemented\n");
}

bool TexturePackRepository::isUsingWebSkin() { return usingWeb; }

void TexturePackRepository::resetWebSkin() {
    usingWeb = false;
    updateList();
    minecraft->delayTextureReload();
}

void TexturePackRepository::updateList() {
    // 4J Stu - We don't ever want to completely refresh the lists, we keep them
    // up-to-date as we go
}

std::wstring TexturePackRepository::getIdOrNull(File file) {
    app.DebugPrintf("TexturePackRepository::getIdOrNull is not implemented\n");
    return L"";
}

std::vector<File> TexturePackRepository::getWorkDirContents() {
    app.DebugPrintf(
        "TexturePackRepository::getWorkDirContents is not implemented\n");
    return std::vector<File>();
}

std::vector<TexturePack*>* TexturePackRepository::getAll() {
    // 4J - note that original constucted a copy of texturePacks here
    return texturePacks;
}

TexturePack* TexturePackRepository::getSelected() {
    if (selected->hasData())
        return selected;
    else
        return DEFAULT_TEXTURE_PACK;
}

bool TexturePackRepository::shouldPromptForWebSkin() {
    app.DebugPrintf(
        "TexturePackRepository::shouldPromptForWebSkin is not implemented\n");
    return false;
}

bool TexturePackRepository::canUseWebSkin() {
    app.DebugPrintf(
        "TexturePackRepository::canUseWebSkin is not implemented\n");
    return false;
}

std::vector<std::pair<std::uint32_t, std::wstring> >*
TexturePackRepository::getTexturePackIdNames() {
    std::vector<std::pair<std::uint32_t, std::wstring> >* packList =
        new std::vector<std::pair<std::uint32_t, std::wstring> >();

    for (AUTO_VAR(it, texturePacks->begin()); it != texturePacks->end(); ++it) {
        TexturePack* pack = *it;
        packList->push_back(std::pair<std::uint32_t, std::wstring>(
            pack->getId(), pack->getName()));
    }
    return packList;
}

bool TexturePackRepository::selectTexturePackById(std::uint32_t id) {
    bool bDidSelect = false;

    // 4J-PB - add in a store of the texture pack required, so that join from
    // invite games
    //  (where they don't have the texture pack) can check this when the texture
    //  pack is installed
    app.SetRequiredTexturePackID(id);

    AUTO_VAR(it, cacheById.find(id));
    if (it != cacheById.end()) {
        TexturePack* newPack = it->second;
        if (newPack != selected) {
            selectSkin(newPack);

            if (newPack->hasData()) {
                app.SetAction(ProfileManager.GetPrimaryPad(),
                              eAppAction_ReloadTexturePack);
            } else {
                newPack->loadData();
            }
            // Minecraft *pMinecraft = Minecraft::GetInstance();
            // pMinecraft->textures->reloadAll();
        } else {
            app.DebugPrintf("TexturePack with id %d is already selected\n", id);
        }
        bDidSelect = true;
    } else {
        app.DebugPrintf(
            "Failed to select texture pack %d as it is not in the list\n", id);
#if !defined(_CONTENT_PACKAGE)
        // TODO - 4J Stu: We should report this to the player in some way
        //__debugbreak();
#endif
        // Fail safely
        if (selectSkin(DEFAULT_TEXTURE_PACK)) {
            app.SetAction(ProfileManager.GetPrimaryPad(),
                          eAppAction_ReloadTexturePack);
        }
    }
    return bDidSelect;
}

TexturePack* TexturePackRepository::getTexturePackById(std::uint32_t id) {
    AUTO_VAR(it, cacheById.find(id));
    if (it != cacheById.end()) {
        return it->second;
    }

    return nullptr;
}

TexturePack* TexturePackRepository::addTexturePackFromDLC(DLCPack* dlcPack,
                                                          std::uint32_t id) {
    TexturePack* newPack = nullptr;
    // 4J-PB - The City texture pack went out with a child id for the texture
    // pack of 1 instead of zero we need to mask off the child id here to deal
    // with this
    const std::uint32_t parentId =
        id & 0xFFFFFFu;  // child id is <<24 and Or'd with parent

    if (dlcPack != nullptr) {
        newPack = new DLCTexturePack(parentId, dlcPack, DEFAULT_TEXTURE_PACK);
        texturePacks->push_back(newPack);
        cacheById[parentId] = newPack;

#if !defined(_CONTENT_PACKAGE)
        if (dlcPack->hasPurchasedFile(DLCManager::e_DLCType_TexturePack, L"")) {
            wprintf(L"Added new FULL DLCTexturePack: %ls - id=%u\n",
                    dlcPack->getName().c_str(), parentId);
        } else {
            wprintf(L"Added new TRIAL DLCTexturePack: %ls - id=%u\n",
                    dlcPack->getName().c_str(), parentId);
        }
#endif
    }
    return newPack;
}

void TexturePackRepository::clearInvalidTexturePacks() {
    for (AUTO_VAR(it, m_texturePacksToDelete.begin());
         it != m_texturePacksToDelete.end(); ++it) {
        delete *it;
    }
}

void TexturePackRepository::removeTexturePackById(std::uint32_t id) {
    AUTO_VAR(it, cacheById.find(id));
    if (it != cacheById.end()) {
        TexturePack* oldPack = it->second;

        AUTO_VAR(it2,
                 find(texturePacks->begin(), texturePacks->end(), oldPack));
        if (it2 != texturePacks->end()) {
            texturePacks->erase(it2);
            if (lastSelected == oldPack) {
                lastSelected = nullptr;
            }
        }
        m_texturePacksToDelete.push_back(oldPack);
    }
}

void TexturePackRepository::updateUI() {
    if (lastSelected != nullptr && lastSelected != selected) {
        lastSelected->unloadUI();
        selected->loadUI();
        Minimap::reloadColours();
        ui.StartReloadSkinThread();
        lastSelected = nullptr;
    }
}

bool TexturePackRepository::needsUIUpdate() {
    return lastSelected != nullptr && lastSelected != selected;
}

unsigned int TexturePackRepository::getTexturePackCount() {
    return texturePacks->size();
}

TexturePack* TexturePackRepository::getTexturePackByIndex(unsigned int index) {
    TexturePack* pack = nullptr;
    if (index < texturePacks->size()) {
        pack = texturePacks->at(index);
    }
    return pack;
}

unsigned int TexturePackRepository::getTexturePackIndex(std::uint32_t id) {
    int currentIndex = 0;
    for (AUTO_VAR(it, texturePacks->begin()); it != texturePacks->end(); ++it) {
        TexturePack* pack = *it;
        if (pack->getId() == id) break;
        ++currentIndex;
    }
    if (currentIndex >= texturePacks->size()) currentIndex = 0;
    return currentIndex;
}