568 lines
21 KiB
C++
568 lines
21 KiB
C++
|
|
|
|
#include "script_save_nested.h"
|
|
|
|
// Rage headers
|
|
#include "parser/psofile.h"
|
|
|
|
// Game headers
|
|
#include "SaveLoad/GenericGameStorage.h"
|
|
#include "SaveLoad/savegame_channel.h"
|
|
#include "SaveLoad/SavegameScriptData/script_save_data.h"
|
|
#include "script/gta_thread.h"
|
|
|
|
#define MAX_LENGTH_OF_LABEL_FOR_SAVE_DATA (64)
|
|
|
|
// **************************************** SaveGameDataBlock - Script - CNestedScriptData ************************************
|
|
|
|
CNestedScriptData::~CNestedScriptData()
|
|
{
|
|
Shutdown();
|
|
}
|
|
|
|
void CNestedScriptData::Shutdown()
|
|
{
|
|
m_ScriptSaveArrayOfStructs.Shutdown();
|
|
|
|
#if SAVEGAME_USES_XML
|
|
m_ScriptSaveXmlTrees.Shutdown();
|
|
#endif
|
|
|
|
#if SAVEGAME_USES_PSO
|
|
m_ScriptSavePsoFileTracker.Shutdown();
|
|
#endif
|
|
}
|
|
|
|
bool CNestedScriptData::OpenScriptSaveData(const char *pLabel, const void *pStartAddressOfStruct, s32 NumberOfScrValuesInStruct, GtaThread *pScriptThread)
|
|
{
|
|
#if SAVEGAME_USES_XML
|
|
if (m_ScriptSaveArrayOfStructs.GetTopLevelRTStructure())
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::OpenScriptSaveData - START_SAVE_DATA has already been called for %s", pScriptThread->GetScriptName());
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
if (CScriptSaveData::GetStructStack().GetStackLevel() != -1)
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::OpenScriptSaveData - expected stack level to be -1 for the stack of script structs in %s", pScriptThread->GetScriptName());
|
|
return false;
|
|
}
|
|
|
|
scrValue *pStartAddress = (scrValue*)pStartAddressOfStruct;
|
|
if(atLiteralHashValue(pScriptThread->GetScriptName())==atLiteralHashValue("startup"))
|
|
{
|
|
if (!scrThread::IsValidGlobal(pStartAddress))
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::OpenScriptSaveData - %s %s Start address of the global save struct is outside the global save data block", pScriptThread->GetScriptName(), pLabel);
|
|
return false;
|
|
//DLCTODO: Make sure this works properly, not stopping at the moment, works fine
|
|
}
|
|
|
|
if (!scrThread::IsValidGlobal(pStartAddress + NumberOfScrValuesInStruct - 1))
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::OpenScriptSaveData - %s %s End address of the global save struct is outside the global save data block", pScriptThread->GetScriptName(), pLabel);
|
|
return false;
|
|
//DLCTODO: Make sure this works properly, not stopping at the moment, works fine
|
|
}
|
|
}
|
|
|
|
int ArrayIndex = m_ScriptSaveArrayOfStructs.AddNewScriptStruct(pScriptThread->GetProgramCounter(0), false, pLabel);
|
|
savegameAssertf(ArrayIndex == 0, "CNestedScriptData::OpenScriptSaveData - expected the array index of the struct containing all the other data to be 0");
|
|
|
|
u8* StartAddress = reinterpret_cast<u8*>(pStartAddress);
|
|
u8* EndAddress = reinterpret_cast<u8*>(pStartAddress + NumberOfScrValuesInStruct);
|
|
CScriptSaveData::PushOnToStructStack(StartAddress, EndAddress, pLabel, ArrayIndex);
|
|
|
|
m_ScriptSaveArrayOfStructs.SetDataForTopLevelStruct(StartAddress, pLabel);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNestedScriptData::AddMemberToCurrentStruct(const char *pLabel, int DataType, const void *pStartAddress, GtaThread *ASSERT_ONLY(pScriptThread))
|
|
{
|
|
if (!CheckElementName(pLabel))
|
|
{
|
|
return;
|
|
}
|
|
|
|
int CurrentStackLevel = CScriptSaveData::GetStructStack().GetStackLevel();
|
|
if (savegameVerifyf(CurrentStackLevel >= 0, "CNestedScriptData::AddMemberToCurrentStruct - stack of structs is empty %s", pScriptThread->GetScriptName()))
|
|
{
|
|
int ArrayIndexOfStructAtCurrentStackLevel = CScriptSaveData::GetStructStack().GetArrayIndex(CurrentStackLevel);
|
|
if (!m_ScriptSaveArrayOfStructs.GetHasBeenClosed(ArrayIndexOfStructAtCurrentStackLevel))
|
|
{
|
|
const u8* StartAddressAsUInt32 = reinterpret_cast<const u8*>(pStartAddress);
|
|
u8* StartAddressOfParentStruct = CScriptSaveData::GetStructStack().GetStartAddress(CurrentStackLevel);
|
|
u8* EndAddressOfParentStruct = CScriptSaveData::GetStructStack().GetEndAddress(CurrentStackLevel);
|
|
|
|
if (savegameVerifyf(StartAddressAsUInt32 >= StartAddressOfParentStruct, "CNestedScriptData::AddMemberToCurrentStruct - %s occurs outside its parent struct", pLabel))
|
|
{
|
|
if (savegameVerifyf( (EndAddressOfParentStruct == 0) || (StartAddressAsUInt32 < EndAddressOfParentStruct), "CNestedScriptData::AddMemberToCurrentStruct - %s occurs outside its parent struct", pLabel))
|
|
{
|
|
ptrdiff_t Offset = StartAddressAsUInt32 - StartAddressOfParentStruct;
|
|
Assert(Offset <= 0xffffffff);
|
|
|
|
savegameDebugf3("CNestedScriptData::AddMemberToCurrentStruct - adding %s with offset %d (%u). Start Address Of Parent Struct = %p Address Of This Member = %p", pLabel, (s32) Offset, (u32) Offset, StartAddressOfParentStruct, StartAddressAsUInt32);
|
|
|
|
#if !__NO_OUTPUT
|
|
if (Offset > 200000)
|
|
{
|
|
savegameDebugf1("CNestedScriptData::AddMemberToCurrentStruct - offset %06d label %s", (s32) Offset, pLabel);
|
|
}
|
|
#endif // !__NO_OUTPUT
|
|
|
|
savegameAssertf(Offset < psoSchemaMemberData::MAX_OFFSET, "CNestedScriptData::AddMemberToCurrentStruct - offset %d of %s is too large. It needs to be less than psoSchemaMemberData::MAX_OFFSET (%d)", (s32) Offset, pLabel, psoSchemaMemberData::MAX_OFFSET);
|
|
|
|
m_ScriptSaveArrayOfStructs.AddNewDataItemToStruct(ArrayIndexOfStructAtCurrentStackLevel, u32(Offset), DataType, pLabel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CNestedScriptData::OpenScriptStruct(const char *pLabel, void *pStartAddress, s32 NumberOfScrValuesInStruct, bool bIsArray, GtaThread *pScriptThread)
|
|
{
|
|
if (!CheckElementName(pLabel))
|
|
{
|
|
return;
|
|
}
|
|
|
|
int ArrayIndex = m_ScriptSaveArrayOfStructs.AddNewScriptStruct(pScriptThread->GetProgramCounter(0), bIsArray, pLabel);
|
|
AddMemberToCurrentStruct(pLabel, ArrayIndex, pStartAddress, pScriptThread);
|
|
u8* StartAddress = reinterpret_cast<u8*>(pStartAddress);
|
|
u8* EndAddress = NULL;
|
|
if (NumberOfScrValuesInStruct > 0)
|
|
{
|
|
EndAddress = reinterpret_cast<u8*>( ((scrValue*) pStartAddress) + NumberOfScrValuesInStruct);
|
|
}
|
|
CScriptSaveData::PushOnToStructStack(StartAddress, EndAddress, pLabel, ArrayIndex);
|
|
}
|
|
|
|
bool CNestedScriptData::CloseScriptStruct()
|
|
{
|
|
int CurrentStackLevel = CScriptSaveData::GetStructStack().GetStackLevel();
|
|
|
|
// char NameOfPoppedStruct[MAX_LENGTH_OF_LABEL_FOR_SAVE_DATA];
|
|
// const atString &NameOfStruct = CScriptSaveData::GetStructStack().GetNameOfInstance(CurrentStackLevel);
|
|
// strncpy(NameOfPoppedStruct, NameOfStruct.c_str(), MAX_LENGTH_OF_LABEL_FOR_SAVE_DATA);
|
|
|
|
int ArrayIndexOfPoppedStruct = CScriptSaveData::GetStructStack().GetArrayIndex(CurrentStackLevel);
|
|
m_ScriptSaveArrayOfStructs.ClearRegisteredElementNames(ArrayIndexOfPoppedStruct);
|
|
m_ScriptSaveArrayOfStructs.SetHasBeenClosed(ArrayIndexOfPoppedStruct, true);
|
|
|
|
CScriptSaveData::PopStructStack();
|
|
|
|
bool bStackIsNowEmpty = false;
|
|
if (CurrentStackLevel == 0)
|
|
{ // we've just popped the top level
|
|
bStackIsNowEmpty = true;
|
|
}
|
|
|
|
return bStackIsNowEmpty;
|
|
}
|
|
|
|
void CNestedScriptData::ForceCleanupOfScriptSaveStructs(const char* pNameOfGlobalDataTree)
|
|
{
|
|
#if SAVEGAME_USES_PSO
|
|
atLiteralHashValue nameHash(pNameOfGlobalDataTree);
|
|
psoStruct* pStruct = m_ScriptSavePsoFileTracker.GetStruct(nameHash);
|
|
if (pStruct)
|
|
{
|
|
if (pStruct->IsValid() && !pStruct->IsNull())
|
|
{
|
|
savegameDisplayf("CNestedScriptData::ForceCleanupOfScriptSaveStructs - About to call ForceCleanup for %s", pNameOfGlobalDataTree);
|
|
m_ScriptSavePsoFileTracker.ForceCleanup();
|
|
}
|
|
}
|
|
#endif // SAVEGAME_USES_PSO
|
|
}
|
|
|
|
bool CNestedScriptData::DeserializeSavedData(const char* pNameOfGlobalDataTree)
|
|
{
|
|
// if (bStackIsNowEmpty)
|
|
{
|
|
#if SAVEGAME_USES_PSO
|
|
// Check for PSO data to load
|
|
atLiteralHashValue nameHash(pNameOfGlobalDataTree);
|
|
psoStruct* pStruct = m_ScriptSavePsoFileTracker.GetStruct(nameHash);
|
|
if (pStruct)
|
|
{
|
|
if (pStruct->IsValid() && !pStruct->IsNull())
|
|
{
|
|
m_ScriptSaveArrayOfStructs.LoadFromPsoStruct(*pStruct);
|
|
savegameDisplayf("CNestedScriptData::DeserializeSavedData - About to call DeleteStruct for %s", pNameOfGlobalDataTree);
|
|
m_ScriptSavePsoFileTracker.DeleteStruct(nameHash);
|
|
}
|
|
}
|
|
#else
|
|
if (0) { }
|
|
#endif
|
|
|
|
#if SAVEGAME_USES_XML
|
|
else
|
|
{
|
|
// Search the array of parTrees for one with a matching name
|
|
int ArrayCount = m_ScriptSaveXmlTrees.GetTreeCount();
|
|
int loop = 0;
|
|
bool bFound = false;
|
|
while ((loop < ArrayCount) && !bFound)
|
|
{
|
|
if (m_ScriptSaveXmlTrees.GetTreeNode(loop))
|
|
{
|
|
parTreeNode *pRootNode = m_ScriptSaveXmlTrees.GetTreeNode(loop);
|
|
if (pRootNode && (strcmp(pRootNode->GetElement().GetName(), pNameOfGlobalDataTree) == 0))
|
|
{
|
|
m_ScriptSaveArrayOfStructs.CreateRTStructuresForLoading();
|
|
parRTStructure *pRTStructureOfSaveData = m_ScriptSaveArrayOfStructs.GetTopLevelRTStructure();
|
|
|
|
if (savegameVerifyf(pRTStructureOfSaveData, "CNestedScriptData::CloseScriptStruct - RTStructure doesn't exist for %s", pNameOfGlobalDataTree))
|
|
{
|
|
PARSER.LoadFromStructure(pRootNode, *pRTStructureOfSaveData, NULL, false);
|
|
}
|
|
|
|
m_ScriptSaveArrayOfStructs.DeleteRTStructures();
|
|
|
|
m_ScriptSaveXmlTrees.DeleteTreeFromArray(loop);
|
|
bFound = true;
|
|
}
|
|
} // if (m_ScriptSaveXmlTrees.GetTreeNode(loop))
|
|
|
|
loop++;
|
|
} // while ((loop < ArrayCount) && !bFound)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return true; // I'm always returning true just now. Is there any way I can check for failure?
|
|
}
|
|
|
|
|
|
atString& CNestedScriptData::GetTopLevelName()
|
|
{
|
|
return m_ScriptSaveArrayOfStructs.GetTopLevelName();
|
|
}
|
|
|
|
bool CNestedScriptData::HasRegisteredScriptData()
|
|
{
|
|
return m_ScriptSaveArrayOfStructs.HasRegisteredScriptData();
|
|
}
|
|
|
|
#if __ALLOW_EXPORT_OF_SP_SAVEGAMES || __ALLOW_IMPORT_OF_SP_SAVEGAMES
|
|
void CNestedScriptData::SetBufferForImportExport(u8 *pBaseAddress)
|
|
{
|
|
m_ScriptSaveArrayOfStructs.SetBufferForImportExport(pBaseAddress);
|
|
}
|
|
#endif // __ALLOW_EXPORT_OF_SP_SAVEGAMES || __ALLOW_IMPORT_OF_SP_SAVEGAMES
|
|
|
|
|
|
#if SAVEGAME_USES_XML
|
|
void CNestedScriptData::DeleteAllRTStructures()
|
|
{
|
|
m_ScriptSaveArrayOfStructs.DeleteRTStructures();
|
|
}
|
|
#endif // SAVEGAME_USES_XML
|
|
|
|
#if SAVEGAME_USES_XML || __ALLOW_EXPORT_OF_SP_SAVEGAMES
|
|
void CNestedScriptData::AddActiveScriptDataToTreeToBeSaved(parTree *pTreeToBeSaved, int index)
|
|
{
|
|
m_ScriptSaveArrayOfStructs.AddActiveScriptDataToTreeToBeSaved(pTreeToBeSaved, index);
|
|
}
|
|
#endif // SAVEGAME_USES_XML || __ALLOW_EXPORT_OF_SP_SAVEGAMES
|
|
|
|
#if SAVEGAME_USES_XML
|
|
void CNestedScriptData::AddInactiveScriptDataToTreeToBeSaved(parTree *pTreeToBeSaved, const char* pNameOfScriptTreeNode)
|
|
{
|
|
if (savegameVerifyf(pTreeToBeSaved, "CNestedScriptData::AddInactiveScriptDataToTreeToBeSaved - the main tree that will be added to does not exist"))
|
|
{
|
|
parTreeNode *pRootOfTreeToBeSaved = pTreeToBeSaved->GetRoot();
|
|
|
|
if (savegameVerifyf(pRootOfTreeToBeSaved, "CNestedScriptData::AddInactiveScriptDataToTreeToBeSaved - the main tree that will be added to does not have a root node"))
|
|
{
|
|
parTreeNode *pScriptDataNode = pRootOfTreeToBeSaved->FindChildWithName(pNameOfScriptTreeNode);
|
|
|
|
if (savegameVerifyf(pScriptDataNode, "CNestedScriptData::AddInactiveScriptDataToTreeToBeSaved - the main tree that will be added to does not have a node named %s", pNameOfScriptTreeNode))
|
|
{
|
|
// loop through array of parTrees and clone each one then append the clone as a child of the pNameOfScriptTreeNode node
|
|
for (u32 loop = 0; loop < m_ScriptSaveXmlTrees.GetTreeCount(); loop++)
|
|
{ // loop through any parTrees that have been loaded but not converted to an RTStructure during the current session
|
|
if (savegameVerifyf(m_ScriptSaveXmlTrees.GetTreeNode(loop), "CNestedScriptData::AddInactiveScriptDataToTreeToBeSaved - expected all entries in tree array to be valid"))
|
|
{
|
|
// As with the names in the rtStructs that are local to CreateSaveDataAndCalculateSize
|
|
// it would be better if the strings in the clone were duplicates of the original string
|
|
parTreeNode *pClone = m_ScriptSaveXmlTrees.GetTreeNode(loop)->Clone();
|
|
pClone->AppendAsChildOf(pScriptDataNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CNestedScriptData::ReadScriptTreesFromLoadedTree(parTree *pFullLoadedTree, const char* pNameOfScriptTreeNode)
|
|
{
|
|
savegameAssertf(m_ScriptSaveXmlTrees.GetTreeCount() == 0, "CNestedScriptData::ReadScriptTreesFromLoadedTree - expected the array of parTrees to be empty at this stage");
|
|
|
|
if (savegameVerifyf(pFullLoadedTree, "CNestedScriptData::ReadScriptTreesFromLoadedTree - the main tree to be loaded does not exist"))
|
|
{
|
|
parTreeNode *pRootOfTreeToBeLoaded = pFullLoadedTree->GetRoot();
|
|
|
|
if (savegameVerifyf(pRootOfTreeToBeLoaded, "CNestedScriptData::ReadScriptTreesFromLoadedTree - the main tree to be loaded does not have a root node"))
|
|
{
|
|
parTreeNode *pScriptDataNode = pRootOfTreeToBeLoaded->FindChildWithName(pNameOfScriptTreeNode);
|
|
|
|
if (savegameVerifyf(pScriptDataNode, "CNestedScriptData::ReadScriptTreesFromLoadedTree - the main tree to be loaded does not have a node named %s", pNameOfScriptTreeNode))
|
|
{
|
|
parTreeNode *pCurrent = pScriptDataNode->GetChild();
|
|
parTreeNode *pNext = NULL;
|
|
while (pCurrent)
|
|
{
|
|
pNext = pCurrent->GetSibling();
|
|
pCurrent->RemoveSelf(); // Remove the branch containing the data for a GtaThread remove from the tree...
|
|
m_ScriptSaveXmlTrees.Append(pCurrent); // and add it to the atArray of parTreeNodes
|
|
pCurrent = pNext;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CNestedScriptData::HasAllScriptDataBeenDeserializedFromXmlFile()
|
|
{
|
|
return (m_ScriptSaveXmlTrees.GetTreeCount() == 0);
|
|
}
|
|
|
|
#endif // SAVEGAME_USES_XML
|
|
|
|
s32 CNestedScriptData::GetSizeOfSavedScriptData()
|
|
{
|
|
return m_ScriptSaveArrayOfStructs.GetSizeOfSavedScriptData();
|
|
}
|
|
|
|
s32 CNestedScriptData::GetSizeOfSavedScriptDataInBytes()
|
|
{
|
|
return m_ScriptSaveArrayOfStructs.GetSizeOfSavedScriptDataInBytes();
|
|
}
|
|
|
|
#if SAVEGAME_USES_PSO
|
|
psoBuilderInstance* CNestedScriptData::CreatePsoStructuresForSaving(psoBuilder& pso, atLiteralHashValue nameHashOfScript)
|
|
{
|
|
return m_ScriptSaveArrayOfStructs.CreatePsoStructuresForSaving(pso, nameHashOfScript);
|
|
}
|
|
|
|
|
|
void CNestedScriptData::AddActiveScriptDataToPsoToBeSaved(psoBuilder& builder, psoBuilderInstance* rootInstance, const char* pNameOfScriptTreeNode)
|
|
{
|
|
#if __BANK
|
|
if (CGenericGameStorage::ms_bSaveScriptVariables)
|
|
#endif // __BANK
|
|
{
|
|
// Define a container structure that holds pointers to each thread's script data
|
|
psoBuilderStructSchema& scriptThreadContainerSchema = builder.CreateStructSchema(atLiteralHashValue(pNameOfScriptTreeNode));
|
|
|
|
scriptThreadContainerSchema.AddMemberPointer(atLiteralHashValue(GetTopLevelName().c_str()), parMemberStructSubType::SUBTYPE_SIMPLE_POINTER);
|
|
|
|
scriptThreadContainerSchema.FinishBuilding();
|
|
|
|
// Now create an instance of that structure (the one containing pointers to all of the script data structures)
|
|
psoBuilderInstance& scriptThreadContainer = builder.CreateStructInstances(scriptThreadContainerSchema);
|
|
|
|
// Create each of the script data structure objects
|
|
psoBuilderInstance* scriptThreadData = CreatePsoStructuresForSaving(builder, atLiteralHashValue(pNameOfScriptTreeNode));
|
|
|
|
// Then fix up the pointer from the scriptThreadContainer to the scriptThreadData
|
|
scriptThreadContainer.AddFixup(0, GetTopLevelName().c_str(), scriptThreadData);
|
|
|
|
// Finally add a fixup so that the root object in the PSO file points to the script data container
|
|
rootInstance->AddFixup(0, pNameOfScriptTreeNode, &scriptThreadContainer);
|
|
}
|
|
}
|
|
|
|
void CNestedScriptData::ReadAndDeserializeAllScriptTreesFromLoadedPso(psoFile& file, const char* pNameOfScriptTreeNode, const char* pNameOfGlobalDataTree)
|
|
{
|
|
psoStruct root = file.GetRootInstance();
|
|
psoMember mem =root.GetMemberByName(atLiteralHashValue(CSaveGameData::GetNameOfMainScriptTreeNode()));
|
|
if(!(atLiteralHashValue(pNameOfScriptTreeNode)==atLiteralHashValue(CSaveGameData::GetNameOfMainScriptTreeNode())))
|
|
{
|
|
//mem = mem.GetSubStructure().GetMemberByName(atLiteralHashValue(pNameOfScriptTreeNode));
|
|
mem = root.GetMemberByName(atLiteralHashValue(CSaveGameData::GetNameOfDLCScriptTreeNode())).GetSubStructure().GetMemberByName(atLiteralHashValue(pNameOfScriptTreeNode));
|
|
}
|
|
//psoMember mem = root.GetMemberByName(atLiteralHashValue(pNameOfScriptTreeNode));
|
|
if (savegameVerifyf(mem.IsValid(), "CNestedScriptData::ReadAndDeserializeAllScriptTreesFromLoadedPso - Couldn't find member %s in structure", pNameOfScriptTreeNode))
|
|
{
|
|
// The current format is that the root node has a substructure named pNameOfScriptTreeNode, which contains pointers to all
|
|
// of the actual script data structures.
|
|
psoStruct subStruct = mem.GetSubStructure();
|
|
|
|
atLiteralHashValue nameHash(pNameOfGlobalDataTree);
|
|
|
|
int SubStructCount = subStruct.GetSchema().GetNumMembers();
|
|
savegameAssertf(SubStructCount == 1, "CNestedScriptData::ReadAndDeserializeAllScriptTreesFromLoadedPso - SubStructCount is %d. Expected it to always be 1 for now. Graeme", SubStructCount);
|
|
for(int i = 0; i < SubStructCount; i++)
|
|
{
|
|
psoMember scriptStructMember = subStruct.GetMemberByIndex(i);
|
|
atLiteralHashValue sHash = scriptStructMember.GetSchema().GetNameHash();
|
|
if (sHash == nameHash)
|
|
{
|
|
psoStruct scriptStruct = subStruct.GetMemberByIndex(i).GetSubStructure();
|
|
|
|
if (scriptStruct.IsValid() && !scriptStruct.IsNull())
|
|
{
|
|
m_ScriptSaveArrayOfStructs.LoadFromPsoStruct(scriptStruct);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if __ALLOW_EXPORT_OF_SP_SAVEGAMES
|
|
bool CNestedScriptData::DeserializeForExport(psoMember& member)
|
|
{
|
|
u32 numberOfLoadedStructs = 0;
|
|
psoStruct subStruct = member.GetSubStructure();
|
|
int SubStructCount = subStruct.GetSchema().GetNumMembers();
|
|
for(int i = 0; i < SubStructCount; i++)
|
|
{
|
|
psoMember scriptStructMember = subStruct.GetMemberByIndex(i);
|
|
psoStruct scriptStruct = scriptStructMember.GetSubStructure();
|
|
if (scriptStruct.IsValid() && !scriptStruct.IsNull())
|
|
{
|
|
savegameDisplayf("CNestedScriptData::DeserializeForExport - about to call m_ScriptSaveArrayOfStructs.LoadFromPsoStruct()");
|
|
m_ScriptSaveArrayOfStructs.LoadFromPsoStruct(scriptStruct);
|
|
numberOfLoadedStructs++;
|
|
}
|
|
else
|
|
{
|
|
savegameWarningf("CNestedScriptData::DeserializeForExport - scriptStruct is not valid");
|
|
}
|
|
}
|
|
return numberOfLoadedStructs!=0;
|
|
}
|
|
#endif // __ALLOW_EXPORT_OF_SP_SAVEGAMES
|
|
|
|
#if __ALLOW_IMPORT_OF_SP_SAVEGAMES
|
|
bool CNestedScriptData::DeserializeForImport(parTreeNode *pParentNode, const char* pNameOfScriptTreeNode, const char* pNameOfGlobalDataTree)
|
|
{
|
|
bool bFound = false;
|
|
|
|
parTreeNode *pScriptDataNode = pParentNode->FindChildWithName(pNameOfScriptTreeNode);
|
|
if (savegameVerifyf(pScriptDataNode, "CNestedScriptData::DeserializeForImport - the main tree to be loaded does not have a node named %s", pNameOfScriptTreeNode))
|
|
{
|
|
parTreeNode *pCurrentTreeNode = pScriptDataNode->GetChild();
|
|
while (pCurrentTreeNode && !bFound)
|
|
{
|
|
if (pCurrentTreeNode && (strcmp(pCurrentTreeNode->GetElement().GetName(), pNameOfGlobalDataTree) == 0))
|
|
{
|
|
m_ScriptSaveArrayOfStructs.CreateRTStructuresForLoading();
|
|
parRTStructure *pRTStructureOfSaveData = m_ScriptSaveArrayOfStructs.GetTopLevelRTStructure();
|
|
if (savegameVerifyf(pRTStructureOfSaveData, "CNestedScriptData::DeserializeForImport - RTStructure doesn't exist for %s", pNameOfGlobalDataTree))
|
|
{
|
|
PARSER.LoadFromStructure(pCurrentTreeNode, *pRTStructureOfSaveData, NULL, false);
|
|
}
|
|
|
|
m_ScriptSaveArrayOfStructs.DeleteRTStructures();
|
|
bFound = true;
|
|
}
|
|
|
|
pCurrentTreeNode = pCurrentTreeNode->GetSibling();
|
|
}
|
|
|
|
if (!bFound)
|
|
{
|
|
savegameErrorf("CNestedScriptData::DeserializeForImport - failed to find a child node of %s with the the name %s", pNameOfScriptTreeNode, pNameOfGlobalDataTree);
|
|
savegameAssertf(0, "CNestedScriptData::DeserializeForImport - failed to find a child node of %s with the the name %s", pNameOfScriptTreeNode, pNameOfGlobalDataTree);
|
|
}
|
|
}
|
|
|
|
return bFound;
|
|
}
|
|
#endif // __ALLOW_IMPORT_OF_SP_SAVEGAMES
|
|
|
|
|
|
|
|
#if __BANK
|
|
void CNestedScriptData::DisplayCurrentValuesOfSavedScriptVariables()
|
|
{
|
|
m_ScriptSaveArrayOfStructs.DisplayCurrentValuesOfSavedScriptVariables();
|
|
}
|
|
#endif // __BANK
|
|
|
|
|
|
#endif // SAVEGAME_USES_PSO
|
|
|
|
bool CNestedScriptData::IsValidCharacterForElementName(char c)
|
|
{
|
|
if (c >= 'a' && c <= 'z')
|
|
return true;
|
|
|
|
if (c >= 'A' && c <= 'Z')
|
|
return true;
|
|
|
|
if (c >= '0' && c <= '9')
|
|
return true;
|
|
|
|
if (c == '.')
|
|
return true;
|
|
|
|
if (c == ':')
|
|
return true;
|
|
|
|
if (c == '_')
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CNestedScriptData::DoesElementNameAlreadyExistInStructsOnStack(const char *pElementName)
|
|
{
|
|
int CurrentStackLevel = CScriptSaveData::GetStructStack().GetStackLevel();
|
|
|
|
if (CurrentStackLevel < 0)
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::DoesElementNameAlreadyExistInStructsOnStack - didn't expect stack to be empty");
|
|
return false;
|
|
}
|
|
|
|
for (int stack_level = 0; stack_level <= CurrentStackLevel; stack_level++)
|
|
{ // Need to use <= rather than <
|
|
int ArrayIndex = CScriptSaveData::GetStructStack().GetArrayIndex(stack_level);
|
|
if (m_ScriptSaveArrayOfStructs.DoesElementNameAlreadyExist(ArrayIndex, pElementName))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CNestedScriptData::CheckElementName(const char *pElementName)
|
|
{
|
|
int char_index = 0;
|
|
while (pElementName[char_index] != '\0')
|
|
{
|
|
if (!IsValidCharacterForElementName(pElementName[char_index]))
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::CheckElementName - label %s contains an invalid character %c", pElementName, pElementName[char_index]);
|
|
return false;
|
|
}
|
|
|
|
char_index++;
|
|
}
|
|
|
|
if (char_index >= MAX_LENGTH_OF_LABEL_FOR_SAVE_DATA)
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::CheckElementName - label %s is longer than 63 characters", pElementName);
|
|
return false;
|
|
}
|
|
|
|
bool bNameAlreadyExists = DoesElementNameAlreadyExistInStructsOnStack(pElementName);
|
|
if (bNameAlreadyExists)
|
|
{
|
|
savegameAssertf(0, "CNestedScriptData::CheckElementName - data with label %s has already been registered", pElementName);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|