void CMaterialEffects::LoadFXLibraries() { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "MaterialEffects"); m_mfxLibraries.clear(); m_effectContainers.clear(); m_effectContainers.push_back(0); // 0 -> invalid effect id ICryPak *pak = gEnv->pCryPak; _finddata_t fd; stack_string searchPath; searchPath.Format("%s/*.xml", MATERIAL_EFFECTS_LIBRARIES_FOLDER); intptr_t handle = pak->FindFirst(searchPath.c_str(), &fd); int res = 0; if (handle != -1) { do { LoadFXLibrary(fd.name); res = pak->FindNext(handle, &fd); SLICE_AND_SLEEP(); } while(res >= 0); pak->FindClose(handle); } m_canopySurfaceId = MaterialEffectsUtils::FindSurfaceIdByName(MATERIAL_EFFECTS_SURFACE_TYPE_CANOPY); }
EntityId CAICorpseManager::SpawnAICorpseFromEntity( IEntity& sourceEntity, const SCorpseParameters& corpseParams ) { assert(gEnv->IsEditor() == false); assert(gEnv->bMultiplayer == false); if(g_pGameCVars->g_aiCorpses_Enable == 0) return 0; if(m_corpsesArray.size() == m_maxCorpses) { RemoveSomeCorpses(); assert((uint32)m_corpsesArray.size() < m_maxCorpses); } MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, EMemStatContextFlags::MSF_None, "AICorpseManager::SpawnCorpse"); EntityId corpseId = 0; IPhysicalEntity* pSourcePhysics = sourceEntity.GetPhysics(); if ((pSourcePhysics != NULL) && (pSourcePhysics->GetType() == PE_ARTICULATED)) { ICharacterInstance *pSourceCharacterInstance = sourceEntity.GetCharacter(0); if (pSourceCharacterInstance != NULL) { IEntityClass *pCorpseClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("AICorpse"); assert(pCorpseClass); stack_string corpseName; corpseName.Format("%s_Corpse", sourceEntity.GetName()); SEntitySpawnParams params; params.pClass = pCorpseClass; params.sName = corpseName.c_str(); #if !AI_CORPSES_ENABLE_SERIALIZE params.nFlags |= ENTITY_FLAG_NO_SAVE; #endif params.vPosition = sourceEntity.GetWorldPos(); params.qRotation = sourceEntity.GetWorldRotation(); IEntity *pCorpseEntity = gEnv->pEntitySystem->SpawnEntity(params, true); if(pCorpseEntity != NULL) { corpseId = pCorpseEntity->GetId(); CorpseInfo* pCorpseInfo = FindCorpseInfo( corpseId ); assert(pCorpseInfo != NULL); CAICorpse* pCorpse = pCorpseInfo->GetCorpse(); assert(pCorpse != NULL); pCorpse->SetupFromSource( sourceEntity, *pSourceCharacterInstance, (uint32)corpseParams.priority); } } } return corpseId; }
bool CGameStartup::InitFramework(SSystemInitParams &startupParams) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Init Game Framework" ); #if !defined(_LIB) m_frameworkDll = GetFrameworkDLL(startupParams.szBinariesDir); if (!m_frameworkDll) { // failed to open the framework dll CryFatalError("Failed to open the GameFramework DLL!"); return false; } IGameFramework::TEntryFunction CreateGameFramework = (IGameFramework::TEntryFunction)CryGetProcAddress(m_frameworkDll, DLL_INITFUNC_CREATEGAME ); if (!CreateGameFramework) { // the dll is not a framework dll CryFatalError("Specified GameFramework DLL is not valid!"); return false; } #endif //_LIB m_pFramework = CreateGameFramework(); if (!m_pFramework) { CryFatalError("Failed to create the GameFramework Interface!"); // failed to create the framework return false; } #ifdef WIN32 if (startupParams.pSystem == NULL || (!startupParams.bEditor && !gEnv->IsDedicated())) { ::ShowCursor(FALSE); // Hide the cursor during loading (it will be shown again in Run()) } #endif // initialize the engine if (!m_pFramework->Init(startupParams)) { CryFatalError("Failed to initialize CryENGINE!"); return false; } ModuleInitISystem(m_pFramework->GetISystem(),"CryGame"); #ifdef WIN32 SetWindowLongPtr(reinterpret_cast<HWND>(gEnv->pRenderer->GetHWND()), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this)); #endif return true; }
// Loads equipment packs from rootNode void CEquipmentManager::LoadEquipmentPacks(const XmlNodeRef& rootNode) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Equipment Packs"); if (rootNode->isTag("EquipPacks") == false) return; for (int i=0; i<rootNode->getChildCount(); ++i) { XmlNodeRef packNode = rootNode->getChild(i); LoadEquipmentPack(packNode, true); } }
bool CGameStartup::InitFramework(SSystemInitParams& startupParams) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Init Game Framework" ); #if !defined(_LIB) m_frameworkDll = GetFrameworkDLL(startupParams.szBinariesDir); if (!m_frameworkDll) { CryFatalError("Failed to open the GameFramework DLL!"); return false; } IGameFramework::TEntryFunction CreateGameFramework = (IGameFramework::TEntryFunction)CryGetProcAddress(m_frameworkDll, DLL_INITFUNC_CREATEGAME); if (!CreateGameFramework) { CryFatalError("Specified GameFramework DLL is not valid!"); return false; } #endif m_pFramework = CreateGameFramework(); if (!m_pFramework) { CryFatalError("Failed to create the GameFramework Interface!"); return false; } if (!m_pFramework->Init(startupParams)) { CryFatalError("Failed to initialize CryENGINE!"); return false; } ModuleInitISystem(m_pFramework->GetISystem(), GAME_NAME); #if CRY_PLATFORM_WINDOWS SetWindowLongPtr(reinterpret_cast<HWND>(gEnv->pRenderer->GetHWND()), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this)); #endif return true; }
bool CEntityPool::CreatePoolEntity(CEntity* &pOutEntity, bool bAddToInactiveList) { FUNCTION_PROFILER(GetISystem(), PROFILE_ENTITY); assert(!gEnv->IsEditor()); MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, EMemStatContextFlags::MSF_Instance, "Create Pool Entity"); bool bResult = false; assert(m_pEntityPoolManager); CEntitySystem* pEntitySystem = m_pEntityPoolManager->GetEntitySystem(); if (pEntitySystem) { SEntitySpawnParams params; CreateSpawnParams(params); params.vScale.Set(1.0f,1.0f,1.0f); CEntity* pEntity = (CEntity*)pEntitySystem->SpawnEntity(params); if (pEntity) { pEntity->SetPoolControl(true); // Put into map if (bAddToInactiveList) { const EntityId poolId = pEntity->GetId(); stl::push_back_unique(m_InactivePoolIds, poolId); } pOutEntity = pEntity; bResult = true; } } return bResult; }
// Load all equipment packs from a certain folder void CEquipmentManager::LoadEquipmentPacksFromPath(const char* path) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Equipment Packs"); ICryPak * pCryPak = gEnv->pCryPak; _finddata_t fd; string realPath (path); realPath.TrimRight("/\\"); string search (realPath); search += "/*.xml"; intptr_t handle = pCryPak->FindFirst( search.c_str(), &fd ); if (handle != -1) { do { // fd.name contains the profile name string filename = path; filename += "/" ; filename += fd.name; MEMSTAT_CONTEXT_FMT(EMemStatContextTypes::MSC_Other, 0, "EquipmentPack XML (%s)", filename.c_str()); XmlNodeRef rootNode = gEnv->pSystem->LoadXmlFromFile(filename.c_str()); // load from XML node const bool ok = rootNode ? LoadEquipmentPack(rootNode) : false; if (!ok) { GameWarning("[EquipmentMgr]: Cannot load XML file '%s'. Skipping.", filename.c_str()); } } while ( pCryPak->FindNext( handle, &fd ) >= 0 ); pCryPak->FindClose( handle ); } }
//------------------------------------------------------------------------ void CInventory::FullSerialize( TSerialize ser ) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Inventory serialization"); IEntityPoolManager* pMgr = gEnv->pEntitySystem->GetIEntityPoolManager(); if(pMgr && !gEnv->pSystem->IsSerializingFile()) { // Entities being activated from the pool shouldn't // serialize their inventories. The item ids in the bookmark // refer to the previous entities which no longer exist, instead the // actor will have been given a new equipment pack instead. // In that case just holster the default weapon. We will have to // select it after on the behavior or on the entity side if (ser.IsReading()) { EntityId currentItemId = 0; bool isUsing = false; ser.Value("using", isUsing); ser.Value("CurrentItem", currentItemId); if (currentItemId) { IItem *pItem = m_pGameFrameWork->GetIItemSystem()->GetItem(currentItemId); if(pItem && isUsing && !pItem->IsUsed()) { pItem->Use(GetEntityId()); return; } } HolsterItem(true); } else { bool isUsing = false; if (IItem *pItem = m_pGameFrameWork->GetIItemSystem()->GetItem(m_stats.currentItemId)) isUsing = pItem->IsUsed() && pItem->GetOwnerId() == GetEntityId(); ser.Value("using", isUsing); ser.Value("CurrentItem", m_stats.currentItemId); } return; } ser.BeginGroup("InventoryItems"); ser.Value("CurrentItem", m_stats.currentItemId); ser.Value("HolsterItem", m_stats.holsteredItemId); ser.Value("LastItem", m_stats.lastItemId); int s = m_stats.slots.size(); ser.Value("InventorySize", s); if(ser.IsReading()) m_stats.slots.resize(s); ser.Value("Slots", m_stats.slots ); ser.BeginGroup("accessorySlots"); int exSize = m_stats.accessorySlots.size(); ser.Value("Size", exSize); for(int i = 0; i < IInventory::eInventorySlot_Last; ++i) { ser.BeginGroup("SlotInfo"); ser.Value("slotInfoCount", m_stats.slotsInfo[i].count); ser.Value("slotInfoLastSelected", m_stats.slotsInfo[i].lastSelected); ser.EndGroup(); } if(ser.IsReading()) { m_stats.accessorySlots.resize(0); if(exSize>0) m_stats.accessorySlots.reserve(exSize); } for(int i = 0; i<exSize; ++i) { string accessoryName; if(ser.IsWriting()) accessoryName = m_stats.accessorySlots[i]->GetName(); ser.BeginGroup("Class"); ser.Value("AccessoryName", accessoryName); ser.EndGroup(); if(ser.IsReading()) { IEntityClass* pAccessoryClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(accessoryName); CRY_ASSERT(pAccessoryClass); if (pAccessoryClass != NULL) { m_stats.accessorySlots.push_back(pAccessoryClass); } } } ser.EndGroup();//"accessorySlots" ser.BeginGroup("Ammo"); if(ser.IsReading()) { m_stats.ammoInfo.clear(); } TAmmoInfoMap::iterator ammoInfoIt = m_stats.ammoInfo.begin(); int ammoAmount = m_stats.ammoInfo.size(); ser.Value("AmmoAmount", ammoAmount); for(int i = 0; i < ammoAmount; ++i) { string name; int amount = 0; int capacity = 0; if(ser.IsWriting()) { IEntityClass* pAmmoClass = ammoInfoIt->first; CRY_ASSERT(pAmmoClass); name = (pAmmoClass) ? pAmmoClass->GetName() : ""; const SAmmoInfo& ammoInfo = ammoInfoIt->second; amount = ammoInfo.GetCount(); //users = ammoInfo.GetUserCount(); capacity = ammoInfo.GetCapacity(); // Only use this iterator writing. If we're reading, we change the size // of the map and end up with an out of sync (and invalid) iterator. ++ammoInfoIt; } ser.BeginGroup("Ammo"); ser.Value("AmmoName", name); ser.Value("Bullets", amount); ser.Value("Capacity", capacity); ser.EndGroup(); if(ser.IsReading()) { IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(name); CRY_ASSERT(pClass); TAmmoInfoMap::iterator it = m_stats.ammoInfo.find(pClass); if (it == m_stats.ammoInfo.end()) { m_stats.ammoInfo[pClass] = SAmmoInfo(amount, capacity); } else { it->second.SetCount(amount); it->second.SetCapacity(capacity); } } } ser.EndGroup(); /* ser.BeginGroup("CategorySlots"); for (TSlotsInfo::iterator it = m_stats.slotsInfo.begin(); it != m_stats.slotsInfo.end(); ++it) { ser.Value("Count", it->second.count); } ser.EndGroup();*/ ser.EndGroup(); }
IGameRef CGameStartup::Init(SSystemInitParams &startupParams) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialization"); LOADING("game_startup"); if (!InitFramework(startupParams)) { return 0; } // Configuration for this game ICVar *pCVar = gEnv->pConsole->GetCVar("ai_CompatibilityMode"); if (pCVar) pCVar->Set("crysis"); LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem()); ISystem* pSystem = m_pFramework->GetISystem(); IConsole* pConsole = gEnv->pConsole; startupParams.pSystem = pSystem; #if defined(ENABLE_STATS_AGENT) const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename"); CStatsAgent::CreatePipe( pPipeArg ); #endif PluginManager::InitPluginManager(startupParams); PluginManager::InitPluginsBeforeFramework(); REGISTER_COMMAND("g_loadMod", RequestLoadMod,VF_NULL,""); // load the appropriate game/mod const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD"); IGameRef pOut; if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue()))) { const char* pModName = pModArg->GetValue(); assert(pModName); pOut = Reset(pModName); } else { pOut = Reset(GAME_NAME); } // Load all localized strings. LoadLocalizationData(); if (!m_pFramework->CompleteInit()) { pOut->Shutdown(); return 0; } LOADING_DONE; // should be after init game (should be executed even if there is no game) if(startupParams.bExecuteCommandLine) pSystem->ExecuteCommandLine(); pSystem->GetISystemEventDispatcher()->RegisterListener( &g_system_event_listener_game ); // Creates and starts the realtime update system listener. if (pSystem->IsDevMode()) { CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true); } GCOV_FLUSH; if (gEnv && GetISystem()) { } else { CryLogAlways("failed to find ISystem to register error observer"); assert(0); } PluginManager::InitPluginsLast(); return pOut; }
bool CommunicationVoiceLibrary::LoadFromFile(const char* fileName) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Communication Voice Library" ); MEMSTAT_CONTEXT_FMT(EMemStatContextTypes::MSC_Other, 0, "Voice Lib: %s",fileName ); XmlNodeRef root = GetISystem()->LoadXmlFromFile(fileName); if (!root) return false; XmlNodeRef nodeWorksheet = root->findChild("Worksheet"); if (!nodeWorksheet) return false; XmlNodeRef nodeTable = nodeWorksheet->findChild("Table"); if (!nodeTable) return false; stack_string libName(PathUtil::GetFileName(fileName)); VoiceLibraryID libraryID = GetVoiceLibraryID(libName.c_str()); std::pair<VoiceLibraries::iterator, bool> iresult = m_libraries.insert( VoiceLibraries::value_type(libraryID, VoiceLibrary())); if (!iresult.second) { if (iresult.first->second.name == libName.c_str()) { AIWarningID("<AICommunicationVoiceLibrary::LoadFromFile> ", "Duplicate voice library '%s'!", libName.c_str()); return false; } else { AIWarningID("<AICommunicationVoiceLibrary::LoadFromFile> ", "Hash collision for voice library name '%s' and '%s'!", libName.c_str(), iresult.first->second.name.c_str()); return false; } } VoiceLibrary& library = iresult.first->second; library.name = string(libName); VoiceGroup* voiceGroup = 0; string signalName; string lastSignalName; string voiceName; for (int rowCntr = 0, childN = 0; childN < nodeTable->getChildCount(); ++childN) { XmlNodeRef nodeRow = nodeTable->getChild(childN); if (!nodeRow->isTag("Row")) continue; ++rowCntr; if (rowCntr == 1) // skip language continue; if (rowCntr == 2) // path { int cellN = 0; for (int childrenCntr = 0; childrenCntr < nodeRow->getChildCount(); ++childrenCntr) { XmlNodeRef nodeCell = nodeRow->getChild(childrenCntr); if (!nodeCell->isTag("Cell")) continue; ++cellN; if (cellN == 2) { XmlNodeRef nodeCellData = nodeCell->findChild("Data"); if (!nodeCellData) break; library.base = PathUtil::GetLocalizationFolder() + nodeCellData->getContent(); if (!library.base.empty()) { library.base.replace("\\", "/"); if (library.base[library.base.length()-1] != '/') library.base.append("/"); } break; } } continue; } if (rowCntr == 3) // headers continue; signalName.clear(); voiceName.clear(); for (int childrenCntr = 0, cellIndex = 1; childrenCntr < nodeRow->getChildCount(); ++childrenCntr, ++cellIndex) { XmlNodeRef nodeCell = nodeRow->getChild(childrenCntr); if (!nodeCell->isTag("Cell")) continue; if (nodeCell->haveAttr("ss:Index")) { const char* strIdx = nodeCell->getAttr("ss:Index"); if (sscanf(strIdx, "%d", &cellIndex) != 1) continue; } XmlNodeRef nodeCellData = nodeCell->findChild("Data"); if (!nodeCellData) continue; switch (cellIndex) { case 1: signalName = nodeCellData->getContent(); break; case 2: voiceName = nodeCellData->getContent(); break; } } if (!signalName.empty()) { signalName.MakeLower(); std::pair<VoiceGroups::iterator, bool> itresult = library.voiceGroups.insert( VoiceGroups::value_type(signalName, VoiceGroup())); voiceGroup = &itresult.first->second; // The 20 here comes from inspection of the resulting contents in memreplay voiceGroup->variations.reserve(20); if (!itresult.second) { if (lastSignalName != signalName) AIWarningID("<AICommunicationVoiceLibrary::LoadFromFile> ", "Duplicate voice signal '%s' in file '%s'.", signalName.c_str(), libName.c_str()); } lastSignalName = signalName; } if (!voiceGroup || voiceName.empty()) continue; if ((library.base.find_first_of(':') == string::npos) && (voiceName.find_first_of(':') == string::npos)) voiceName.append(".wav"); if (voiceGroup->variations.size() < MaxVariationCount) voiceGroup->variations.push_back(voiceName); else AIWarningID("<AICommunicationVoiceLibrary::LoadFromFile> ", "Too many voice variations for signal '%s' in file '%s'. Limit is 32.", signalName.c_str(), libName.c_str()); } return true; }
IGameRef CGameStartup::Init(SSystemInitParams &startupParams) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialisation"); #if defined(CVARS_WHITELIST) startupParams.pCVarsWhitelist = &g_CVarsWhiteList; #endif // defined(CVARS_WHITELIST) startupParams.pGameStartup = this; if (!InitFramework(startupParams)) { return 0; } InlineInitializationProcessing("CGameStartup::Init"); LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem()); ISystem* pSystem = m_pFramework->GetISystem(); startupParams.pSystem = pSystem; const ICmdLineArg* pSvBind = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "sv_bind"); IConsole* pConsole = pSystem->GetIConsole(); if ((pSvBind != NULL) && (pConsole != NULL)) { string command = pSvBind->GetName() + string(" ") + pSvBind->GetValue(); pConsole->ExecuteString(command.c_str(), true, false); } #if defined(ENABLE_STATS_AGENT) const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename"); CStatsAgent::CreatePipe( pPipeArg ); #endif REGISTER_COMMAND("g_loadMod", CGameStartupStatic::RequestLoadMod,VF_NULL,""); REGISTER_COMMAND("g_unloadMod", CGameStartupStatic::RequestUnloadMod, VF_NULL, ""); // load the appropriate game/mod #if !defined(_RELEASE) const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD"); #else const ICmdLineArg *pModArg = NULL; #endif // !defined(_RELEASE) InlineInitializationProcessing("CGameStartup::Init LoadLocalizationData"); IGameRef pOut; if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue()))) { const char* pModName = pModArg->GetValue(); assert(pModName); pOut = Reset(pModName); } else { pOut = Reset(GAME_NAME); } if (!m_pFramework->CompleteInit()) { pOut->Shutdown(); return 0; } InlineInitializationProcessing("CGameStartup::Init FrameworkCompleteInit"); // should be after init game (should be executed even if there is no game) if(startupParams.bExecuteCommandLine) pSystem->ExecuteCommandLine(); pSystem->GetISystemEventDispatcher()->RegisterListener(this); // Creates and starts the realtime update system listener. if (pSystem->IsDevMode()) { CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true); } GCOV_FLUSH; if (ISystem *pSystem = gEnv ? GetISystem() : NULL) { pSystem->RegisterErrorObserver(&m_errorObsever); pSystem->RegisterWindowMessageHandler(this); } else { CryLogAlways("failed to find ISystem to register error observer"); assert(0); } InlineInitializationProcessing("CGameStartup::Init End"); #if defined(CRY_UNIT_TESTING) // Register All unit tests of this module. #if defined(_LIB) if(gEnv->pSystem) { CryUnitTest::Test *pTest = CryUnitTest::Test::m_pFirst; for (; pTest != 0; pTest = pTest->m_pNext) { CryUnitTest::IUnitTestManager *pTestManager = gEnv->pSystem->GetITestSystem()->GetIUnitTestManager(); if (pTestManager) { pTest->m_unitTestInfo.module = "StaticBinary"; pTestManager->CreateTest( pTest->m_unitTestInfo ); } } } #endif // run unit tests CryUnitTest::IUnitTestManager *pTestManager = (gEnv && gEnv->pSystem) ? gEnv->pSystem->GetITestSystem()->GetIUnitTestManager() : NULL; if (pTestManager) { const ICmdLineArg* pSkipUnitTest = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "skip_unit_tests"); if(pSkipUnitTest == NULL) { const ICmdLineArg* pUseUnitTestExcelReporter = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "use_unit_test_excel_reporter"); if(pUseUnitTestExcelReporter) { gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::ExcelReporter); } else // default is the minimal reporter { gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::MinimalReporter); } } } #endif // CRY_UNIT_TESTING assert(gEnv); PREFAST_ASSUME(gEnv); GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_RANDOM_SEED, (UINT_PTR)gEnv->pTimer->GetAsyncTime().GetMicroSecondsAsInt64(), 0); return pOut; }
void CScriptProxy::Serialize( TSerialize ser ) { CHECK_SCRIPT_STACK; if (ser.GetSerializationTarget() != eST_Network) { MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Script proxy serialization"); if (NeedSerialize()) { if (ser.BeginOptionalGroup("ScriptProxy", true)) { ser.Value("scriptUpdateRate", m_fScriptUpdateRate); int currStateId = m_nCurrStateId; ser.Value("currStateId", currStateId); // Simulate state change if (m_nCurrStateId != currStateId) { // If state changed kill all old timers. m_pEntity->KillTimer(-1); m_nCurrStateId = currStateId; } if (ser.IsReading()) { // Repeat check if update script function is implemented. m_bUpdateScript = CurrentState()->IsStateFunctionImplemented(ScriptState_OnUpdate); } if (CVar::pEnableFullScriptSave && CVar::pEnableFullScriptSave->GetIVal()) { ser.Value( "FullScriptData", m_pThis ); } else if (m_pThis->HaveValue("OnSave") && m_pThis->HaveValue("OnLoad")) { //SerializeTable( ser, "Properties" ); //SerializeTable( ser, "PropertiesInstance" ); //SerializeTable( ser, "Events" ); SmartScriptTable persistTable(m_pThis->GetScriptSystem()); if (ser.IsWriting()) Script::CallMethod(m_pThis, "OnSave", persistTable); ser.Value( "ScriptData", persistTable.GetPtr()); if (ser.IsReading()) Script::CallMethod(m_pThis, "OnLoad", persistTable); } ser.EndGroup(); //ScriptProxy } else { // If we haven't already serialized the script proxy then reset it back to the default state. CRY_ASSERT(m_pScript); m_pScript->Call_OnReset(m_pThis, true); } } } else { int stateId = m_nCurrStateId; ser.Value("currStateId", stateId, 'sSts'); if (ser.IsReading()) GotoState(stateId); } }