801 lines
23 KiB
C++
801 lines
23 KiB
C++
#include "SaveMigration_multiplayer.h"
|
|
|
|
// Rage headers
|
|
#include "rline/savemigration/rlsavemigration.h"
|
|
|
|
// network headers
|
|
#include "Network/NetworkInterface.h"
|
|
#include "scene/DynamicEntity.h"
|
|
|
|
#if __BANK
|
|
#include "bank/bkmgr.h"
|
|
#include "bank/bank.h"
|
|
#include "bank/title.h"
|
|
#include "data/callback.h"
|
|
#include "system/bit.h"
|
|
#endif // __BANK
|
|
|
|
SAVEGAME_OPTIMISATIONS()
|
|
|
|
#if __BANK
|
|
enum eSaveMigrationBankRequestsFlags
|
|
{
|
|
SMBR_NONE = BIT0,
|
|
SMBR_GET_ACCOUNTS = BIT1,
|
|
SMBR_MIGRATE_ACCOUNT = BIT2,
|
|
SMBR_GET_STATUS = BIT3,
|
|
};
|
|
|
|
const char * g_SavemigrationMPAccountsOverrideNames[6] = {
|
|
"Zero Accounts",
|
|
"One Account",
|
|
"Two Account",
|
|
"Account Unavaliable",
|
|
"Account Error",
|
|
"Error",
|
|
};
|
|
const char * g_SavemigrationMPStatusOverrideNames[6] = {
|
|
"NONE",
|
|
"INPROGRESS",
|
|
"FINISHED",
|
|
"CANCELED",
|
|
"ROLLEDBACK",
|
|
"Error",
|
|
};
|
|
|
|
bool g_SavemigrationMPAccountOverrideEnabled = false;
|
|
int g_SavemigrationMPAccountOverride = 0;
|
|
bool g_SavemigrationMPAccountMigrationOverrideEnabled = false;
|
|
int g_SavemigrationMPAccountMigrationOverride = 0;
|
|
bool g_SavemigrationMPAccountStatusOverrideEnabled = false;
|
|
int g_SavemigrationMPAccountStatusOverride = 0;
|
|
|
|
PARAM(SavemigrationMPEnabledOverride, "Enable | Disable the multiplayer save migration");
|
|
|
|
PARAM(SavemigrationMPAccountsOverride, "Save migration multiplayer accounts overrider (0:Zero Accounts, 1:One Account 2:Two Accounts 3:Account Unavaliable 4:Account Error 5:Error)");
|
|
PARAM(SavemigrationMPMigrationOverride, "Save migration multiplayer migration override (0:NONE, 1:INPROGRESS, 2:FINISHED 3:CANCELED 4:ROLLEDBACK 5:ERROR)");
|
|
PARAM(SavemigrationMPStatusOverride, "Save migration multiplayer status override (0:NONE, 1:INPROGRESS, 2:FINISHED 3:CANCELED 4:ROLLEDBACK 5:ERROR)");
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CSaveMigrationGetAccounts::CSaveMigrationGetAccounts()
|
|
: m_accounts()
|
|
{}
|
|
|
|
bool CSaveMigrationGetAccounts::OnConfigure()
|
|
{
|
|
m_accounts.Reset();
|
|
|
|
#if __BANK
|
|
if (g_SavemigrationMPAccountOverrideEnabled)
|
|
{
|
|
m_netStatus.Finished();
|
|
switch (g_SavemigrationMPAccountOverride)
|
|
{
|
|
default:
|
|
case 0:
|
|
|
|
break;
|
|
case 2:
|
|
{
|
|
rlSaveMigrationMPAccount account;
|
|
account.m_AccountId = 996352064;
|
|
account.m_Available = true;
|
|
|
|
safecpy(account.m_Gamertag, "Test Gamertag 1", rage::RLSM_MAX_GAMERTAG_CHARS);
|
|
safecpy(account.m_GamerHandle, "Test GamerHandle 1", rage::RLSM_MAX_GAMERHANDLE_CHARS);
|
|
safecpy(account.m_Platform, "xboxone", rage::RLSM_MAX_PLATFORM_CHARS);
|
|
|
|
m_accounts.Push(account);
|
|
|
|
// Fall through to add the 2nd account
|
|
}
|
|
case 1:
|
|
{
|
|
rlSaveMigrationMPAccount account;
|
|
account.m_AccountId = 996352063;
|
|
account.m_Available = true;
|
|
|
|
safecpy(account.m_Gamertag, "Test Gamertag", rage::RLSM_MAX_GAMERTAG_CHARS);
|
|
safecpy(account.m_GamerHandle, "Test GamerHandle", rage::RLSM_MAX_GAMERHANDLE_CHARS);
|
|
safecpy(account.m_Platform, "ps4", rage::RLSM_MAX_PLATFORM_CHARS);
|
|
|
|
m_accounts.Push(account);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
rlSaveMigrationMPAccount account;
|
|
account.m_AccountId = 996352063;
|
|
account.m_Available = false;
|
|
|
|
safecpy(account.m_Gamertag, "Test Gamertag Unavaliable", rage::RLSM_MAX_GAMERTAG_CHARS);
|
|
safecpy(account.m_GamerHandle, "Test GamerHandle", rage::RLSM_MAX_GAMERHANDLE_CHARS);
|
|
safecpy(account.m_Platform, "ps4", rage::RLSM_MAX_PLATFORM_CHARS);
|
|
|
|
safecpy(account.m_ErrorCode, "ERROR_ALREADY_DONE", rage::RLSM_MAX_ERROR_CODE);
|
|
|
|
m_accounts.Push(account);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
rlSaveMigrationMPAccount account;
|
|
account.m_AccountId = 996352063;
|
|
account.m_Available = false;
|
|
|
|
safecpy(account.m_Gamertag, "Test Gamertag Error", rage::RLSM_MAX_GAMERTAG_CHARS);
|
|
safecpy(account.m_GamerHandle, "Test GamerHandle", rage::RLSM_MAX_GAMERHANDLE_CHARS);
|
|
safecpy(account.m_Platform, "ps4", rage::RLSM_MAX_PLATFORM_CHARS);
|
|
|
|
safecpy(account.m_ErrorCode, "ERROR_NOT_AVAILABLE", rage::RLSM_MAX_ERROR_CODE);
|
|
|
|
m_accounts.Push(account);
|
|
break;
|
|
}
|
|
break;
|
|
case 5:
|
|
m_netStatus.Failed();
|
|
break;
|
|
}
|
|
savemigrationDebug1("CSaveMigrationGetAccounts::OnConfigure : OVERRIDE %d", g_SavemigrationMPAccountOverride);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
savemigrationDebug1("CSaveMigrationGetAccounts::OnConfigure : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
return rlSaveMigration::GetMPAccounts(NetworkInterface::GetLocalGamerIndex(), &m_accounts, &m_netStatus);
|
|
}
|
|
|
|
void CSaveMigrationGetAccounts::OnCompleted()
|
|
{
|
|
m_status = SM_STATUS_OK;
|
|
|
|
savemigrationDebug1("CSaveMigrationGetAccounts::OnCompleted : localGamerIndex %d : Accounts Count %d", NetworkInterface::GetLocalGamerIndex(), m_accounts.GetCount());
|
|
}
|
|
|
|
void CSaveMigrationGetAccounts::OnFailed()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationGetAccounts::OnFailed : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
void CSaveMigrationGetAccounts::OnCanceled()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationGetAccounts::OnCanceled : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CSaveMigrationMigrateAccount::CSaveMigrationMigrateAccount()
|
|
: m_sourceAccount(RLSM_INVALID_ACCOUNT_ID)
|
|
, m_sourcePlatform()
|
|
, m_transactionAttempts(0)
|
|
, m_transactionPollTime(SAVEMIGRATION_DEFAULT_POOL_TIME_MS)
|
|
, m_transactionMaxAttempts(SAVEMIGRATION_DEFAULT_NUM_ATTEMPTS)
|
|
, m_transactionTimeStamp(0)
|
|
, m_transactionId(RLSM_INVALID_TRANSACTION_ID)
|
|
, m_transactionState()
|
|
{}
|
|
|
|
bool CSaveMigrationMigrateAccount::Setup(const int sourceAccountid, const char* sourcePlatform, u32 pollTimeIncrementMs, u32 maxPollingAttempts)
|
|
{
|
|
if (!IsActive())
|
|
{
|
|
m_sourceAccount = sourceAccountid;
|
|
m_sourcePlatform = sourcePlatform;
|
|
m_transactionPollTime = pollTimeIncrementMs;
|
|
m_transactionMaxAttempts = maxPollingAttempts;
|
|
m_transactionAttempts = 0;
|
|
m_transactionTimeStamp = 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CSaveMigrationMigrateAccount::OnWait()
|
|
{
|
|
#if __BANK
|
|
if (g_SavemigrationMPAccountMigrationOverrideEnabled)
|
|
{
|
|
CSaveMigrationTask::OnWait(); // Run through the base code to handle task completion
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (m_transactionId == RLSM_INVALID_TRANSACTION_ID)
|
|
{
|
|
if (m_netStatus.GetStatus() == rage::netStatus::NET_STATUS_SUCCEEDED)
|
|
{
|
|
if (m_transactionState.InProgress())
|
|
{
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnWait Migration Started : localGamerIndex %d : transactionId %d", NetworkInterface::GetLocalGamerIndex(), m_transactionState.GetTransactionId());
|
|
savemigrationAssertf(m_transactionState.GetTransactionId() != RLSM_INVALID_TRANSACTION_ID, "CSaveMigrationMigrateAccount::OnWait : Transaction ID is invalid");
|
|
|
|
m_netStatus.Reset();
|
|
m_transactionAttempts = 1;
|
|
m_transactionTimeStamp = fwTimer::GetTimeInMilliseconds();
|
|
m_transactionId = m_transactionState.GetTransactionId();
|
|
}
|
|
else
|
|
{
|
|
CSaveMigrationTask::OnWait(); // Run through the base code to handle task completion
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CSaveMigrationTask::OnWait(); // Run through the base code to handle task completion
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_netStatus.GetStatus() == rage::netStatus::NET_STATUS_NONE)
|
|
{
|
|
if (m_transactionAttempts > m_transactionMaxAttempts)
|
|
{
|
|
savemigrationWarning("CSaveMigrationMigrateAccount::OnWait Migration State Requested reached max polling attempts %d : %dms", m_transactionAttempts, m_transactionAttempts * m_transactionPollTime);
|
|
|
|
m_taskState = SM_TASK_DONE;
|
|
m_status = SM_STATUS_ERROR;
|
|
m_netStatus.Reset();
|
|
|
|
OnFailed();
|
|
}
|
|
else if ((fwTimer::GetTimeInMilliseconds() - m_transactionTimeStamp) > Min((m_transactionAttempts * m_transactionPollTime), (u32)SAVEMIGRATION_DEFAULT_MAX_POOL_TIME_MS)) // Poll once to see if the migration has competed
|
|
{
|
|
m_transactionState.Reset();
|
|
m_transactionAttempts++;
|
|
|
|
if (!rlSaveMigration::GetTransactionState(NetworkInterface::GetLocalGamerIndex(), m_transactionId, &m_transactionState, &m_netStatus))
|
|
{
|
|
m_taskState = SM_TASK_DONE;
|
|
m_status = SM_STATUS_ERROR;
|
|
m_netStatus.Reset();
|
|
|
|
OnFailed();
|
|
}
|
|
else
|
|
{
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnWait Migration State Requested : localGamerIndex %d : transactionId %d", NetworkInterface::GetLocalGamerIndex(), m_transactionId);
|
|
}
|
|
}
|
|
}
|
|
else if (m_netStatus.GetStatus() == rage::netStatus::NET_STATUS_SUCCEEDED)
|
|
{
|
|
if (m_transactionState.InProgress())
|
|
{
|
|
m_netStatus.Reset();
|
|
m_transactionTimeStamp = fwTimer::GetTimeInMilliseconds();
|
|
}
|
|
else
|
|
{
|
|
CSaveMigrationTask::OnWait(); // Run through the base code to handle task completion
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CSaveMigrationTask::OnWait(); // Run through the base code to handle task completion
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CSaveMigrationMigrateAccount::OnConfigure()
|
|
{
|
|
m_transactionState.Reset();
|
|
|
|
#if __BANK
|
|
if (g_SavemigrationMPAccountMigrationOverrideEnabled)
|
|
{
|
|
m_netStatus.Finished();
|
|
switch (g_SavemigrationMPAccountMigrationOverride)
|
|
{
|
|
default:
|
|
case rage::RLSM_STATE_INVALID:
|
|
m_transactionState.Reset();
|
|
break;
|
|
case rage::RLSM_STATE_INPROGRESS:
|
|
m_transactionState.Set(996352063, true, NULL);
|
|
break;
|
|
case rage::RLSM_STATE_FINISHED:
|
|
m_transactionState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Finished");
|
|
break;
|
|
case rage::RLSM_STATE_CANCELED:
|
|
m_transactionState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Canceled");
|
|
break;
|
|
case rage::RLSM_STATE_ROLLEDBACK:
|
|
m_transactionState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "RolledBack");
|
|
break;
|
|
case rage::RLSM_STATE_ERROR:
|
|
m_transactionState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Error");
|
|
break;
|
|
}
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnConfigure : OVERRIDE %d : state %d : %s", g_SavemigrationMPAccountMigrationOverride, m_transactionState.GetStateId(), m_transactionState.GetState());
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnConfigure : localGamerIndex %d : sourceAccount %d : sourcePlatform %s", NetworkInterface::GetLocalGamerIndex(), m_sourceAccount, m_sourcePlatform.c_str());
|
|
return rlSaveMigration::MigrateMPAccount(NetworkInterface::GetLocalGamerIndex(), m_sourceAccount, m_sourcePlatform.c_str(), &m_transactionState, &m_netStatus);
|
|
}
|
|
|
|
void CSaveMigrationMigrateAccount::OnCompleted()
|
|
{
|
|
switch (m_transactionState.GetStateId())
|
|
{
|
|
case rage::RLSM_STATE_INVALID:
|
|
m_status = SM_STATUS_NONE;
|
|
break;
|
|
case rage::RLSM_STATE_INPROGRESS:
|
|
m_status = SM_STATUS_INPROGRESS;
|
|
break;
|
|
case rage::RLSM_STATE_FINISHED:
|
|
m_status = SM_STATUS_OK;
|
|
break;
|
|
case rage::RLSM_STATE_CANCELED:
|
|
m_status = SM_STATUS_CANCELED;
|
|
break;
|
|
case rage::RLSM_STATE_ROLLEDBACK:
|
|
m_status = SM_STATUS_ROLLEDBACK;
|
|
break;
|
|
case rage::RLSM_STATE_ERROR:
|
|
m_status = SM_STATUS_ERROR;
|
|
break;
|
|
}
|
|
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnCompleted : localGamerIndex %d : status %s", NetworkInterface::GetLocalGamerIndex(), GetSaveMigrationStatusChar(m_status));
|
|
}
|
|
|
|
void CSaveMigrationMigrateAccount::OnFailed()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnFailed : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
void CSaveMigrationMigrateAccount::OnCanceled()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationMigrateAccount::OnCanceled : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CSaveMigrationGetMPStatus::CSaveMigrationGetMPStatus()
|
|
:m_playState()
|
|
,m_migrated(false)
|
|
{}
|
|
|
|
bool CSaveMigrationGetMPStatus::OnConfigure()
|
|
{
|
|
#if __BANK
|
|
if (g_SavemigrationMPAccountStatusOverrideEnabled)
|
|
{
|
|
m_netStatus.Finished();
|
|
switch (g_SavemigrationMPAccountStatusOverride)
|
|
{
|
|
default:
|
|
case rage::RLSM_STATE_INVALID:
|
|
m_playState.Reset();
|
|
break;
|
|
case rage::RLSM_STATE_INPROGRESS:
|
|
m_playState.Set(996352063, true, NULL);
|
|
break;
|
|
case rage::RLSM_STATE_FINISHED:
|
|
m_playState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Finished");
|
|
break;
|
|
case rage::RLSM_STATE_CANCELED:
|
|
m_playState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Canceled");
|
|
break;
|
|
case rage::RLSM_STATE_ROLLEDBACK:
|
|
m_playState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "RolledBack");
|
|
break;
|
|
case rage::RLSM_STATE_ERROR:
|
|
m_playState.Set(rage::RLSM_INVALID_TRANSACTION_ID, false, "Error");
|
|
break;
|
|
}
|
|
savemigrationDebug1("CSaveMigrationGetMPStatus::OnConfigure : OVERRIDE %d : state %d : %s", g_SavemigrationMPAccountStatusOverride, m_playState.GetStateId(), m_playState.GetState());
|
|
return true;
|
|
}
|
|
#endif
|
|
savemigrationDebug1("CSaveMigrationGetMPStatus::OnConfigure : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
return rlSaveMigration::GetState(NetworkInterface::GetLocalGamerIndex(), &m_playState, &m_netStatus);
|
|
}
|
|
|
|
void CSaveMigrationGetMPStatus::OnCompleted()
|
|
{
|
|
int stateId = m_playState.GetStateId();
|
|
switch (stateId)
|
|
{
|
|
case rage::RLSM_STATE_INVALID:
|
|
m_status = SM_STATUS_OK; // No transtaction information returned
|
|
break;
|
|
case rage::RLSM_STATE_INPROGRESS:
|
|
m_status = SM_STATUS_INPROGRESS;
|
|
break;
|
|
case rage::RLSM_STATE_FINISHED:
|
|
m_status = SM_STATUS_OK;
|
|
m_migrated = true;
|
|
break;
|
|
case rage::RLSM_STATE_CANCELED:
|
|
m_status = SM_STATUS_CANCELED;
|
|
break;
|
|
case rage::RLSM_STATE_ROLLEDBACK:
|
|
m_status = SM_STATUS_ROLLEDBACK;
|
|
break;
|
|
case rage::RLSM_STATE_ERROR:
|
|
m_status = SM_STATUS_ERROR;
|
|
break;
|
|
}
|
|
|
|
savemigrationDebug1("CSaveMigrationGetMPStatus::OnCompleted : localGamerIndex %d : status %d : %s : %s", NetworkInterface::GetLocalGamerIndex(), m_playState.GetStateId(), m_playState.GetState(), GetSaveMigrationStatusChar(m_status));
|
|
}
|
|
|
|
void CSaveMigrationGetMPStatus::OnFailed()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationGetMPStatus::OnFailed : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
void CSaveMigrationGetMPStatus::OnCanceled()
|
|
{
|
|
savemigrationDebug1("CSaveMigrationGetMPStatus::OnCanceled : localGamerIndex %d", NetworkInterface::GetLocalGamerIndex());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CSaveMigration_multiplayer::CSaveMigration_multiplayer()
|
|
: m_accountsTask()
|
|
, m_migrateTask()
|
|
, m_playStateTask()
|
|
, m_queue()
|
|
, m_enabled(true)
|
|
{
|
|
#if __BANK
|
|
m_BkRequest = SMBR_NONE;
|
|
m_BkGroup = nullptr;
|
|
m_bBankCreated = false;
|
|
|
|
m_BkAccountsGroup = nullptr;
|
|
m_bBankAccountsCreated = false;
|
|
#endif
|
|
}
|
|
|
|
CSaveMigration_multiplayer::~CSaveMigration_multiplayer()
|
|
{
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Init()
|
|
{
|
|
m_enabled = !Tunables::GetInstance().TryAccess(CD_GLOBAL_HASH, ATSTRINGHASH("SAVEMIGRATION_DISABLED", 0xFB18BC93), false) ||
|
|
!Tunables::GetInstance().TryAccess(CD_GLOBAL_HASH, ATSTRINGHASH("SAVEMIGRATION_DISABLE_MULTIPLAYER", 0x4BF38BBB), false);
|
|
|
|
#if __BANK
|
|
int iEnabled;
|
|
if (PARAM_SavemigrationMPEnabledOverride.Get(iEnabled))
|
|
{
|
|
m_enabled = iEnabled > 0;
|
|
}
|
|
g_SavemigrationMPAccountOverrideEnabled = PARAM_SavemigrationMPAccountsOverride.Get(g_SavemigrationMPAccountOverride);
|
|
g_SavemigrationMPAccountMigrationOverrideEnabled = PARAM_SavemigrationMPMigrationOverride.Get(g_SavemigrationMPAccountMigrationOverride);
|
|
g_SavemigrationMPAccountStatusOverrideEnabled = PARAM_SavemigrationMPStatusOverride.Get(g_SavemigrationMPAccountStatusOverride);
|
|
#endif
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Shutdown()
|
|
{
|
|
Cancel();
|
|
|
|
m_queue.Reset();
|
|
|
|
m_accountsTask.Reset();
|
|
m_migrateTask.Reset();
|
|
m_playStateTask.Reset();
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Update()
|
|
{
|
|
if (!m_queue.IsEmpty())
|
|
{
|
|
CSaveMigrationTask* task = m_queue.Top();
|
|
if (task->IsActive())
|
|
{
|
|
task->Update();
|
|
}
|
|
else
|
|
{
|
|
m_queue.Pop();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CSaveMigration_multiplayer::RequestAccounts()
|
|
{
|
|
if (m_enabled && m_accountsTask.Start())
|
|
{
|
|
m_queue.Push(&m_accountsTask);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
eSaveMigrationStatus CSaveMigration_multiplayer::GetAccountsStatus() const
|
|
{
|
|
return m_accountsTask.GetStatus();
|
|
}
|
|
|
|
const rlSaveMigrationMPAccountsArray& CSaveMigration_multiplayer::GetAccounts() const
|
|
{
|
|
return m_accountsTask.GetAccounts();
|
|
}
|
|
|
|
bool CSaveMigration_multiplayer::MigrateAccount(const int sourceAccountid, const char* sourcePlatform, u32 pollTimeIncrementMs, u32 maxPollingAttempts)
|
|
{
|
|
if (m_enabled && m_migrateTask.Setup(sourceAccountid, sourcePlatform, pollTimeIncrementMs, maxPollingAttempts) && m_migrateTask.Start())
|
|
{
|
|
m_queue.Push(&m_migrateTask);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
eSaveMigrationStatus CSaveMigration_multiplayer::GetMigrationStatus() const
|
|
{
|
|
return m_migrateTask.GetStatus();
|
|
}
|
|
|
|
bool CSaveMigration_multiplayer::RequestStatus()
|
|
{
|
|
if (m_enabled && m_playStateTask.Start())
|
|
{
|
|
m_queue.Push(&m_playStateTask);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
eSaveMigrationStatus CSaveMigration_multiplayer::GetStatus(bool* out_migrated) const
|
|
{
|
|
if (out_migrated && m_playStateTask.GetStatus()== eSaveMigrationStatus::SM_STATUS_OK)
|
|
{
|
|
*out_migrated = m_playStateTask.HasMigrated();
|
|
}
|
|
return m_playStateTask.GetStatus();
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Cancel()
|
|
{
|
|
m_accountsTask.Cancel();
|
|
m_migrateTask.Cancel();
|
|
m_playStateTask.Cancel();
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::SetChosenMpCharacterSlot(const int chosenMpCharacterSlot)
|
|
{
|
|
m_chosenMpCharacterSlot = chosenMpCharacterSlot;
|
|
}
|
|
|
|
#if __BANK
|
|
void CSaveMigration_multiplayer::Bank_InitWidgets(bkBank* bank)
|
|
{
|
|
if (bank)
|
|
{
|
|
m_BkGroup = bank->PushGroup("Multiplayer", false);
|
|
{
|
|
bank->AddButton("Create MP widgets", datCallback(MFA(CSaveMigration_multiplayer::Bank_CreateWidgets), (datBase*)this));
|
|
}
|
|
bank->PopGroup();
|
|
}
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_ShutdownWidgets(bkBank* bank)
|
|
{
|
|
if (bank && m_BkGroup)
|
|
{
|
|
bank->DeleteGroup(*m_BkGroup);
|
|
}
|
|
m_BkGroup = nullptr;
|
|
m_bBankCreated = false;
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_CreateWidgets()
|
|
{
|
|
bkBank* bank = BANKMGR.FindBank("SaveMigration");
|
|
if (bank && m_BkGroup)
|
|
{
|
|
bank->DeleteGroup(*m_BkGroup);
|
|
|
|
m_bBankAccountsCreated = false;
|
|
m_BkAccountsGroup = nullptr;
|
|
}
|
|
m_BkGroup = nullptr;
|
|
m_bBankCreated = false;
|
|
|
|
if ((!m_bBankCreated) && bank && !m_BkGroup)
|
|
{
|
|
m_bBankCreated = true;
|
|
|
|
m_BkGroup = bank->PushGroup("Multiplayer", true);
|
|
{
|
|
bank->PushGroup("Overrides", true, "Lets you force the return result from the request.");
|
|
{
|
|
bank->AddToggle("Enable", &g_SavemigrationMPAccountOverrideEnabled);
|
|
bank->AddCombo("Account Request Result", &g_SavemigrationMPAccountOverride, 6, &g_SavemigrationMPAccountsOverrideNames[0], 0, NullCB, "");
|
|
#if IS_GEN9_PLATFORM
|
|
bank->AddSeparator();
|
|
bank->AddToggle("Enable", &g_SavemigrationMPAccountMigrationOverrideEnabled);
|
|
bank->AddCombo("Migrate Account Result", &g_SavemigrationMPAccountMigrationOverride, 6, &g_SavemigrationMPStatusOverrideNames[0], 0, NullCB, "");
|
|
bank->AddSeparator();
|
|
bank->AddToggle("Enable", &g_SavemigrationMPAccountStatusOverrideEnabled);
|
|
bank->AddCombo("Account Status Result", &g_SavemigrationMPAccountStatusOverride, 6, &g_SavemigrationMPStatusOverrideNames[0], 0, NullCB, "");
|
|
bank->AddSeparator();
|
|
#endif
|
|
}
|
|
bank->PopGroup();
|
|
|
|
bank->AddSeparator();
|
|
bank->PushGroup("Tests", true, "Use to test the MP save migration API");
|
|
{
|
|
bank->AddButton("Request Accounts", datCallback(MFA(CSaveMigration_multiplayer::Bank_RequestAccounts), (datBase*)this));
|
|
{
|
|
strcpy(m_accountstatus, "None");
|
|
m_accountsCount = 0;
|
|
|
|
bank->AddText("Status", m_accountstatus, 32, true);
|
|
bank->AddText("Count", &m_accountsCount, true);
|
|
|
|
if (!m_bBankAccountsCreated && !m_BkAccountsGroup)
|
|
{
|
|
m_bBankAccountsCreated = true;
|
|
m_BkAccountsGroup = bank->PushGroup("Accounts", false);
|
|
// Will be filled in when they accounts are pulled
|
|
bank->PopGroup();
|
|
}
|
|
}
|
|
|
|
#if IS_GEN9_PLATFORM
|
|
bank->AddButton("Migrate Account", datCallback(MFA(CSaveMigration_multiplayer::Bank_MigrateAccount), (datBase*)this));
|
|
{
|
|
strcpy(m_migrationstatus, "None");
|
|
m_migrationAccountid = 0;
|
|
strcpy(m_migrationPlatform, "");
|
|
|
|
bank->AddText("Status", m_migrationstatus, 32, true);
|
|
bank->AddText("Accountid", &m_migrationAccountid, false);
|
|
bank->AddText("Platform", m_migrationPlatform, 32, false);
|
|
}
|
|
|
|
bank->AddButton("Request Status", datCallback(MFA(CSaveMigration_multiplayer::Bank_RequestStatus), (datBase*)this));
|
|
{
|
|
strcpy(m_playstatus, "None");
|
|
m_playstatusTransactionid = 0;
|
|
|
|
bank->AddText("Status", m_playstatus, 32, true);
|
|
bank->AddText("Transactionid", &m_playstatusTransactionid, false);
|
|
}
|
|
#else
|
|
bank->AddTitle("Migrate Account is not avaliable on this generation of the game.");
|
|
#endif
|
|
}
|
|
bank->PopGroup();
|
|
}
|
|
bank->PopGroup();
|
|
}
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_Update()
|
|
{
|
|
if (m_BkRequest.IsFlagSet(SMBR_GET_ACCOUNTS))
|
|
{
|
|
strcpy(m_accountstatus, GetSaveMigrationStatusChar(GetAccountsStatus()));
|
|
m_accountsCount = GetAccounts().GetCount();
|
|
|
|
if (GetAccountsStatus() != SM_STATUS_PENDING)
|
|
{
|
|
m_BkRequest.ClearFlag(SMBR_GET_ACCOUNTS);
|
|
|
|
for (int i = 0; i < m_accountsCount; i++)
|
|
{
|
|
const rlSaveMigrationMPAccount& account = GetAccounts()[i];
|
|
|
|
savemigrationDebug1("Bank_RequestAccounts : AccountId %d : Platform %s : Gamertag %s : ugcPublishCount %d : Available : %s", account.m_AccountId, account.m_Platform, account.m_Gamertag, account.m_ugcPublishCount, account.m_Available ? "True" : "False");
|
|
|
|
if (m_bBankAccountsCreated && m_BkAccountsGroup)
|
|
{
|
|
m_BankAccounts.Push(m_BkAccountsGroup->AddTitle("Id %d : %s : %s : ugc %d : %s", account.m_AccountId, account.m_Platform, account.m_Gamertag, account.m_ugcPublishCount, account.m_Available ? "Avaliable" : "Unavaliable"));
|
|
}
|
|
|
|
if (account.m_Available)
|
|
{
|
|
m_migrationAccountid = account.m_AccountId;
|
|
strcpy(m_migrationPlatform, account.m_Platform);
|
|
}
|
|
}
|
|
|
|
savemigrationDebug1("Bank_RequestAccounts : Completed : %s", m_accountstatus);
|
|
}
|
|
else if (m_BankAccounts.GetCount() > 0)
|
|
{
|
|
for (int i = 0; i < m_BankAccounts.GetCount(); i++)
|
|
{
|
|
m_BankAccounts[i]->Destroy();
|
|
}
|
|
m_BankAccounts.clear();
|
|
}
|
|
}
|
|
|
|
if (m_BkRequest.IsFlagSet(SMBR_MIGRATE_ACCOUNT))
|
|
{
|
|
strcpy(m_migrationstatus, GetSaveMigrationStatusChar(GetMigrationStatus()));
|
|
|
|
if (GetMigrationStatus() != SM_STATUS_PENDING)
|
|
{
|
|
savemigrationDebug1("Bank_MigrateAccounts : Completed : %s", m_migrationstatus);
|
|
m_BkRequest.ClearFlag(SMBR_MIGRATE_ACCOUNT);
|
|
}
|
|
}
|
|
|
|
if (m_BkRequest.IsFlagSet(SMBR_GET_STATUS))
|
|
{
|
|
strcpy(m_playstatus, GetSaveMigrationStatusChar(GetStatus()));
|
|
|
|
if (GetStatus() != SM_STATUS_PENDING)
|
|
{
|
|
m_playstatusTransactionid = m_playStateTask.GetState().GetTransactionId();
|
|
|
|
savemigrationDebug1("Bank_RefreshStatus : Completed : %s", m_playstatus);
|
|
m_BkRequest.ClearFlag(SMBR_GET_STATUS);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_RequestAccounts()
|
|
{
|
|
if (!m_BkRequest.IsFlagSet(SMBR_GET_ACCOUNTS))
|
|
{
|
|
if (RequestAccounts())
|
|
{
|
|
savemigrationDebug1("Bank_RequestAccounts : Requested");
|
|
|
|
strcpy(m_accountstatus, "Requested");
|
|
m_BkRequest.SetFlag(SMBR_GET_ACCOUNTS);
|
|
}
|
|
else
|
|
{
|
|
strcpy(m_accountstatus, "Failed");
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_MigrateAccount()
|
|
{
|
|
if (!m_BkRequest.IsFlagSet(SMBR_MIGRATE_ACCOUNT))
|
|
{
|
|
if (MigrateAccount(m_migrationAccountid, m_migrationPlatform))
|
|
{
|
|
savemigrationDebug1("Bank_MigrateAccounts : Requested");
|
|
|
|
strcpy(m_migrationstatus, "Requested");
|
|
m_BkRequest.SetFlag(SMBR_MIGRATE_ACCOUNT);
|
|
}
|
|
else
|
|
{
|
|
strcpy(m_migrationstatus, "Failed");
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSaveMigration_multiplayer::Bank_RequestStatus()
|
|
{
|
|
if (!m_BkRequest.IsFlagSet(SMBR_GET_STATUS))
|
|
{
|
|
if (RequestStatus())
|
|
{
|
|
savemigrationDebug1("Bank_RequestStatus : Requested");
|
|
|
|
strcpy(m_playstatus, "Requested");
|
|
m_BkRequest.SetFlag(SMBR_GET_STATUS);
|
|
}
|
|
else
|
|
{
|
|
strcpy(m_playstatus, "Failed");
|
|
}
|
|
}
|
|
}
|
|
#endif
|