BVB Source Codes

CRYENGINE Show GameplayRecorder.cpp Source code

Return Download CRYENGINE: download GameplayRecorder.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 22:1:2007   11:07 : Created by Marcio Martins
  11.  
  12. *************************************************************************/
  13. #include "StdAfx.h"
  14. #include "CryAction.h"
  15. #include "GameplayRecorder.h"
  16. #include "TestSystem/IGameStateRecorder.h"
  17. #include "CryActionCVars.h"
  18.  
  19. //------------------------------------------------------------------------
  20. CGameplayRecorder::CGameplayRecorder(CCryAction* pGameFramework)
  21.         : m_pGameFramework(pGameFramework),
  22.         m_lastdiscreet(0.0f),
  23.         m_sampleinterval(0.5f),
  24.         m_pGameStateRecorder(NULL)
  25. {
  26.         //m_pMetadataRecorder->InitSave("GameData.meta");
  27.         m_listeners.reserve(12);
  28. }
  29.  
  30. //------------------------------------------------------------------------
  31. CGameplayRecorder::~CGameplayRecorder()
  32. {
  33.         //m_pMetadataRecorder->Reset();
  34. }
  35.  
  36. //------------------------------------------------------------------------
  37. void CGameplayRecorder::Init()
  38. {
  39. }
  40.  
  41. //------------------------------------------------------------------------
  42. void CGameplayRecorder::Update(float frameTime)
  43. {
  44.         // modify this as you wish
  45.         //m_example.RecordGameData();
  46.  
  47.         // if anyone needs to touch this, talk to Lin first
  48.         m_pMetadataRecorder->Flush();
  49.  
  50.         //CTimeValue now(gEnv->pTimer->GetFrameStartTime());
  51.         //if (gEnv->pTimer->GetFrameStartTime()-m_lastdiscreet<m_sampleinterval)
  52.         //      return;
  53.  
  54.         //m_lastdiscreet=now;
  55.         /* disabled
  56.            // only actors for now
  57.            IActorIteratorPtr actorIt=m_pGameFramework->GetIActorSystem()->CreateActorIterator();
  58.            while (IActor *pActor=actorIt->Next())
  59.             Event(pActor->GetEntity(), GameplayEvent(eGE_DiscreetSample));
  60.          */
  61.         if (m_pGameStateRecorder && m_pGameStateRecorder->IsEnabled())
  62.                 m_pGameStateRecorder->Update();
  63. }
  64.  
  65. //------------------------------------------------------------------------
  66. void CGameplayRecorder::Release()
  67. {
  68.  
  69.         SAFE_RELEASE(m_pGameStateRecorder);
  70.  
  71.         delete this;
  72. }
  73.  
  74. //------------------------------------------------------------------------
  75. void CGameplayRecorder::RegisterListener(IGameplayListener* pGameplayListener)
  76. {
  77.         stl::push_back_unique(m_listeners, pGameplayListener);
  78. }
  79.  
  80. //------------------------------------------------------------------------
  81. void CGameplayRecorder::UnregisterListener(IGameplayListener* pGameplayListener)
  82. {
  83.         stl::find_and_erase(m_listeners, pGameplayListener);
  84.  
  85.         if (m_listeners.empty())
  86.         {
  87.                 stl::free_container(m_listeners);
  88.         }
  89. }
  90.  
  91. //------------------------------------------------------------------------
  92. void CGameplayRecorder::Event(IEntity* pEntity, const GameplayEvent& event)
  93. {
  94.         std::vector<IGameplayListener*>::iterator it = m_listeners.begin();
  95.         std::vector<IGameplayListener*>::iterator end = m_listeners.end();
  96.  
  97.         if (CCryActionCVars::Get().g_debug_stats)
  98.         {
  99.                 CryLog("GamePlay event %u, %p, value:%f extra:%p desc:%s", event.event, pEntity, event.value, event.extra, event.description ? event.description : "");
  100.         }
  101.  
  102.         for (; it != end; ++it)
  103.         {
  104.                 (*it)->OnGameplayEvent(pEntity, event);
  105.         }
  106. }
  107.  
  108. void CGameplayRecorder::OnGameData(const IMetadata* pGameData)
  109. {
  110.         m_pMetadataRecorder->RecordIt(pGameData); // will be flushed together with all other gamedata collected in this frame
  111.         // flushing is performed in Update
  112. }
  113.  
  114. void CGameplayRecorder::CExampleMetadataListener::RecordGameData()
  115. {
  116.         IGameplayRecorder* pRecorder = CCryAction::GetCryAction()->GetIGameplayRecorder();
  117.  
  118.         {
  119.                 int64 t = gEnv->pTimer->GetFrameStartTime().GetValue();
  120.                 IMetadataPtr pMetadata;
  121.                 pMetadata->SetTag(eDT_frame);
  122.                 pMetadata->SetValue(eBT_i64, (uint8*)&t, 8);
  123.                 //m_pMetadataRecorder->RecordIt( pMetadata.get() );
  124.                 pRecorder->OnGameData(pMetadata.get());
  125.         }
  126.  
  127.         IActorSystem* pActorSystem = CCryAction::GetCryAction()->GetIActorSystem();
  128.  
  129.         IEntityItPtr it = gEnv->pEntitySystem->GetEntityIterator();
  130.         while (!it->IsEnd())
  131.         {
  132.                 IEntity* pEntity = it->Next();
  133.                 if (!pEntity->IsActive())
  134.                         continue;
  135.  
  136.                 if (IActor* pActor = pActorSystem->GetActor(pEntity->GetId()))
  137.                 {
  138.                         IMetadataPtr pActorMetadata;
  139.  
  140.                         // 'actr'
  141.                         pActorMetadata->SetTag(eDT_actor);
  142.  
  143.                         string sActorName = pActor->GetEntity()->GetName();
  144.                         pActorMetadata->AddField(eDT_name, eBT_str, (uint8*)sActorName.data(), static_cast<uint8>(sActorName.size()));
  145.                         Vec3 pos = pActor->GetEntity()->GetWorldPos();
  146.                         pActorMetadata->AddField(eDT_position, eBT_vec3, (uint8*)&pos, sizeof(pos));
  147.                         if (pActor != NULL)
  148.                         {
  149.                                 uint8 health = pActor->GetHealthAsRoundedPercentage();
  150.                                 pActorMetadata->AddField(eDT_health, eBT_i08, &health, 1);
  151.                                 uint8 armor = pActor->GetArmor();
  152.                                 pActorMetadata->AddField(eDT_armor, eBT_i08, &armor, 1);
  153.                                 uint8 isgod = pActor->IsGod() ? 0xff : 0x00;
  154.                                 pActorMetadata->AddField(eDT_isgod, eBT_i08, &isgod, 1);
  155.                                 //uint8 third = pOldActor->IsThirdPerson() ? 0xff : 0x00;
  156.                                 //pActorMetadata->AddField(eDT_3rdperson, eBT_i08, &third, 1);
  157.                                 if (IItem* pItem = pActor->GetCurrentItem())
  158.                                 {
  159.                                         IMetadataPtr pItemMetadata;
  160.                                         pItemMetadata->SetTag(eDT_item);
  161.                                         string name = pItem->GetEntity()->GetName();
  162.                                         pItemMetadata->AddField(eDT_name, eBT_str, (uint8*)name.data(), static_cast<uint8>(name.size()));
  163.                                         if (IWeapon* pWeapon = pItem->GetIWeapon())
  164.                                         {
  165.                                                 IMetadataPtr pWeaponMetadata;
  166.                                                 pWeaponMetadata->SetTag(eDT_weapon);
  167.                                                 IFireMode* pFireMode = pWeapon->GetFireMode(pWeapon->GetCurrentFireMode());
  168.                                                 string fire = pFireMode->GetName();
  169.                                                 pWeaponMetadata->AddField(eDT_firemode, eBT_str, (uint8*)fire.data(), static_cast<uint8>(fire.size()));
  170.                                                 if (pFireMode->GetAmmoType())
  171.                                                 {
  172.                                                         string ammt = pFireMode->GetAmmoType()->GetName();
  173.                                                         pWeaponMetadata->AddField(eDT_ammotype, eBT_str, (uint8*)ammt.data(), static_cast<uint8>(ammt.size()));
  174.                                                 }
  175.                                                 uint32 ammo = pFireMode->GetAmmoCount();
  176.                                                 pWeaponMetadata->AddField(eDT_ammocount, eBT_u32, (uint8*)&ammo, sizeof(ammo));
  177.  
  178.                                                 pItemMetadata->AddField(pWeaponMetadata.get());
  179.                                         }
  180.                                         pActorMetadata->AddField(pItemMetadata.get());
  181.                                 }
  182.                         }
  183.  
  184.                         //m_pMetadataRecorder->RecordIt(pActorMetadata.get());
  185.                         pRecorder->OnGameData(pActorMetadata.get());
  186.                 }
  187.                 else
  188.                 {
  189.                         // 'entt' name/class/position
  190.                         IMetadataPtr pEntityMetadata;
  191.                         pEntityMetadata->SetTag(eDT_entity);
  192.                         string name = pEntity->GetName();
  193.                         pEntityMetadata->AddField(eDT_name, eBT_str, (uint8*)name.data(), static_cast<uint8>(name.size()));
  194.                         string type = pEntity->GetClass()->GetName();
  195.                         pEntityMetadata->AddField(eDT_type, eBT_str, (uint8*)type.data(), static_cast<uint8>(type.size()));
  196.                         Vec3 pos = pEntity->GetWorldPos();
  197.                         pEntityMetadata->AddField(eDT_position, eBT_vec3, (uint8*)&pos, sizeof(pos));
  198.  
  199.                         //m_pMetadataRecorder->RecordIt(pEntityMetadata.get());
  200.                         pRecorder->OnGameData(pEntityMetadata.get());
  201.                 }
  202.         }
  203. }
  204.  
  205. void CGameplayRecorder::CExampleMetadataListener::OnData(const IMetadata* metadata)
  206. {
  207.         //DumpMetadata(metadata, 0);
  208.  
  209.         CCompositeData data;
  210.         data.Compose(metadata);
  211.  
  212.         switch (metadata->GetTag())
  213.         {
  214.         case eDT_frame:
  215.                 {
  216.                         CTimeValue tv;
  217.                         if (const int64* temp = boost::get<const int64>(&data.GetValue()))
  218.                                 tv = *temp;
  219.                         CryLog("frame %f", tv.GetSeconds());
  220.                 }
  221.                 break;
  222.  
  223.         case eDT_entity:
  224.                 {
  225.                         string name;
  226.                         if (const string* temp = boost::get<const string>(&data.GetField(eDT_name).GetValue()))
  227.                                 name = *temp;
  228.                         string type;
  229.                         if (const string* temp = boost::get<const string>(&data.GetField(eDT_type).GetValue()))
  230.                                 type = *temp;
  231.                         Vec3 pos;
  232.                         if (const Vec3* temp = boost::get<const Vec3>(&data.GetField(eDT_position).GetValue()))
  233.                                 pos = *temp;
  234.  
  235.                         CryLog("entity [%s] [%s] [%f,%f,%f]", name.c_str(), type.c_str(), pos.x, pos.y, pos.z);
  236.                 }
  237.                 break;
  238.  
  239.         case eDT_actor:
  240.                 {
  241.                         string name;
  242.                         if (const string* temp = boost::get<const string>(&data.GetField(eDT_name).GetValue()))
  243.                                 name = *temp;
  244.                         Vec3 pos;
  245.                         if (const Vec3* temp = boost::get<const Vec3>(&data.GetField(eDT_position).GetValue()))
  246.                                 pos = *temp;
  247.                         string item;
  248.                         if (const string* temp = boost::get<const string>(&data.GetField(eDT_item).GetField(eDT_name).GetValue()))
  249.                                 item = *temp;
  250.                         string firemode;
  251.                         if (const string* temp = boost::get<const string>(&data.GetField(eDT_item).GetField(eDT_weapon).GetField(eDT_firemode).GetValue()))
  252.                                 firemode = *temp;
  253.                         CryLog("actor [%s] [%s] [%s] [%f,%f,%f]", name.c_str(), item.c_str(), firemode.c_str(), pos.x, pos.y, pos.z);
  254.                 }
  255.                 break;
  256.         }
  257. }
  258.  
  259. IGameStateRecorder* CGameplayRecorder::EnableGameStateRecorder(bool bEnable, IGameplayListener* pL, bool bRecording)
  260. {
  261.  
  262.         if (!m_pGameStateRecorder)
  263.         {
  264.                 if (auto* pGame = gEnv->pGameFramework->GetIGame())
  265.                         m_pGameStateRecorder = pGame->CreateGameStateRecorder(pL);//pTestManager);
  266.         }
  267.  
  268.         if (m_pGameStateRecorder)
  269.         {
  270.                 m_pGameStateRecorder->Enable(bEnable, bRecording);
  271.         }
  272.         return m_pGameStateRecorder;
  273. }
  274.  
  275. ////////////////////////////////////////////////////////////////////////////
  276. void CGameplayRecorder::GetMemoryStatistics(ICrySizer* s)
  277. {
  278.         SIZER_SUBCOMPONENT_NAME(s, "GameplayRecorder");
  279.         s->Add(*this);
  280.         s->AddContainer(m_listeners);
  281.  
  282.         if (m_pGameStateRecorder)
  283.                 m_pGameStateRecorder->GetMemoryStatistics(s);
  284. }
  285.  
downloadGameplayRecorder.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top