BVB Source Codes

CRYENGINE Show Analyst.cpp Source code

Return Download CRYENGINE: download Analyst.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "Analyst.h"
  5. #include "ILevelSystem.h"
  6. #include "IGameRulesSystem.h"
  7.  
  8. //------------------------------------------------------------------------
  9. CGameplayAnalyst::CGameplayAnalyst()
  10. {
  11. }
  12.  
  13. //------------------------------------------------------------------------
  14. CGameplayAnalyst::~CGameplayAnalyst()
  15. {
  16.  
  17. }
  18.  
  19. void CGameplayAnalyst::ProcessPlayerEvent(EntityId id, const GameplayEvent& event)
  20. {
  21.         switch (event.event)
  22.         {
  23.         case eGE_Connected:
  24.                 {
  25.                         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(id);
  26.                         NewPlayer(pEntity);
  27.                 }
  28.                 break;
  29.         case eGE_Renamed:
  30.                 GetPlayer(id).name = event.description;
  31.                 break;
  32.         case eGE_Kill:
  33.                 {
  34.                         PlayerAnalysis& player = GetPlayer(id);
  35.                         player.kills++;
  36.                         player.suit.kills[player.suit.mode]++;
  37.                         GetWeapon(id, ((EntityId*)event.extra)[0]).kills++;
  38.                 }
  39.                 break;
  40.         case eGE_Death:
  41.                 {
  42.                         PlayerAnalysis& player = GetPlayer(id);
  43.                         player.deaths++;
  44.  
  45.                         GetCurrentWeapon(id).deaths++;
  46.                         player.suit.deaths[player.suit.mode]++;
  47.  
  48.                         CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  49.  
  50.                         if (player.deathStart.GetMilliSeconds() == 0)
  51.                                 player.deathStart = now;
  52.  
  53.                         if (player.alive)
  54.                                 player.timeAlive += now - player.deathStart;
  55.  
  56.                         player.deathStart = now;
  57.                         player.alive = false;
  58.                 }
  59.                 break;
  60.  
  61.         case eGE_Revive:
  62.                 {
  63.                         PlayerAnalysis& player = GetPlayer(id);
  64.                         CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  65.  
  66.                         if (player.deathStart.GetMilliSeconds() == 0)
  67.                                 player.deathStart = now;
  68.  
  69.                         if (!player.alive)
  70.                                 player.timeDead += now - player.deathStart;
  71.                         player.deathStart = now;
  72.                         player.alive = true;
  73.                 }
  74.                 break;
  75.  
  76.         case eGE_WeaponHit:
  77.                 GetPlayer(id).hits++;
  78.                 GetWeapon(id, ((EntityId*)event.extra)[0]).hits++;
  79.                 break;
  80.         case eGE_WeaponShot:
  81.                 GetPlayer(id).shots += (int)event.value;
  82.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).shots += (int)event.value;
  83.                 break;
  84.         case eGE_WeaponMelee:
  85.                 GetPlayer(id).melee++;
  86.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).melee++;
  87.                 break;
  88.         case eGE_WeaponReload:
  89.                 GetPlayer(id).reloads++;
  90.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).reloads++;
  91.                 break;
  92.         case eGE_WeaponFireModeChanged:
  93.                 GetPlayer(id).firemodes++;
  94.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).firemodes++;
  95.                 break;
  96.         case eGE_ZoomedIn:
  97.                 GetPlayer(id).zoomUsage++;
  98.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).zoomUsage++;
  99.                 break;
  100.  
  101.         case eGE_ItemSelected:
  102.                 GetPlayer(id).itemUsage;
  103.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).usage++;
  104.                 break;
  105.  
  106.         case eGE_Damage:
  107.                 GetPlayer(id).damage += (int)event.value;
  108.                 GetWeapon(id, (EntityId)(TRUNCATE_PTR)event.extra).damage += (int)event.value;
  109.                 break;
  110.  
  111.         case eGE_SuitModeChanged:
  112.                 {
  113.                         PlayerAnalysis& player = GetPlayer(id);
  114.                         SuitAnalysis& suit = player.suit;
  115.  
  116.                         CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  117.  
  118.                         if (suit.usageStart.GetMilliSeconds() == 0)
  119.                                 suit.usageStart = player.timeStart;
  120.  
  121.                         suit.timeUsed[suit.mode] += now - suit.usageStart;
  122.  
  123.                         suit.mode = (int)event.value;
  124.                         suit.usage[(int)event.value]++;
  125.                         suit.usageStart = now;
  126.                 }
  127.                 break;
  128.  
  129.         case eGE_Rank:
  130.                 {
  131.                         PlayerAnalysis& player = GetPlayer(id);
  132.  
  133.                         CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  134.  
  135.                         if (player.rankStart.GetMilliSeconds() == 0)
  136.                                 player.rankStart = player.timeStart;
  137.  
  138.                         if (player.maxRank < event.value)
  139.                                 player.maxRank = (int)event.value;
  140.  
  141.                         if (player.rank > event.value)
  142.                                 ++player.demotions;
  143.                         if (player.rank < event.value)
  144.                                 ++player.promotions;
  145.  
  146.                         CRY_ASSERT(player.rank < 10);
  147.                         player.rankTime[player.rank] += now - player.rankStart;
  148.                         player.rank = (int)event.value;
  149.                         player.rankStart = now;
  150.                 }
  151.                 break;
  152.         default:
  153.                 break;
  154.         }
  155. }
  156.  
  157. //------------------------------------------------------------------------
  158. void CGameplayAnalyst::OnGameplayEvent(IEntity* pEntity, const GameplayEvent& event)
  159. {
  160.         if (!gEnv->bServer)
  161.                 return;
  162.  
  163.         EntityId id = pEntity ? pEntity->GetId() : 0;
  164.  
  165.         if (id && IsPlayer(id))
  166.                 ProcessPlayerEvent(id, event);
  167.  
  168.         switch (event.event)
  169.         {
  170.         case eGE_GameStarted:
  171.                 if (event.value)//only for server event
  172.                         Reset();
  173.                 break;
  174.         case eGE_GameEnd:
  175.                 if (event.value)//only for server event
  176.                         DumpToTXT();
  177.                 break;
  178.         default:
  179.                 break;
  180.         }
  181. }
  182.  
  183. //------------------------------------------------------------------------
  184. void CGameplayAnalyst::NewPlayer(IEntity* pEntity)
  185. {
  186.         if (!pEntity)
  187.                 return;
  188.  
  189.         std::pair<Players::iterator, bool> result = m_gameanalysis.players.insert(Players::value_type(pEntity->GetId(), PlayerAnalysis()));
  190.         result.first->second.name = pEntity->GetName();
  191.         result.first->second.timeStart = gEnv->pTimer->GetFrameStartTime();
  192. }
  193.  
  194. //------------------------------------------------------------------------
  195. bool CGameplayAnalyst::IsPlayer(EntityId entityId) const
  196. {
  197.         if (IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(entityId))
  198.                 return pActor->IsPlayer();
  199.         return false;
  200. }
  201.  
  202. //------------------------------------------------------------------------
  203. CGameplayAnalyst::PlayerAnalysis& CGameplayAnalyst::GetPlayer(EntityId playerId)
  204. {
  205.         Players::iterator it = m_gameanalysis.players.find(playerId);
  206.         if (it != m_gameanalysis.players.end())
  207.                 return it->second;
  208.  
  209.         static PlayerAnalysis def;
  210.         return def;
  211. }
  212.  
  213. //------------------------------------------------------------------------
  214. CGameplayAnalyst::WeaponAnalysis& CGameplayAnalyst::GetWeapon(EntityId playerId, EntityId weaponId)
  215. {
  216.         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(weaponId))
  217.                 return GetWeapon(playerId, pEntity->GetClass()->GetName());
  218.  
  219.         static WeaponAnalysis def;
  220.         return def;
  221. }
  222.  
  223. //------------------------------------------------------------------------
  224. CGameplayAnalyst::WeaponAnalysis& CGameplayAnalyst::GetWeapon(EntityId playerId, const char* weapon)
  225. {
  226.         PlayerAnalysis& player = GetPlayer(playerId);
  227.  
  228.         Weapons::iterator it = player.weapons.find(CONST_TEMP_STRING(weapon));
  229.         if (it == player.weapons.end())
  230.         {
  231.                 std::pair<Weapons::iterator, bool> result = player.weapons.insert(Weapons::value_type(weapon, WeaponAnalysis()));
  232.                 return result.first->second;
  233.         }
  234.         else
  235.                 return it->second;
  236. }
  237.  
  238. //------------------------------------------------------------------------
  239. CGameplayAnalyst::WeaponAnalysis& CGameplayAnalyst::GetCurrentWeapon(EntityId playerId)
  240. {
  241.         if (IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(playerId))
  242.         {
  243.                 if (IInventory* pInventory = pActor->GetInventory())
  244.                         return GetWeapon(playerId, pInventory->GetCurrentItem());
  245.         }
  246.  
  247.         static WeaponAnalysis def;
  248.         return def;
  249. }
  250.  
  251. //------------------------------------------------------------------------
  252. void CGameplayAnalyst::Reset()
  253. {
  254.         m_gameanalysis = GameAnalysis();
  255.  
  256.         IActorSystem* pActorSystem = CCryAction::GetCryAction()->GetIActorSystem();
  257.         IActorIteratorPtr pActorIt = pActorSystem->CreateActorIterator();
  258.         while (IActor* pActor = pActorIt->Next())
  259.         {
  260.                 if (pActor && pActor->GetChannelId())
  261.                         NewPlayer(pActor->GetEntity());
  262.         }
  263.  
  264.         CryLog("Player statistics reset...");
  265. }
  266.  
  267. //------------------------------------------------------------------------
  268. void CGameplayAnalyst::DumpToTXT()
  269. {
  270.         const char* level = CCryAction::GetCryAction()->GetILevelSystem()->GetCurrentLevel()->GetName();
  271.         const char* gamerules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity()->GetClass()->GetName();
  272.  
  273.         string lines;
  274.         lines.append(level);
  275.         lines.append("\n");
  276.         lines.append(gamerules);
  277.         lines.append("\n\n");
  278.  
  279.         for (Players::iterator it = m_gameanalysis.players.begin(); it != m_gameanalysis.players.end(); ++it)
  280.                 DumpWeapon(it->first, lines);
  281.  
  282.         lines.append("\n\n");
  283.  
  284.         DumpRank(lines);
  285.         lines.append("\n\n");
  286.  
  287.         DumpSuit(lines);
  288.         lines.append("\n\n");
  289.  
  290.         DumpCurrency(lines);
  291.         lines.append("\n\n");
  292.  
  293.         ICryPak* pCryPak = gEnv->pCryPak;
  294.         FILE* pFile = 0;
  295.  
  296.         const char* fileFmt = "gameplaystats%03d.txt";
  297.         string fname;
  298.  
  299.         int i = 0;
  300.         while (++i < 1000)
  301.         {
  302.                 fname.Format(fileFmt, i);
  303.                 if (pFile = pCryPak->FOpen(fname.c_str(), "r"))
  304.                 {
  305.                         pCryPak->FClose(pFile);
  306.                         pFile = 0;
  307.  
  308.                         continue;
  309.                 }
  310.  
  311.                 fname.Format(fileFmt, i);
  312.                 if (pFile = pCryPak->FOpen(fname, "wb"))
  313.                         break;
  314.  
  315.                 return;
  316.         }
  317.  
  318.         if (!pFile)
  319.                 return;
  320.  
  321.         pCryPak->FWrite(lines.c_str(), lines.size(), 1, pFile);
  322.         pCryPak->FClose(pFile);
  323.  
  324.         CryLog("Player statistics saved to %s...", fname.c_str());
  325. }
  326.  
  327. //------------------------------------------------------------------------
  328. void CGameplayAnalyst::DumpWeapon(EntityId playerId, string& lines)
  329. {
  330.         PlayerAnalysis& player = GetPlayer(playerId);
  331.  
  332.         const char* header = "\tKills\tDeaths\tKillsPerDeath\tShots\tHits\tShootsPerKill\tAccuracy\tDamage\tUsage\tReloads\tMeleeAttacks\tFireModeChanges\tZoomIn\n";
  333.         const char* lineFmt = "%s\t%d\t%d\t%.2f\t%d\t%d\t%.2f\t%.2f\t%d\t%d\t%d\t%d\t%d\t%d\n";
  334.  
  335.         string lineFormatter;
  336.  
  337.         lines.append(header);
  338.         lines.append(lineFormatter.Format(lineFmt, player.name.c_str(), player.kills, player.deaths,
  339.                                           player.deaths ? player.kills / (float)player.deaths : player.kills,
  340.                                           player.shots, player.hits,
  341.                                           player.kills ? (player.shots / (float)player.kills) : player.shots,
  342.                                           player.shots ? (100 * player.hits / (float)player.shots) : 0.0f,
  343.                                           player.damage, player.itemUsage, player.reloads, player.melee, player.firemodes, player.zoomUsage));
  344.  
  345.         for (Weapons::iterator wit = player.weapons.begin(); wit != player.weapons.end(); ++wit)
  346.         {
  347.                 WeaponAnalysis& weapon = wit->second;
  348.                 lines.append(lineFormatter.Format(lineFmt, wit->first.c_str(), weapon.kills, weapon.deaths,
  349.                                                   weapon.deaths ? weapon.kills / (float)weapon.deaths : weapon.kills,
  350.                                                   weapon.shots, weapon.hits,
  351.                                                   weapon.kills ? weapon.shots / (float)weapon.kills : weapon.shots,
  352.                                                   weapon.shots ? 100 * weapon.hits / (float)weapon.shots : 0.0f,
  353.                                                   weapon.damage, weapon.usage, weapon.reloads, weapon.melee, weapon.firemodes, weapon.zoomUsage));
  354.         }
  355.         lines.append("\n");
  356. }
  357.  
  358. //------------------------------------------------------------------------
  359. void CGameplayAnalyst::DumpRank(string& lines)
  360. {
  361.         string header("\tHighestRank\tPromotions\tDemotions");
  362.         string lineFmt("%s\t%d\t%d\t%d");
  363.  
  364.         string headerFormatter;
  365.         for (int i = 1; i < 10; i++)
  366.         {
  367.                 header.append(headerFormatter.Format("\tRank %d Time", i));
  368.                 lineFmt.append("\t%.1f");
  369.         }
  370.         header.append("\n");
  371.         lineFmt.append("\n");
  372.  
  373.         lines.append(header);
  374.  
  375.         string lineFormatter;
  376.  
  377.         for (Players::iterator it = m_gameanalysis.players.begin(); it != m_gameanalysis.players.end(); ++it)
  378.         {
  379.                 PlayerAnalysis& player = it->second;
  380.  
  381.                 CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  382.  
  383.                 if (player.rankStart.GetMilliSeconds() == 0)
  384.                         player.rankStart = now;
  385.  
  386.                 player.rankTime[player.rank] += now - player.rankStart;
  387.                 player.rankStart = now;
  388.  
  389.                 lines.append(lineFormatter.Format(lineFmt, player.name.c_str(), player.maxRank, player.promotions, player.demotions,
  390.                                                   player.rankTime[1].GetSeconds(), player.rankTime[2].GetSeconds(), player.rankTime[3].GetSeconds(),
  391.                                                   player.rankTime[4].GetSeconds(), player.rankTime[5].GetSeconds(), player.rankTime[6].GetSeconds(),
  392.                                                   player.rankTime[7].GetSeconds(), player.rankTime[8].GetSeconds(), player.rankTime[9].GetSeconds()
  393.                                                   ));
  394.         }
  395. }
  396.  
  397. //------------------------------------------------------------------------
  398. void CGameplayAnalyst::DumpSuit(string& lines)
  399. {
  400.         string header("\tModeChanges\tSpeedKills\tSpeedDeaths\tSpeedUsage\tSpeedTime\tStrengthKills\tStrengthDeaths\tStrengthUsage\tStrengthTime\tCloakKills\tCloakDeaths\tCloakUsage\tCloakTime\tArmorKills\tArmorDeaths\tArmorUsage\tArmorTime\n");
  401.         string lineFmt("%s\t%d\t%d\t%d\t%d\t%.1f\t%d\t%d\t%d\t%.1f\t%d\t%d\t%d\t%.1f\t%d\t%d\t%d\t%.1f\n");
  402.  
  403.         lines.append(header);
  404.  
  405.         string lineFormatter;
  406.  
  407.         for (Players::iterator it = m_gameanalysis.players.begin(); it != m_gameanalysis.players.end(); ++it)
  408.         {
  409.                 SuitAnalysis& suit = it->second.suit;
  410.  
  411.                 CTimeValue now = gEnv->pTimer->GetFrameStartTime();
  412.  
  413.                 if (suit.usageStart.GetMilliSeconds() == 0)
  414.                         suit.usageStart = now;
  415.  
  416.                 suit.timeUsed[suit.mode] += now - suit.usageStart;
  417.                 suit.usageStart = now;
  418.  
  419.                 int totalUsage = suit.usage[0] + suit.usage[1] + suit.usage[2] + suit.usage[3];
  420.                 CTimeValue totalTime = suit.timeUsed[0] + suit.timeUsed[1] + suit.timeUsed[2] + suit.timeUsed[3];
  421.  
  422.                 lines.append(lineFormatter.Format(lineFmt, it->second.name.c_str(), totalUsage,
  423.                                                   suit.kills[0], suit.deaths[0], suit.usage[0], suit.timeUsed[0].GetSeconds(),
  424.                                                   suit.kills[1], suit.deaths[1], suit.usage[1], suit.timeUsed[1].GetSeconds(),
  425.                                                   suit.kills[2], suit.deaths[2], suit.usage[2], suit.timeUsed[2].GetSeconds(),
  426.                                                   suit.kills[3], suit.deaths[3], suit.usage[3], suit.timeUsed[3].GetSeconds()
  427.                                                   ));
  428.         }
  429. }
  430.  
  431. //------------------------------------------------------------------------
  432. void CGameplayAnalyst::DumpCurrency(string& lines)
  433. {
  434.         /*
  435.            const char *header="\tHighestRank\tPromotions\tDemotions\n"
  436.            const char *lineFmt="";
  437.  
  438.            string lineFormatter;
  439.  
  440.            for (Players::iterator it=m_gameanalysis.players.begin(); it!=m_gameanalysis.players.end(); it++)
  441.            {
  442.            PlayerAnalysis &player=it->second;
  443.  
  444.            lines.append(header);
  445.            lines.append(lineFormatter.Format(lineFmt,
  446.              ));
  447.            }
  448.          */
  449. }
  450.  
downloadAnalyst.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