mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-04-24 02:53:39 +00:00
721 lines
26 KiB
C++
721 lines
26 KiB
C++
#include "app/common/DLCController.h"
|
|
|
|
#include "app/common/Game.h"
|
|
#include "app/common/DLC/DLCPack.h"
|
|
#include "app/common/DLC/DLCManager.h"
|
|
#include "app/common/DLC/DLCSkinFile.h"
|
|
#include "app/linux/LinuxGame.h"
|
|
#include "app/linux/Linux_UIController.h"
|
|
#include "app/linux/Stubs/winapi_stubs.h"
|
|
#include "minecraft/client/Minecraft.h"
|
|
#include "minecraft/client/skins/TexturePack.h"
|
|
#include "minecraft/client/skins/TexturePackRepository.h"
|
|
#include "platform/storage/storage.h"
|
|
#include "platform/profile/profile.h"
|
|
#include "platform/XboxStubs.h"
|
|
|
|
#include <cstring>
|
|
#include <mutex>
|
|
|
|
DLCController::DLCController() {
|
|
m_pDLCFileBuffer = nullptr;
|
|
m_dwDLCFileSize = 0;
|
|
m_bDefaultCapeInstallAttempted = false;
|
|
m_bDLCInstallProcessCompleted = false;
|
|
m_bDLCInstallPending = false;
|
|
m_iTotalDLC = 0;
|
|
m_iTotalDLCInstalled = 0;
|
|
m_bNewDLCAvailable = false;
|
|
m_bSeenNewDLCTip = false;
|
|
m_iDLCOfferC = 0;
|
|
m_bAllDLCContentRetrieved = true;
|
|
m_bAllTMSContentRetrieved = true;
|
|
m_bTickTMSDLCFiles = true;
|
|
}
|
|
|
|
std::unordered_map<PlayerUID, MOJANG_DATA*> DLCController::MojangData;
|
|
std::unordered_map<int, uint64_t> DLCController::DLCTextures_PackID;
|
|
std::unordered_map<uint64_t, DLC_INFO*> DLCController::DLCInfo_Trial;
|
|
std::unordered_map<uint64_t, DLC_INFO*> DLCController::DLCInfo_Full;
|
|
std::unordered_map<std::string, uint64_t> DLCController::DLCInfo_SkinName;
|
|
|
|
std::uint32_t DLCController::m_dwContentTypeA[e_Marketplace_MAX] = {
|
|
XMARKETPLACE_OFFERING_TYPE_CONTENT,
|
|
XMARKETPLACE_OFFERING_TYPE_THEME,
|
|
XMARKETPLACE_OFFERING_TYPE_AVATARITEM,
|
|
XMARKETPLACE_OFFERING_TYPE_TILE,
|
|
};
|
|
|
|
int DLCController::marketplaceCountsCallback(
|
|
void* pParam, IPlatformStorage::DLC_TMS_DETAILS* pTMSDetails, int iPad) {
|
|
app.DebugPrintf("Marketplace Counts= New - %d Total - %d\n",
|
|
pTMSDetails->dwNewOffers, pTMSDetails->dwTotalOffers);
|
|
|
|
if (pTMSDetails->dwNewOffers > 0) {
|
|
app.m_dlcController.m_bNewDLCAvailable = true;
|
|
app.m_dlcController.m_bSeenNewDLCTip = false;
|
|
} else {
|
|
app.m_dlcController.m_bNewDLCAvailable = false;
|
|
app.m_dlcController.m_bSeenNewDLCTip = true;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool DLCController::startInstallDLCProcess(int iPad) {
|
|
app.DebugPrintf("--- DLCController::startInstallDLCProcess: pad=%i.\n",
|
|
iPad);
|
|
|
|
if ((dlcInstallProcessCompleted() == false) &&
|
|
(m_bDLCInstallPending == false)) {
|
|
app.m_dlcManager.resetUnnamedCorruptCount();
|
|
m_bDLCInstallPending = true;
|
|
m_iTotalDLC = 0;
|
|
m_iTotalDLCInstalled = 0;
|
|
app.DebugPrintf(
|
|
"--- DLCController::startInstallDLCProcess - "
|
|
"PlatformStorage.GetInstalledDLC\n");
|
|
|
|
PlatformStorage.GetInstalledDLC(
|
|
iPad, [this](int iInstalledC, int pad) {
|
|
return dlcInstalledCallback(iInstalledC, pad);
|
|
});
|
|
return true;
|
|
} else {
|
|
app.DebugPrintf(
|
|
"--- DLCController::startInstallDLCProcess - nothing to do\n");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int DLCController::dlcInstalledCallback(int iInstalledC, int iPad) {
|
|
app.DebugPrintf(
|
|
"--- DLCController::dlcInstalledCallback: totalDLC=%i, pad=%i.\n",
|
|
iInstalledC, iPad);
|
|
m_iTotalDLC = iInstalledC;
|
|
mountNextDLC(iPad);
|
|
return 0;
|
|
}
|
|
|
|
void DLCController::mountNextDLC(int iPad) {
|
|
app.DebugPrintf("--- DLCController::mountNextDLC: pad=%i.\n", iPad);
|
|
if (m_iTotalDLCInstalled < m_iTotalDLC) {
|
|
if (PlatformStorage.MountInstalledDLC(
|
|
iPad, m_iTotalDLCInstalled,
|
|
[this](int pad, std::uint32_t dwErr,
|
|
std::uint32_t dwLicenceMask) {
|
|
return dlcMountedCallback(pad, dwErr, dwLicenceMask);
|
|
}) != ERROR_IO_PENDING) {
|
|
app.DebugPrintf("Failed to mount DLC %d for pad %d\n",
|
|
m_iTotalDLCInstalled, iPad);
|
|
++m_iTotalDLCInstalled;
|
|
mountNextDLC(iPad);
|
|
} else {
|
|
app.DebugPrintf("PlatformStorage.MountInstalledDLC ok\n");
|
|
}
|
|
} else {
|
|
m_bDLCInstallPending = false;
|
|
m_bDLCInstallProcessCompleted = true;
|
|
ui.HandleDLCMountingComplete();
|
|
}
|
|
}
|
|
|
|
#if defined(_WINDOWS64)
|
|
#define CONTENT_DATA_DISPLAY_NAME(a) (a.szDisplayName)
|
|
#else
|
|
#define CONTENT_DATA_DISPLAY_NAME(a) (a.wszDisplayName)
|
|
#endif
|
|
|
|
int DLCController::dlcMountedCallback(int iPad, std::uint32_t dwErr,
|
|
std::uint32_t dwLicenceMask) {
|
|
#if defined(_WINDOWS64)
|
|
app.DebugPrintf("--- DLCController::dlcMountedCallback\n");
|
|
|
|
if (dwErr != ERROR_SUCCESS) {
|
|
app.DebugPrintf("Failed to mount DLC for pad %d: %u\n", iPad, dwErr);
|
|
app.m_dlcManager.incrementUnnamedCorruptCount();
|
|
} else {
|
|
XCONTENT_DATA ContentData =
|
|
PlatformStorage.GetDLC(m_iTotalDLCInstalled);
|
|
|
|
DLCPack* pack =
|
|
app.m_dlcManager.getPack(CONTENT_DATA_DISPLAY_NAME(ContentData));
|
|
|
|
if (pack != nullptr && pack->IsCorrupt()) {
|
|
app.DebugPrintf(
|
|
"Pack '%s' is corrupt, removing it from the DLC Manager.\n",
|
|
CONTENT_DATA_DISPLAY_NAME(ContentData));
|
|
app.m_dlcManager.removePack(pack);
|
|
pack = nullptr;
|
|
}
|
|
|
|
if (pack == nullptr) {
|
|
app.DebugPrintf("Pack \"%s\" is not installed, so adding it\n",
|
|
CONTENT_DATA_DISPLAY_NAME(ContentData));
|
|
|
|
#if defined(_WINDOWS64)
|
|
pack = new DLCPack(ContentData.szDisplayName, dwLicenceMask);
|
|
#else
|
|
pack = new DLCPack(ContentData.wszDisplayName, dwLicenceMask);
|
|
#endif
|
|
pack->SetDLCMountIndex(m_iTotalDLCInstalled);
|
|
pack->SetDLCDeviceID(ContentData.DeviceID);
|
|
app.m_dlcManager.addPack(pack);
|
|
handleDLC(pack);
|
|
|
|
if (pack->getDLCItemsCount(DLCManager::e_DLCType_Texture) > 0) {
|
|
Minecraft::GetInstance()->skins->addTexturePackFromDLC(
|
|
pack, pack->GetPackId());
|
|
}
|
|
} else {
|
|
app.DebugPrintf(
|
|
"Pack \"%s\" is already installed. Updating license to %u\n",
|
|
CONTENT_DATA_DISPLAY_NAME(ContentData), dwLicenceMask);
|
|
|
|
pack->SetDLCMountIndex(m_iTotalDLCInstalled);
|
|
pack->SetDLCDeviceID(ContentData.DeviceID);
|
|
pack->updateLicenseMask(dwLicenceMask);
|
|
}
|
|
|
|
PlatformStorage.UnmountInstalledDLC();
|
|
}
|
|
++m_iTotalDLCInstalled;
|
|
mountNextDLC(iPad);
|
|
#endif
|
|
return 0;
|
|
}
|
|
#undef CONTENT_DATA_DISPLAY_NAME
|
|
|
|
void DLCController::handleDLC(DLCPack* pack) {
|
|
unsigned int dwFilesProcessed = 0;
|
|
#if defined(_WINDOWS64) || defined(__linux__)
|
|
std::vector<std::string> dlcFilenames;
|
|
#endif
|
|
PlatformStorage.GetMountedDLCFileList("DLCDrive", dlcFilenames);
|
|
for (int i = 0; i < dlcFilenames.size(); i++) {
|
|
app.m_dlcManager.readDLCDataFile(dwFilesProcessed, dlcFilenames[i],
|
|
pack);
|
|
}
|
|
if (dwFilesProcessed == 0) app.m_dlcManager.removePack(pack);
|
|
}
|
|
|
|
void DLCController::addCreditText(const char* lpStr) {
|
|
app.DebugPrintf("ADDING CREDIT - %s\n", lpStr);
|
|
SCreditTextItemDef* pCreditStruct = new SCreditTextItemDef;
|
|
pCreditStruct->m_eType = eSmallText;
|
|
pCreditStruct->m_iStringID[0] = NO_TRANSLATED_STRING;
|
|
pCreditStruct->m_iStringID[1] = NO_TRANSLATED_STRING;
|
|
pCreditStruct->m_Text = new char[strlen(lpStr) + 1];
|
|
strcpy((char*)pCreditStruct->m_Text, lpStr);
|
|
vDLCCredits.push_back(pCreditStruct);
|
|
}
|
|
|
|
bool DLCController::alreadySeenCreditText(const std::string& wstemp) {
|
|
for (unsigned int i = 0; i < m_vCreditText.size(); i++) {
|
|
std::string temp = m_vCreditText.at(i);
|
|
if (temp.compare(wstemp) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
m_vCreditText.push_back((char*)wstemp.c_str());
|
|
return false;
|
|
}
|
|
|
|
unsigned int DLCController::getDLCCreditsCount() {
|
|
return (unsigned int)vDLCCredits.size();
|
|
}
|
|
|
|
SCreditTextItemDef* DLCController::getDLCCredits(int iIndex) {
|
|
return vDLCCredits.at(iIndex);
|
|
}
|
|
|
|
#if defined(_WINDOWS64)
|
|
int32_t DLCController::registerDLCData(char* pType, char* pBannerName,
|
|
int iGender, uint64_t ullOfferID_Full,
|
|
uint64_t ullOfferID_Trial,
|
|
char* pFirstSkin,
|
|
unsigned int uiSortIndex, int iConfig,
|
|
char* pDataFile) {
|
|
int32_t hr = 0;
|
|
DLC_INFO* pDLCData = new DLC_INFO;
|
|
memset(pDLCData, 0, sizeof(DLC_INFO));
|
|
pDLCData->ullOfferID_Full = ullOfferID_Full;
|
|
pDLCData->ullOfferID_Trial = ullOfferID_Trial;
|
|
pDLCData->eDLCType = e_DLC_NotDefined;
|
|
pDLCData->iGender = iGender;
|
|
pDLCData->uiSortIndex = uiSortIndex;
|
|
pDLCData->iConfig = iConfig;
|
|
|
|
if (pBannerName != "") {
|
|
wcsncpy_s(pDLCData->wchBanner, pBannerName, MAX_BANNERNAME_SIZE);
|
|
}
|
|
if (pDataFile[0] != 0) {
|
|
wcsncpy_s(pDLCData->wchDataFile, pDataFile, MAX_BANNERNAME_SIZE);
|
|
}
|
|
|
|
if (pType != nullptr) {
|
|
if (strcmp(pType, "Skin") == 0) {
|
|
pDLCData->eDLCType = e_DLC_SkinPack;
|
|
} else if (strcmp(pType, "Gamerpic") == 0) {
|
|
pDLCData->eDLCType = e_DLC_Gamerpics;
|
|
} else if (strcmp(pType, "Theme") == 0) {
|
|
pDLCData->eDLCType = e_DLC_Themes;
|
|
} else if (strcmp(pType, "Avatar") == 0) {
|
|
pDLCData->eDLCType = e_DLC_AvatarItems;
|
|
} else if (strcmp(pType, "MashUpPack") == 0) {
|
|
pDLCData->eDLCType = e_DLC_MashupPacks;
|
|
DLCTextures_PackID[pDLCData->iConfig] = ullOfferID_Full;
|
|
} else if (strcmp(pType, "TexturePack") == 0) {
|
|
pDLCData->eDLCType = e_DLC_TexturePacks;
|
|
DLCTextures_PackID[pDLCData->iConfig] = ullOfferID_Full;
|
|
}
|
|
}
|
|
|
|
if (ullOfferID_Trial != 0ll) DLCInfo_Trial[ullOfferID_Trial] = pDLCData;
|
|
if (ullOfferID_Full != 0ll) DLCInfo_Full[ullOfferID_Full] = pDLCData;
|
|
if (pFirstSkin[0] != 0) DLCInfo_SkinName[pFirstSkin] = ullOfferID_Full;
|
|
|
|
return hr;
|
|
}
|
|
#elif defined(__linux__)
|
|
int32_t DLCController::registerDLCData(char* pType, char* pBannerName,
|
|
int iGender, uint64_t ullOfferID_Full,
|
|
uint64_t ullOfferID_Trial,
|
|
char* pFirstSkin,
|
|
unsigned int uiSortIndex, int iConfig,
|
|
char* pDataFile) {
|
|
fprintf(stderr,
|
|
"warning: DLCController::registerDLCData unimplemented for "
|
|
"platform `__linux__`\n");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
bool DLCController::getDLCFullOfferIDForSkinID(const std::string& FirstSkin,
|
|
uint64_t* pullVal) {
|
|
auto it = DLCInfo_SkinName.find(FirstSkin);
|
|
if (it == DLCInfo_SkinName.end()) {
|
|
return false;
|
|
} else {
|
|
*pullVal = (uint64_t)it->second;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool DLCController::getDLCFullOfferIDForPackID(const int iPackID,
|
|
uint64_t* pullVal) {
|
|
auto it = DLCTextures_PackID.find(iPackID);
|
|
if (it == DLCTextures_PackID.end()) {
|
|
*pullVal = (uint64_t)0;
|
|
return false;
|
|
} else {
|
|
*pullVal = (uint64_t)it->second;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
DLC_INFO* DLCController::getDLCInfoForTrialOfferID(
|
|
uint64_t ullOfferID_Trial) {
|
|
if (DLCInfo_Trial.size() > 0) {
|
|
auto it = DLCInfo_Trial.find(ullOfferID_Trial);
|
|
if (it == DLCInfo_Trial.end()) {
|
|
return nullptr;
|
|
} else {
|
|
return it->second;
|
|
}
|
|
} else
|
|
return nullptr;
|
|
}
|
|
|
|
DLC_INFO* DLCController::getDLCInfoForFullOfferID(uint64_t ullOfferID_Full) {
|
|
if (DLCInfo_Full.size() > 0) {
|
|
auto it = DLCInfo_Full.find(ullOfferID_Full);
|
|
if (it == DLCInfo_Full.end()) {
|
|
return nullptr;
|
|
} else {
|
|
return it->second;
|
|
}
|
|
} else
|
|
return nullptr;
|
|
}
|
|
|
|
DLC_INFO* DLCController::getDLCInfoTrialOffer(int iIndex) {
|
|
std::unordered_map<uint64_t, DLC_INFO*>::iterator it =
|
|
DLCInfo_Trial.begin();
|
|
for (int i = 0; i < iIndex; i++) {
|
|
++it;
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
DLC_INFO* DLCController::getDLCInfoFullOffer(int iIndex) {
|
|
std::unordered_map<uint64_t, DLC_INFO*>::iterator it = DLCInfo_Full.begin();
|
|
for (int i = 0; i < iIndex; i++) {
|
|
++it;
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
uint64_t DLCController::getDLCInfoTexturesFullOffer(int iIndex) {
|
|
std::unordered_map<int, uint64_t>::iterator it = DLCTextures_PackID.begin();
|
|
for (int i = 0; i < iIndex; i++) {
|
|
++it;
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
int DLCController::getDLCInfoTrialOffersCount() {
|
|
return (int)DLCInfo_Trial.size();
|
|
}
|
|
|
|
int DLCController::getDLCInfoFullOffersCount() {
|
|
return (int)DLCInfo_Full.size();
|
|
}
|
|
|
|
int DLCController::getDLCInfoTexturesOffersCount() {
|
|
return (int)DLCTextures_PackID.size();
|
|
}
|
|
|
|
unsigned int DLCController::addDLCRequest(eDLCMarketplaceType eType,
|
|
bool bPromote) {
|
|
{
|
|
std::lock_guard<std::mutex> lock(csDLCDownloadQueue);
|
|
|
|
int iPosition = 0;
|
|
for (auto it = m_DLCDownloadQueue.begin();
|
|
it != m_DLCDownloadQueue.end(); ++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
if (pCurrent->dwType == m_dwContentTypeA[eType]) {
|
|
if (pCurrent->eState == e_DLC_ContentState_Retrieving ||
|
|
pCurrent->eState == e_DLC_ContentState_Retrieved) {
|
|
return 0;
|
|
} else {
|
|
if (bPromote) {
|
|
m_DLCDownloadQueue.erase(m_DLCDownloadQueue.begin() +
|
|
iPosition);
|
|
m_DLCDownloadQueue.insert(m_DLCDownloadQueue.begin(),
|
|
pCurrent);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
iPosition++;
|
|
}
|
|
|
|
DLCRequest* pDLCreq = new DLCRequest;
|
|
pDLCreq->dwType = m_dwContentTypeA[eType];
|
|
pDLCreq->eState = e_DLC_ContentState_Idle;
|
|
m_DLCDownloadQueue.push_back(pDLCreq);
|
|
m_bAllDLCContentRetrieved = false;
|
|
}
|
|
|
|
app.DebugPrintf("[Consoles_App] Added DLC request.\n");
|
|
return 1;
|
|
}
|
|
|
|
bool DLCController::retrieveNextDLCContent() {
|
|
int primPad = PlatformProfile.GetPrimaryPad();
|
|
if (primPad == -1 || !PlatformProfile.IsSignedInLive(primPad)) {
|
|
return true;
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(csDLCDownloadQueue);
|
|
for (auto it = m_DLCDownloadQueue.begin();
|
|
it != m_DLCDownloadQueue.end(); ++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
if (pCurrent->eState == e_DLC_ContentState_Retrieving) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
for (auto it = m_DLCDownloadQueue.begin();
|
|
it != m_DLCDownloadQueue.end(); ++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
if (pCurrent->eState == e_DLC_ContentState_Idle) {
|
|
#if defined(_DEBUG)
|
|
app.DebugPrintf("RetrieveNextDLCContent - type = %d\n",
|
|
pCurrent->dwType);
|
|
#endif
|
|
IPlatformStorage::EDLCStatus status = PlatformStorage.GetDLCOffers(
|
|
PlatformProfile.GetPrimaryPad(),
|
|
[this](int iOfferC, std::uint32_t dwType, int pad) {
|
|
return dlcOffersReturned(iOfferC, dwType, pad);
|
|
},
|
|
pCurrent->dwType);
|
|
if (status == IPlatformStorage::EDLC_Pending) {
|
|
pCurrent->eState = e_DLC_ContentState_Retrieving;
|
|
} else {
|
|
app.DebugPrintf("RetrieveNextDLCContent - PROBLEM\n");
|
|
pCurrent->eState = e_DLC_ContentState_Retrieved;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
app.DebugPrintf("[Consoles_App] Finished downloading dlc content.\n");
|
|
return false;
|
|
}
|
|
|
|
bool DLCController::checkTMSDLCCanStop() {
|
|
std::lock_guard<std::mutex> lock(csTMSPPDownloadQueue);
|
|
for (auto it = m_TMSPPDownloadQueue.begin();
|
|
it != m_TMSPPDownloadQueue.end(); ++it) {
|
|
TMSPPRequest* pCurrent = *it;
|
|
if (pCurrent->eState == e_TMS_ContentState_Retrieving) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int DLCController::dlcOffersReturned(int iOfferC, std::uint32_t dwType,
|
|
int iPad) {
|
|
{
|
|
std::lock_guard<std::mutex> lock(csTMSPPDownloadQueue);
|
|
for (auto it = m_DLCDownloadQueue.begin();
|
|
it != m_DLCDownloadQueue.end(); ++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
if (pCurrent->dwType == static_cast<std::uint32_t>(dwType)) {
|
|
m_iDLCOfferC = iOfferC;
|
|
app.DebugPrintf(
|
|
"DLCOffersReturned - type %u, count %d - setting to "
|
|
"retrieved\n",
|
|
dwType, iOfferC);
|
|
pCurrent->eState = e_DLC_ContentState_Retrieved;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
eDLCContentType DLCController::find_eDLCContentType(std::uint32_t dwType) {
|
|
for (int i = 0; i < e_DLC_MAX; i++) {
|
|
if (m_dwContentTypeA[i] == dwType) {
|
|
return (eDLCContentType)i;
|
|
}
|
|
}
|
|
return (eDLCContentType)0;
|
|
}
|
|
|
|
bool DLCController::dlcContentRetrieved(eDLCMarketplaceType eType) {
|
|
std::lock_guard<std::mutex> lock(csDLCDownloadQueue);
|
|
for (auto it = m_DLCDownloadQueue.begin(); it != m_DLCDownloadQueue.end();
|
|
++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
if ((pCurrent->dwType == m_dwContentTypeA[eType]) &&
|
|
(pCurrent->eState == e_DLC_ContentState_Retrieved)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DLCController::tickDLCOffersRetrieved() {
|
|
if (!m_bAllDLCContentRetrieved) {
|
|
if (!retrieveNextDLCContent()) {
|
|
app.DebugPrintf("[Consoles_App] All content retrieved.\n");
|
|
m_bAllDLCContentRetrieved = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DLCController::clearAndResetDLCDownloadQueue() {
|
|
app.DebugPrintf("[Consoles_App] Clear and reset download queue.\n");
|
|
|
|
int iPosition = 0;
|
|
{
|
|
std::lock_guard<std::mutex> lock(csTMSPPDownloadQueue);
|
|
for (auto it = m_DLCDownloadQueue.begin();
|
|
it != m_DLCDownloadQueue.end(); ++it) {
|
|
DLCRequest* pCurrent = *it;
|
|
delete pCurrent;
|
|
iPosition++;
|
|
}
|
|
m_DLCDownloadQueue.clear();
|
|
m_bAllDLCContentRetrieved = true;
|
|
}
|
|
}
|
|
|
|
bool DLCController::retrieveNextTMSPPContent() { return false; }
|
|
|
|
void DLCController::tickTMSPPFilesRetrieved() {
|
|
if (m_bTickTMSDLCFiles && !m_bAllTMSContentRetrieved) {
|
|
if (retrieveNextTMSPPContent() == false) {
|
|
m_bAllTMSContentRetrieved = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DLCController::clearTMSPPFilesRetrieved() {
|
|
int iPosition = 0;
|
|
{
|
|
std::lock_guard<std::mutex> lock(csTMSPPDownloadQueue);
|
|
for (auto it = m_TMSPPDownloadQueue.begin();
|
|
it != m_TMSPPDownloadQueue.end(); ++it) {
|
|
TMSPPRequest* pCurrent = *it;
|
|
delete pCurrent;
|
|
iPosition++;
|
|
}
|
|
m_TMSPPDownloadQueue.clear();
|
|
m_bAllTMSContentRetrieved = true;
|
|
}
|
|
}
|
|
|
|
unsigned int DLCController::addTMSPPFileTypeRequest(eDLCContentType eType,
|
|
bool bPromote) {
|
|
std::lock_guard<std::mutex> lock(csTMSPPDownloadQueue);
|
|
|
|
if (eType == e_DLC_TexturePackData) {
|
|
int iCount = getDLCInfoFullOffersCount();
|
|
|
|
for (int i = 0; i < iCount; i++) {
|
|
DLC_INFO* pDLC = getDLCInfoFullOffer(i);
|
|
|
|
if ((pDLC->eDLCType == e_DLC_TexturePacks) ||
|
|
(pDLC->eDLCType == e_DLC_MashupPacks)) {
|
|
if (pDLC->wchDataFile[0] != 0) {
|
|
{
|
|
bool bPresent = app.IsFileInTPD(pDLC->iConfig);
|
|
|
|
if (!bPresent) {
|
|
bool bAlreadyInQueue = false;
|
|
for (auto it = m_TMSPPDownloadQueue.begin();
|
|
it != m_TMSPPDownloadQueue.end(); ++it) {
|
|
TMSPPRequest* pCurrent = *it;
|
|
if (strcmp(pDLC->wchDataFile,
|
|
pCurrent->wchFilename) == 0) {
|
|
bAlreadyInQueue = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bAlreadyInQueue) {
|
|
TMSPPRequest* pTMSPPreq = new TMSPPRequest;
|
|
pTMSPPreq->CallbackFunc =
|
|
&DLCController::tmsPPFileReturned;
|
|
pTMSPPreq->lpCallbackParam = this;
|
|
pTMSPPreq->eStorageFacility =
|
|
IPlatformStorage::eGlobalStorage_Title;
|
|
pTMSPPreq->eFileTypeVal =
|
|
IPlatformStorage::TMS_FILETYPE_BINARY;
|
|
memcpy(pTMSPPreq->wchFilename,
|
|
pDLC->wchDataFile,
|
|
sizeof(char) * MAX_BANNERNAME_SIZE);
|
|
pTMSPPreq->eType = e_DLC_TexturePackData;
|
|
pTMSPPreq->eState = e_TMS_ContentState_Queued;
|
|
m_bAllTMSContentRetrieved = false;
|
|
m_TMSPPDownloadQueue.push_back(pTMSPPreq);
|
|
}
|
|
} else {
|
|
app.DebugPrintf(
|
|
"Texture data already present in the TPD\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
int iCount;
|
|
iCount = getDLCInfoFullOffersCount();
|
|
for (int i = 0; i < iCount; i++) {
|
|
DLC_INFO* pDLC = getDLCInfoFullOffer(i);
|
|
if (pDLC->eDLCType == eType) {
|
|
char* cString = pDLC->wchBanner;
|
|
{
|
|
bool bPresent = app.IsFileInMemoryTextures(cString);
|
|
|
|
if (!bPresent) {
|
|
bool bAlreadyInQueue = false;
|
|
for (auto it = m_TMSPPDownloadQueue.begin();
|
|
it != m_TMSPPDownloadQueue.end(); ++it) {
|
|
TMSPPRequest* pCurrent = *it;
|
|
if (strcmp(pDLC->wchBanner,
|
|
pCurrent->wchFilename) == 0) {
|
|
bAlreadyInQueue = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bAlreadyInQueue) {
|
|
TMSPPRequest* pTMSPPreq = new TMSPPRequest;
|
|
memset(pTMSPPreq, 0, sizeof(TMSPPRequest));
|
|
pTMSPPreq->CallbackFunc =
|
|
&DLCController::tmsPPFileReturned;
|
|
pTMSPPreq->lpCallbackParam = this;
|
|
pTMSPPreq->eStorageFacility =
|
|
IPlatformStorage::eGlobalStorage_Title;
|
|
pTMSPPreq->eFileTypeVal =
|
|
IPlatformStorage::TMS_FILETYPE_BINARY;
|
|
memcpy(pTMSPPreq->wchFilename, pDLC->wchBanner,
|
|
sizeof(char) * MAX_BANNERNAME_SIZE);
|
|
pTMSPPreq->eType = eType;
|
|
pTMSPPreq->eState = e_TMS_ContentState_Queued;
|
|
m_bAllTMSContentRetrieved = false;
|
|
m_TMSPPDownloadQueue.push_back(pTMSPPreq);
|
|
app.DebugPrintf(
|
|
"===m_TMSPPDownloadQueue Adding %s, q size is "
|
|
"%d\n",
|
|
pTMSPPreq->wchFilename,
|
|
m_TMSPPDownloadQueue.size());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int DLCController::tmsPPFileReturned(void* pParam, int iPad, int iUserData,
|
|
IPlatformStorage::PTMSPP_FILEDATA pFileData,
|
|
const char* szFilename) {
|
|
DLCController* pClass = (DLCController*)pParam;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(pClass->csTMSPPDownloadQueue);
|
|
for (auto it = pClass->m_TMSPPDownloadQueue.begin();
|
|
it != pClass->m_TMSPPDownloadQueue.end(); ++it) {
|
|
TMSPPRequest* pCurrent = *it;
|
|
#if defined(_WINDOWS64)
|
|
char szFile[MAX_TMSFILENAME_SIZE];
|
|
strncpy(szFile, pCurrent->wchFilename, MAX_TMSFILENAME_SIZE);
|
|
|
|
if (strcmp(szFilename, szFile) == 0)
|
|
#endif
|
|
{
|
|
pCurrent->eState = e_TMS_ContentState_Retrieved;
|
|
|
|
if (pFileData != nullptr) {
|
|
switch (pCurrent->eType) {
|
|
case e_DLC_TexturePackData: {
|
|
app.DebugPrintf("--- Got texturepack data %s\n",
|
|
pCurrent->wchFilename);
|
|
int iConfig =
|
|
app.GetTPConfigVal(pCurrent->wchFilename);
|
|
app.AddMemoryTPDFile(iConfig, pFileData->pbData,
|
|
pFileData->size);
|
|
} break;
|
|
default:
|
|
app.DebugPrintf("--- Got image data - %s\n",
|
|
pCurrent->wchFilename);
|
|
app.AddMemoryTextureFile(pCurrent->wchFilename,
|
|
pFileData->pbData,
|
|
pFileData->size);
|
|
break;
|
|
}
|
|
} else {
|
|
app.DebugPrintf("TMSImageReturned failed (%s)...\n",
|
|
szFilename);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|