461 lines
13 KiB
C++
461 lines
13 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Implemenatation of CMatchInfo
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
//
|
|
//------------------------------------------------------------------------------------------------------
|
|
// $Log: $
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "MatchInfo.h"
|
|
|
|
CMatchInfo* g_pMatchInfo=NULL; //global information about the match.
|
|
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Function: CMatchInfo::generate
|
|
// Purpose: generates the match info structure from the log file
|
|
//------------------------------------------------------------------------------------------------------
|
|
void CMatchInfo::generate()
|
|
{
|
|
if (plogfile->empty())
|
|
g_pApp->fatalError("No data in log file!\nPlease ensure that you are running TFstats on a valid log file!");
|
|
|
|
CEventListIterator it=plogfile->begin();
|
|
logopentime=(*it)->getTime();
|
|
for (it;it!=plogfile->end();++it)
|
|
{
|
|
const CLogEvent* curr=(*it);
|
|
switch(curr->getType())
|
|
{
|
|
case CLogEvent::CONNECT:
|
|
{
|
|
int sid=curr->getArgument(0)->asPlayerGetSvrPID();
|
|
unsigned long WONid=curr->getArgument(0)->asPlayerGetWONID();
|
|
string plrName=curr->getArgument(0)->asPlayerGetName();
|
|
string ipAddress=curr->getArgument(1)->getStringValue();
|
|
PID pid;
|
|
PID foundpid=-1;
|
|
if (WONid!=-1)
|
|
{
|
|
bLanGame=false;
|
|
pid=pidMap[sid]=WONid;
|
|
}
|
|
else
|
|
{
|
|
bLanGame=true;
|
|
|
|
CPlayerList::iterator it=players.begin();
|
|
for (it;it!=players.end();++it)
|
|
{
|
|
PID currpid=it->first;
|
|
CPlayer& cp=it->second;
|
|
if (cp.ipAddress==ipAddress)
|
|
{
|
|
foundpid=currpid;
|
|
break;
|
|
}
|
|
}
|
|
if (it==players.end()) //if no ip addresses matched match by name
|
|
{
|
|
it = players.begin();
|
|
for (it;it!=players.end();++it)
|
|
{
|
|
PID currpid=it->first;
|
|
CPlayer& cp=it->second;
|
|
if (cp.aliases.contains(plrName))
|
|
{
|
|
foundpid=currpid;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (foundpid != -1)
|
|
{
|
|
pid=pidMap[sid]=foundpid;
|
|
}
|
|
else
|
|
{
|
|
pid=pidMap[sid]=sid;
|
|
}
|
|
//printf("Checkpoint %lu\n",__LINE__);
|
|
//printf("pid=%lu\n",pid);
|
|
if (players[pid].pid==-1)
|
|
players[pid].pid=pid;
|
|
|
|
players[pid].ipAddress=ipAddress;
|
|
players[pid].svrPID=sid;
|
|
players[pid].WONID=WONid;
|
|
//keep the pseudonym list updated
|
|
players[pid].nameFound(curr->getTime(),plrName);
|
|
|
|
}
|
|
break;
|
|
case CLogEvent::ENTER_GAME:
|
|
{
|
|
int sid=curr->getArgument(0)->asPlayerGetSvrPID();
|
|
//PID pid=curr->getArgument(0)->asPlayerGetFullPID();
|
|
unsigned long WONid=curr->getArgument(0)->asPlayerGetWONID();
|
|
|
|
PID pid;
|
|
if (WONid!=-1)
|
|
{
|
|
bLanGame=false;
|
|
pid=pidMap[sid]=WONid;
|
|
}
|
|
else
|
|
{
|
|
bLanGame=true;
|
|
|
|
//they may have matched based on IP or name.
|
|
//so check if the player structure pointed to by
|
|
//the sid is valid, if so, don't reassign pid
|
|
pid=pidMap[sid];
|
|
if (players[pid].ipAddress=="")
|
|
pid=pidMap[sid]=sid;
|
|
}
|
|
|
|
players[pid].svrPID=sid;
|
|
players[pid].WONID=WONid;
|
|
players[pid].pid=pid;
|
|
string nm=curr->getArgument(0)->asPlayerGetName();
|
|
|
|
//keep the pseudonym list updated
|
|
players[pid].nameFound(curr->getTime(),nm);
|
|
}
|
|
break;
|
|
case CLogEvent::CLASS_CHANGE:
|
|
{
|
|
PID pid=curr->getArgument(0)->asPlayerGetPID();
|
|
time_t changetime=curr->getTime();
|
|
|
|
player_class newpc=playerClassNameToClassID(curr->getArgument(1)->getStringValue());
|
|
|
|
//keep the pseudonym list updated
|
|
players[pid].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
string plrname=curr->getArgument(0)->asPlayerGetName();
|
|
|
|
players[pid].allclassesplayed.add(changetime,newpc);
|
|
|
|
int currTeam=players[pid].teams.atTime(changetime);
|
|
players[pid].perteam[currTeam].classesplayed.add(changetime,newpc);
|
|
|
|
}
|
|
break;
|
|
case CLogEvent::NAME_CHANGE:
|
|
{
|
|
//keep the pseudonym list updated
|
|
players[curr->getArgument(0)->asPlayerGetPID()].nameFound(curr->getTime(),curr->getArgument(1)->asPlayerGetName());
|
|
}
|
|
break;
|
|
case CLogEvent::SUICIDE:
|
|
{
|
|
PID pid=(*it)->getArgument(0)->asPlayerGetPID();
|
|
int team=players[pid].teams.atTime((*it)->getTime());
|
|
|
|
// players[pid].perteam[team].kills++;
|
|
players[pid].perteam[team].deaths++;
|
|
players[pid].perteam[team].suicides++;
|
|
|
|
//keep the pseudonym list updated
|
|
players[pid].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
}
|
|
break;
|
|
case CLogEvent::FRAG:
|
|
case CLogEvent::TEAM_FRAG:
|
|
{
|
|
PID killerid=(*it)->getArgument(0)->asPlayerGetPID();
|
|
PID killedid=(*it)->getArgument(1)->asPlayerGetPID();
|
|
int killerTeam=players[killerid].teams.atTime((*it)->getTime());
|
|
int killedTeam=players[killedid].teams.atTime((*it)->getTime());
|
|
|
|
|
|
CPlayer& p1=players[killerid];
|
|
CPlayer& p2=players[killedid];
|
|
|
|
|
|
if (curr->getType() == CLogEvent::TEAM_FRAG)
|
|
{
|
|
players[killerid].perteam[killerTeam].teamkills++;
|
|
players[killedid].perteam[killedTeam].teamkilled++;
|
|
}
|
|
else if (curr->getType() == CLogEvent::FRAG)
|
|
{
|
|
string weapName=(*it)->getArgument(2)->getStringValue();
|
|
|
|
bool countKill=true;
|
|
|
|
//gotta account for timer/infection double kills for medics!
|
|
if (weapName=="infection")
|
|
{
|
|
//test to see if the previous event was a timer from the same player, and a kill, and with the timer.
|
|
CEventListIterator it2=it;
|
|
if ((--it2)!=plogfile->begin())
|
|
{
|
|
if ((*it2)->getType() == CLogEvent::FRAG)
|
|
if ((*it2)->getArgument(2)->getStringValue()=="timer")
|
|
if ((*it2)->getArgument(0)->asPlayerGetPID()==killerid)
|
|
countKill=false;
|
|
}
|
|
}
|
|
if (countKill)
|
|
{
|
|
|
|
players[killerid].perteam[killerTeam].weaponKills[weapName]++;
|
|
players[killerid].perteam[killerTeam].kills++;
|
|
players[killedid].perteam[killedTeam].deaths++;
|
|
}
|
|
}
|
|
|
|
//keep the pseudonym list updated
|
|
players[killerid].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
players[killedid].nameFound(curr->getTime(),curr->getArgument(1)->asPlayerGetName());
|
|
|
|
}
|
|
break;
|
|
case CLogEvent::TEAM_JOIN:
|
|
{
|
|
int team=curr->getArgument(1)->getFloatValue();
|
|
team--; //teams are logged as 1-4. tfstats stores them as 0-3
|
|
PID pid=curr->getArgument(0)->asPlayerGetPID();
|
|
|
|
|
|
CPlayer& p=players[pid];
|
|
team_exists[team]=true;
|
|
|
|
int oldteam=team;
|
|
if(p.teams.anythingAtTime(curr->getTime()-1))
|
|
oldteam=p.teams.atTime(curr->getTime()-1);
|
|
else //if this is the first team join, count them as in the game
|
|
players[pid].logontime=curr->getTime();
|
|
|
|
//keep the pseudonym list updated
|
|
players[pid].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
|
|
players[pid].teams.add(curr->getTime(),team);
|
|
|
|
if (p.allclassesplayed.anythingAtTime(curr->getTime()))
|
|
{
|
|
player_class plrcurrclass=players[pid].allclassesplayed.atTime(curr->getTime());
|
|
players[pid].perteam[oldteam].classesplayed.cut(curr->getTime());
|
|
players[pid].perteam[team].classesplayed.add(curr->getTime(),plrcurrclass);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CLogEvent::TEAM_RENAME:
|
|
{
|
|
int teamid=curr->getArgument(0)->getFloatValue()-1;
|
|
string tname=curr->getArgument(1)->getStringValue();
|
|
teamnames[teamid]=tname;
|
|
}
|
|
break;
|
|
|
|
case CLogEvent::SERVER_NAME:
|
|
{
|
|
servername=curr->getArgument(0)->getStringValue();
|
|
}
|
|
break;
|
|
case CLogEvent::SERVER_SPAWN:
|
|
{
|
|
mapname=curr->getArgument(0)->getStringValue();
|
|
}
|
|
break;
|
|
case CLogEvent::DISCONNECT:
|
|
{
|
|
PID pid=curr->getArgument(0)->asPlayerGetPID();
|
|
players[pid].logofftime=curr->getTime();
|
|
players[pid].allclassesplayed.endTime=curr->getTime();
|
|
players[pid].allclassesplayed.cut(curr->getTime());
|
|
players[pid].teams.cut(curr->getTime());
|
|
players[pid].aliases.cut(curr->getTime());
|
|
|
|
int currTeam=players[pid].teams.atTime(curr->getTime());
|
|
players[pid].perteam[currTeam].classesplayed.cut(curr->getTime());
|
|
|
|
//keep the pseudonym list updated
|
|
if (pid!=-1) //sometimes disconnect messages have -1 for the pid
|
|
players[pid].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
|
|
}
|
|
break;
|
|
case CLogEvent::NAMED_BROADCAST:
|
|
{
|
|
//keep the pseudonym list updated
|
|
const CLogEventArgument* pArg=curr->getArgument(1);
|
|
PID pid=pArg->asPlayerGetPID();
|
|
players[pid].nameFound(curr->getTime(),curr->getArgument(1)->asPlayerGetName());
|
|
}
|
|
break;
|
|
case CLogEvent::NAMED_GOAL_ACTIVATE:
|
|
{
|
|
//keep the pseudonym list updated
|
|
players[curr->getArgument(0)->asPlayerGetPID()].nameFound(curr->getTime(),curr->getArgument(0)->asPlayerGetName());
|
|
}
|
|
break;
|
|
case CLogEvent::LOG_CLOSED:
|
|
{
|
|
logclosetime=curr->getTime();
|
|
}
|
|
break;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
#ifdef _PARSEDEBUG
|
|
|
|
printf("%s:\n",CLogEvent::TypeNames[(int)curr->getType()]);
|
|
fflush(stdout);
|
|
printf("\t%s\n",curr->m_StrippedText);
|
|
fflush(stdout);
|
|
for (int i=0;curr->getArgument(i);i++)
|
|
{
|
|
if (i==0)
|
|
printf("\t\targs: ");
|
|
fflush(stdout);
|
|
printf("\"%s\" ",curr->getArgument(i)->getStringValue());
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
if (logclosetime==0 && !plogfile->empty())
|
|
{
|
|
CEventListIterator it=plogfile->end();
|
|
--it;
|
|
logclosetime=(*it)->getTime();
|
|
}
|
|
|
|
map<PID,CPlayer>::iterator it2;
|
|
for(it2=players.begin();it2!=players.end();++it2)
|
|
{
|
|
CPlayer& p=(*it2).second;
|
|
|
|
|
|
if (p.aliases.endTime < logclosetime)
|
|
p.aliases.endTime=logclosetime;
|
|
|
|
p.name=p.aliases.favourite();
|
|
|
|
if (p.allclassesplayed.endTime < logclosetime)
|
|
p.allclassesplayed.endTime=logclosetime;
|
|
|
|
if (p.teams.endTime < logclosetime)
|
|
p.teams.endTime=logclosetime;
|
|
|
|
for (int i=0;i<MAX_TEAMS;i++)
|
|
{
|
|
//if you have no kills you have to play on a team at least 30 seconds to be counted part of it
|
|
//also give a one-suicide grace so they can killthemselves to get onto another team?
|
|
if (p.teams.howLong(i) < 30 && p.perteam[i].kills==0)// && p.perteam[i].deaths < 1)
|
|
p.teams.remove(i);
|
|
|
|
CTimeIndexedList<player_class>* v= &p.perteam[i].classesplayed;
|
|
p.perteam[i].classesplayed.endTime=logclosetime;
|
|
|
|
time_t t=p.teams.howLong(i);
|
|
p.perteam[i].timeon=t;
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Function: CMatchInfo::getPlayerID
|
|
// Purpose: resolves a player name to that players PID
|
|
// Input: name - the name
|
|
// Output: PID the PID
|
|
//------------------------------------------------------------------------------------------------------
|
|
PID CMatchInfo::getPlayerID(string name)
|
|
{
|
|
CPlayerListIterator it;
|
|
|
|
//ugh! O(n)
|
|
for (it=playerBegin();it!=playerEnd();++it)
|
|
{
|
|
PID id=(*it).first;
|
|
CPlayer curr=(*it).second;
|
|
|
|
if (curr.name == name)
|
|
return id;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
unsigned long CMatchInfo::getPlayerWONID(string name)
|
|
{
|
|
CPlayerListIterator it;
|
|
|
|
//ugh! O(n)
|
|
for (it=playerBegin();it!=playerEnd();++it)
|
|
{
|
|
CPlayer curr=(*it).second;
|
|
|
|
if (curr.name == name)
|
|
return curr.WONID;
|
|
}
|
|
return 0xffffffff;
|
|
}
|
|
*/
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Function: CMatchInfo::CMatchInfo
|
|
// Purpose: Constructor
|
|
// Input: plf - the log file
|
|
// Output:
|
|
//------------------------------------------------------------------------------------------------------
|
|
CMatchInfo::CMatchInfo(CEventList* plf)
|
|
:numPlrs(0),logclosetime(0),plogfile(plf)
|
|
{
|
|
teamnames[0]="Blue";
|
|
teamnames[1]="Red";
|
|
teamnames[2]="Yellow";
|
|
teamnames[3]="Green";
|
|
team_exists[0]=team_exists[1]=team_exists[2]=team_exists[3]=false;
|
|
|
|
|
|
generate();
|
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Function: CMatchInfo::teamID
|
|
// Purpose: resolves a team name to its ID
|
|
// Input: teamname - the team name
|
|
// Output: int the ID of the team
|
|
//------------------------------------------------------------------------------------------------------
|
|
int CMatchInfo::teamID(string teamname)
|
|
{
|
|
for (int i=0;i<MAX_TEAMS;i++)
|
|
if (stricmp(teamname.c_str(),teamnames[i].c_str())==0)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Function: CMatchInfo::getTimeOn
|
|
// Purpose: returns how long the specified player has been playing
|
|
// Input: pid - the player being queried
|
|
// Output: time_t the time he/she played
|
|
//------------------------------------------------------------------------------------------------------
|
|
time_t CMatchInfo::getTimeOn(PID pid)
|
|
{
|
|
CPlayer& p=players[pid];
|
|
|
|
if (p.logofftime==0)
|
|
p.logofftime=logclosetime;
|
|
|
|
time_t timeon=p.logofftime-p.logontime;
|
|
|
|
return timeon;
|
|
}
|