This graph shows which files directly or indirectly include this file:

Macros
#define	PlayerStats_GameReport_Event_Player(ent, eventid, val)
#define	PlayerStats_GameReport_Event_Team(team, eventid, val)

Functions
void	PlayerStats_GameReport (bool finished)
void	PlayerStats_GameReport_Accuracy (entity p)
void	PlayerStats_GameReport_AddEvent (string event_id)
void	PlayerStats_GameReport_AddPlayer (entity e)
void	PlayerStats_GameReport_AddTeam (float t)
float	PlayerStats_GameReport_Event (string prefix, string event_id, float value)
void	PlayerStats_GameReport_FinalizePlayer (entity p)
void	PlayerStats_GameReport_Handler (entity fh, entity pass, float status)
void	PlayerStats_GameReport_Init ()
void	PlayerStats_GameReport_Reset_All ()
void	PlayerStats_PlayerBasic (entity joiningplayer, float newrequest)
void	PlayerStats_PlayerBasic_CheckUpdate (entity joiningplayer)
void	PlayerStats_PlayerBasic_Handler (entity fh, entity p, float status)
void	PlayerStats_PlayerDetail ()
void	PlayerStats_PlayerDetail_CheckUpdate ()
void	PlayerStats_PlayerDetail_Handler (entity fh, entity p, float status)
	REPLICATE_INIT (bool, cvar_cl_allow_uidranking)
	REPLICATE_INIT (int, cvar_cl_allow_uid2name)
	REPLICATE_INIT (int, cvar_cl_allow_uidtracking)

Variables
string	autocvar_g_playerstats_gamereport_ladder
string	autocvar_g_playerstats_gamereport_uri = "https://stats.xonotic.org/stats/submit"
string	autocvar_g_playerstats_playerbasic_uri = "https://stats.xonotic.org"
float	autocvar_g_playerstats_playerdetail_autoupdatetime = 1800
string	autocvar_g_playerstats_playerdetail_uri = "https://stats.xonotic.org/player/me"
const string	PLAYERSTATS_ACHIEVEMENT_BOTLIKE = "achievement-botlike"
const string	PLAYERSTATS_ACHIEVEMENT_FIRSTBLOOD = "achievement-firstblood"
const string	PLAYERSTATS_ACHIEVEMENT_FIRSTVICTIM = "achievement-firstvictim"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_10 = "achievement-kill-spree-10"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_15 = "achievement-kill-spree-15"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_20 = "achievement-kill-spree-20"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_25 = "achievement-kill-spree-25"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_3 = "achievement-kill-spree-3"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_30 = "achievement-kill-spree-30"
const string	PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_5 = "achievement-kill-spree-5"
const string	PLAYERSTATS_ALIVETIME = "alivetime"
const string	PLAYERSTATS_ANTICHEAT = "anticheat-"
const string	PLAYERSTATS_AVGLATENCY = "avglatency"
float	playerstats_basicstatus
bool	PlayerStats_GameReport_DelayMapVote
const string	PLAYERSTATS_HANDICAP_GIVEN = "handicapgiven"
const string	PLAYERSTATS_HANDICAP_TAKEN = "handicaptaken"
string	playerstats_id
const string	PLAYERSTATS_JOINS = "joins"
const string	PLAYERSTATS_MATCHES = "matches"
float	PlayerStats_PlayerDetail_Status = PS_D_STATUS_IDLE
const string	PLAYERSTATS_RANK = "rank"
const string	PLAYERSTATS_SCOREBOARD = "scoreboard-"
const string	PLAYERSTATS_SCOREBOARD_POS = "scoreboardpos"
const string	PLAYERSTATS_SCOREBOARD_VALID = "scoreboardvalid"
const string	PLAYERSTATS_TOTAL = "total-"
const string	PLAYERSTATS_WINS = "wins"
float	PS_B_IN_DB = -1
const float	PS_B_STATUS_ERROR = -2
const float	PS_B_STATUS_IDLE = -1
const float	PS_B_STATUS_RECEIVED = 1
const float	PS_B_STATUS_UPDATING = 2
const float	PS_B_STATUS_WAITING = 0
int	PS_D_IN_DB = -1
string	PS_D_IN_EVL
float	PS_D_LASTGAMECOUNT
float	PS_D_NEXTUPDATETIME
const float	PS_D_STATUS_ERROR = -2
const float	PS_D_STATUS_IDLE = -1
const float	PS_D_STATUS_RECEIVED = 1
const float	PS_D_STATUS_WAITING = 0
int	PS_GR_OUT_DB = -1
string	PS_GR_OUT_EVL
string	PS_GR_OUT_PL
string	PS_GR_OUT_TL
float	scoreboard_pos

Macro Definition Documentation

◆ PlayerStats_GameReport_Event_Player

#define PlayerStats_GameReport_Event_Player	(	ent,
		eventid,
		val )

Value:

PlayerStats_GameReport_Event(ent.playerstats_id, eventid, val)

PlayerStats_GameReport_Event

float PlayerStats_GameReport_Event(string prefix, string event_id, float value)

Definition playerstats.qc:155

Definition at line 76 of file playerstats.qh.

Referenced by anticheat_report_to_playerstats(), GiveFrags(), Obituary(), PlayerDamage(), PlayerScore_Add(), PlayerScore_PlayerStats(), PlayerStats_GameReport(), PlayerStats_GameReport_FinalizePlayer(), and PutObserverInServer().

◆ PlayerStats_GameReport_Event_Team

#define PlayerStats_GameReport_Event_Team	(	team,
		eventid,
		val )

Value:

PlayerStats_GameReport_Event(sprintf("team#%d", team), eventid, val)

team

int team

Definition main.qh:188

Definition at line 77 of file playerstats.qh.

Referenced by PlayerScore_TeamStats().

Function Documentation

◆ PlayerStats_GameReport()

void PlayerStats_GameReport ( bool finished )

Definition at line 229 of file playerstats.qc.

{
    if(PS_GR_OUT_DB < 0) { return; }
 
    PlayerScore_Sort(score_dummyfield, 0, false, false);
    PlayerScore_Sort(scoreboard_pos, 1, true, true);
    if(teamplay) { PlayerScore_TeamStats(); }
 
    FOREACH_CLIENT(true, {
        // add personal score rank
        PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_RANK, it.score_dummyfield);
 
        // scoreboard data
        if(it.scoreboard_pos)
        {
            // scoreboard is valid!
            PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_SCOREBOARD_VALID, 1);
 
            // add scoreboard position
            PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_SCOREBOARD_POS, it.scoreboard_pos);
 
            // add scoreboard data
            PlayerScore_PlayerStats(it);
 
            // if the match ended normally, add winning info
            if(finished)
            {
                PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_WINS, it.winning);
                PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_MATCHES, 1);
            }
        }
 
        // handicap
        const float given = GameRules_scoring_add(it, DMG, 0);
        const float taken = GameRules_scoring_add(it, DMGTAKEN, 0);
        PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_HANDICAP_GIVEN, given <= 0 ? 1 : it.handicap_avg_given_sum / given);
        PlayerStats_GameReport_Event_Player(it, PLAYERSTATS_HANDICAP_TAKEN, taken <= 0 ? 1 : it.handicap_avg_taken_sum / taken);
 
        // collect final player information
        PlayerStats_GameReport_FinalizePlayer(it);
    });
 
    if(autocvar_g_playerstats_gamereport_uri == "" || warmup_stage)
    {
        PlayerStats_GameReport_DelayMapVote = false;
        db_close(PS_GR_OUT_DB);
        PS_GR_OUT_DB = -1;
        return;
    }
 
    PlayerStats_GameReport_DelayMapVote = true;
    url_multi_fopen(
        autocvar_g_playerstats_gamereport_uri,
        FILE_APPEND,
        PlayerStats_GameReport_Handler,
        NULL
    );
}

References autocvar_g_playerstats_gamereport_uri, db_close(), FILE_APPEND, FOREACH_CLIENT, GameRules_scoring_add, NULL, PlayerScore_PlayerStats(), PlayerScore_Sort(), PlayerScore_TeamStats(), PlayerStats_GameReport_DelayMapVote, PlayerStats_GameReport_Event_Player, PlayerStats_GameReport_FinalizePlayer(), PlayerStats_GameReport_Handler(), PLAYERSTATS_HANDICAP_GIVEN, PLAYERSTATS_HANDICAP_TAKEN, PLAYERSTATS_MATCHES, PLAYERSTATS_RANK, PLAYERSTATS_SCOREBOARD_POS, PLAYERSTATS_SCOREBOARD_VALID, PLAYERSTATS_WINS, PS_GR_OUT_DB, score_dummyfield, scoreboard_pos, teamplay, url_multi_fopen(), and warmup_stage.

Referenced by NextLevel(), and Shutdown().

◆ PlayerStats_GameReport_Accuracy()

void PlayerStats_GameReport_Accuracy ( entity p )

Definition at line 167 of file playerstats.qc.

{
    #define ACCMAC(suffix, field) \
        PlayerStats_GameReport_Event_Player(p, \
            sprintf("acc-%s-%s", it.netname, suffix), CS(p).accuracy.(field[i-1]));
    FOREACH(Weapons, it != WEP_Null, {
        ACCMAC("real", accuracy_real)
        ACCMAC("hit", accuracy_hit)
        ACCMAC("fired", accuracy_fired)
        ACCMAC("cnt-hit", accuracy_cnt_hit)
        ACCMAC("cnt-fired", accuracy_cnt_fired)
        ACCMAC("frags", accuracy_frags)
    });
    #undef ACCMAC
}

References ACCMAC, accuracy_cnt_fired, accuracy_cnt_hit, accuracy_fired, accuracy_frags, accuracy_hit, accuracy_real, entity(), FOREACH, and Weapons.

Referenced by PlayerStats_GameReport_FinalizePlayer().

◆ PlayerStats_GameReport_AddEvent()

void PlayerStats_GameReport_AddEvent ( string event_id )

Definition at line 136 of file playerstats.qc.

{
    if(PS_GR_OUT_DB < 0) { return; }
 
    string key = sprintf("*:%s", event_id);
    string p = db_get(PS_GR_OUT_DB, key);
 
    if(p == "")
    {
        if(PS_GR_OUT_EVL)
        {
            db_put(PS_GR_OUT_DB, key, PS_GR_OUT_EVL);
            strunzone(PS_GR_OUT_EVL);
        }
        else { db_put(PS_GR_OUT_DB, key, "#"); }
        PS_GR_OUT_EVL = strzone(event_id);
    }
}

References db_get(), db_put(), PS_GR_OUT_DB, PS_GR_OUT_EVL, strunzone(), and strzone().

Referenced by anticheat_register_to_playerstats(), ClientConnect(), PlayerStats_GameReport_Init(), PlayerStats_GameReport_Reset_All(), ScoreInfo_SetLabel_PlayerScore(), and ScoreInfo_SetLabel_TeamScore().

◆ PlayerStats_GameReport_AddPlayer()

void PlayerStats_GameReport_AddPlayer ( entity e )

Definition at line 79 of file playerstats.qc.

{
    if((PS_GR_OUT_DB < 0) || (e.playerstats_id)) { return; }
 
    // set up player identification
    string s = "";
 
    if((e.crypto_idfp != "") && (CS_CVAR(e).cvar_cl_allow_uidtracking == 1))
        { s = e.crypto_idfp; }
    else if(IS_BOT_CLIENT(e))
        { s = sprintf("bot#%g#%s", skill, e.cleanname); }
 
    if((s == "") || find(NULL, playerstats_id, s)) // already have one of the ID - next one can't be tracked then!
    {
        if(IS_BOT_CLIENT(e))
            { s = sprintf("bot#%d", e.playerid); }
        else
            { s = sprintf("player#%d", e.playerid); }
    }
 
    e.playerstats_id = strzone(s);
 
    // now add the player to the database
    string key = sprintf("%s:*", e.playerstats_id);
    string p = db_get(PS_GR_OUT_DB, key);
 
    if(p == "")
    {
        if(PS_GR_OUT_PL)
        {
            db_put(PS_GR_OUT_DB, key, PS_GR_OUT_PL);
            strunzone(PS_GR_OUT_PL);
        }
        else { db_put(PS_GR_OUT_DB, key, "#"); }
        PS_GR_OUT_PL = strzone(e.playerstats_id);
    }
}

References CS_CVAR, db_get(), db_put(), entity(), find(), IS_BOT_CLIENT, NULL, playerstats_id, PS_GR_OUT_DB, PS_GR_OUT_PL, skill, strunzone(), and strzone().

Referenced by ClientConnect(), PlayerStats_GameReport_Reset_All(), and REPLICATE_APPLYCHANGE().

◆ PlayerStats_GameReport_AddTeam()

void PlayerStats_GameReport_AddTeam ( float t )

◆ PlayerStats_GameReport_Event()

float PlayerStats_GameReport_Event	(	string	prefix,
		string	event_id,
		float	value )

Definition at line 155 of file playerstats.qc.

{
    if((prefix == "") || PS_GR_OUT_DB < 0) { return 0; }
 
    // use a cheaper strcat here since this function is called often in game
    string key = strcat(prefix, ":", event_id);
    float val = stof(db_get(PS_GR_OUT_DB, key));
    val += value;
    db_put(PS_GR_OUT_DB, key, ftos(val));
    return val;
}

References db_get(), db_put(), ftos(), PS_GR_OUT_DB, stof(), and strcat().

◆ PlayerStats_GameReport_FinalizePlayer()

void PlayerStats_GameReport_FinalizePlayer ( entity p )

Definition at line 183 of file playerstats.qc.

{
    if((p.playerstats_id == "") || PS_GR_OUT_DB < 0) { return; }
 
    // add global info!
    if(p.alivetime_start)
    {
        PlayerStats_GameReport_Event_Player(p, PLAYERSTATS_ALIVETIME, max(0, time - p.alivetime_start));
        p.alivetime_start = 0;
    }
 
    db_put(PS_GR_OUT_DB, sprintf("%s:_playerid", p.playerstats_id), ftos(p.playerid));
 
    if(CS_CVAR(p).cvar_cl_allow_uid2name == 1 || IS_BOT_CLIENT(p))
        db_put(PS_GR_OUT_DB, sprintf("%s:_netname", p.playerstats_id), playername(p.netname, p.team, false));
 
    if(teamplay)
        db_put(PS_GR_OUT_DB, sprintf("%s:_team", p.playerstats_id), ftos(p.team));
 
    if(stof(db_get(PS_GR_OUT_DB, sprintf("%s:%s", p.playerstats_id, PLAYERSTATS_ALIVETIME))) > 0)
        PlayerStats_GameReport_Event_Player(p, PLAYERSTATS_JOINS, 1);
 
    PlayerStats_GameReport_Accuracy(p);
    anticheat_report_to_playerstats(p);
 
    if(IS_REAL_CLIENT(p))
    {
        if(CS(p).latency_cnt)
        {
            float latency = max(0, CS(p).latency_sum / CS(p).latency_cnt);
            if(latency)
            {
                // if previous average latency exists (player disconnected and reconnected)
                // make the average of previous and current average latency
                float prev_latency = PlayerStats_GameReport_Event_Player(p, PLAYERSTATS_AVGLATENCY, 0);
                float new_latency = !prev_latency ? latency : (prev_latency + latency) / 2;
                PlayerStats_GameReport_Event_Player(p, PLAYERSTATS_AVGLATENCY, -prev_latency + new_latency);
            }
        }
 
        db_put(PS_GR_OUT_DB, sprintf("%s:_ranked", p.playerstats_id), ftos(CS_CVAR(p).cvar_cl_allow_uidranking));
    }
 
    strfree(p.playerstats_id);
}

References anticheat_report_to_playerstats(), CS(), CS_CVAR, db_get(), db_put(), entity(), ftos(), IS_BOT_CLIENT, IS_REAL_CLIENT, latency_cnt, latency_sum, max(), playername(), PLAYERSTATS_ALIVETIME, PLAYERSTATS_AVGLATENCY, PlayerStats_GameReport_Accuracy(), PlayerStats_GameReport_Event_Player, PLAYERSTATS_JOINS, PS_GR_OUT_DB, stof(), strfree, teamplay, and time.

Referenced by ClientDisconnect(), and PlayerStats_GameReport().

◆ PlayerStats_GameReport_Handler()

void PlayerStats_GameReport_Handler	(	entity	fh,
		entity	pass,
		float	status )

Definition at line 359 of file playerstats.qc.

{
    string t, tn;
    string p, pn;
    string e, en;
    string nn, tt;
    string s;
 
    switch(status)
    {
        // ======================================
        // -- OUTGOING GAME REPORT INFORMATION --
        // ======================================
        /* SPECIFICATIONS:
         * V: format version (always a fixed number) - this MUST be the first line!
         * #: comment (MUST be ignored by any parser)
         * R: release information on the server
         * G: gametype
         * O: mod name (icon request) as in server browser
         * M: map name
         * I: match ID (see "matchid" in world.qc)
         * S: "hostname" of the server
         * C: number of "unpure" cvar changes
         * U: UDP port number of the server
         * D: duration of the match
         * RP: number of rounds played
         * L: "ladder" in which the server is participating in
         * P: player ID of an existing player; this also sets the owner for all following "n", "e" and "t" lines (lower case!)
         * Q: team number of an existing team (format: team#NN); this also sets the owner for all following "e" lines (lower case!)
         * i: player index
         * n: nickname of the player (optional)
         * t: team ID
         * r: player ranking enabled / disabled
         * e: followed by an event name, a space, and the event count/score
         *  event names can be:
         *   alivetime: total playing time of the player
         *   avglatency: average network latency compounded throughout the match
         *   wins: number of games won (can only be set if matches is set)
         *   matches: number of matches played to the end (not aborted by map switch)
         *   joins: number of matches joined (always 1 unless player never played during the match)
         *   scoreboardvalid: set to 1 if the player was there at the end of the match
         *   total-<scoreboardname>: total score of that scoreboard item
         *   scoreboard-<scoreboardname>: end-of-game score of that scoreboard item (can differ in non-team games)
         *   achievement-<achievementname>: achievement counters (their "count" is usually 1 if nonzero at all)
         *   kills-<index>: number of kills against the indexed player
         *   rank <number>: rank of player
         *   handicapgiven: average handicap on given (dealt) damage throughout the match
         *   handicaptaken: average handicap on taken (received) damage throughout the match
         *   acc-<weapon netname>-real: total damage dealt excluding excess after death
         *   acc-<weapon netname>-hit: total damage dealt including excess after death
         *   acc-<weapon netname>-fired: total damage that all fired shots could have dealt
         *   acc-<weapon netname>-cnt-hit: amount of shots that actually hit
         *   acc-<weapon netname>-cnt-fired: amount of fired shots
         *   acc-<weapon netname>-frags: amount of frags dealt by weapon
         */
        case URL_READY_CANWRITE:
        {
            url_fputs(fh, "V 9\n");
            #ifdef WATERMARK
            url_fputs(fh, sprintf("R %s\n", WATERMARK));
            #endif
            url_fputs(fh, sprintf("G %s\n", PlayerStats_GetGametype()));
            url_fputs(fh, sprintf("O %s\n", modname));
            url_fputs(fh, sprintf("M %s\n", GetMapname()));
            url_fputs(fh, sprintf("I %s\n", matchid));
            url_fputs(fh, sprintf("S %s\n", cvar_string("hostname")));
            url_fputs(fh, sprintf("C %d\n", cvar_purechanges_count));
            url_fputs(fh, sprintf("U %d\n", cvar("port")));
            url_fputs(fh, sprintf("D %f\n", max(0, time - game_starttime)));
            if (rounds_played > 0)
                url_fputs(fh, sprintf("RP %d\n", rounds_played));
            if (autocvar_g_playerstats_gamereport_ladder != "")
                url_fputs(fh, sprintf("L %s\n", autocvar_g_playerstats_gamereport_ladder));
 
            // TEAMS
            if(teamplay)
            {
                for(t = PS_GR_OUT_TL; (tn = db_get(PS_GR_OUT_DB, sprintf("%d", stof(t)))) != ""; t = tn)
                {
                    // start team section
                    url_fputs(fh, sprintf("Q team#%s\n", t));
 
                    // output team events // todo: does this do unnecessary loops? perhaps we should do a separate "team_events_last" tracker..."
                    for(e = PS_GR_OUT_EVL; (en = db_get(PS_GR_OUT_DB, sprintf("*:%s", e))) != ""; e = en)
                    {
                        float v = stof(db_get(PS_GR_OUT_DB, sprintf("team#%d:%s", stof(t), e)));
                        if(v != 0) { url_fputs(fh, sprintf("e %s %g\n", e, v)); }
                    }
                }
            }
 
            // PLAYERS
            for(p = PS_GR_OUT_PL; (pn = db_get(PS_GR_OUT_DB, sprintf("%s:*", p))) != ""; p = pn)
            {
                // start player section
                url_fputs(fh, sprintf("P %s\n", p));
 
                // playerid/index (entity number for this server)
                nn = db_get(PS_GR_OUT_DB, sprintf("%s:_playerid", p));
                if(nn != "") { url_fputs(fh, sprintf("i %s\n", nn)); }
 
                // player name
                nn = db_get(PS_GR_OUT_DB, sprintf("%s:_netname", p));
                if(nn != "") { url_fputs(fh, sprintf("n %s\n", nn)); }
 
                // team identification number
                if(teamplay)
                {
                    tt = db_get(PS_GR_OUT_DB, sprintf("%s:_team", p));
                    url_fputs(fh, sprintf("t %s\n", tt));
                }
 
                // skill ranking enabled
                nn = db_get(PS_GR_OUT_DB, sprintf("%s:_ranked", p));
                if(nn != "") { url_fputs(fh, sprintf("r %s\n", nn)); }
 
                // output player events
                for(e = PS_GR_OUT_EVL; (en = db_get(PS_GR_OUT_DB, sprintf("*:%s", e))) != ""; e = en)
                {
                    float v = stof(db_get(PS_GR_OUT_DB, sprintf("%s:%s", p, e)));
                    if(v != 0) { url_fputs(fh, sprintf("e %s %g\n", e, v)); }
                }
            }
            url_fputs(fh, "\n");
            url_fclose(fh);
            break;
        }
 
        // ======================================
        // -- INCOMING GAME REPORT INFORMATION --
        // ======================================
        /* SPECIFICATIONS:
         * stuff
         */
        case URL_READY_CANREAD:
        {
            // url_fclose is processing, we got a response for writing the data
            // this must come from HTTP
            LOG_DEBUG("Got response from player stats server:");
            while((s = url_fgets(fh))) { LOG_DEBUG("  ", s); }
            LOG_DEBUG("End of response.");
            url_fclose(fh);
            break;
        }
 
        case URL_READY_CLOSED:
        {
            // url_fclose has finished
            LOG_DEBUG("Player stats written");
            PlayerStats_GameReport_DelayMapVote = false;
            if(PS_GR_OUT_DB >= 0)
            {
                db_close(PS_GR_OUT_DB);
                PS_GR_OUT_DB = -1;
            }
            break;
        }
 
        case URL_READY_ERROR:
        default:
        {
            LOG_INFO("Player stats writing failed: ", ftos(status));
            PlayerStats_GameReport_DelayMapVote = false;
            if(PS_GR_OUT_DB >= 0)
            {
                db_close(PS_GR_OUT_DB);
                PS_GR_OUT_DB = -1;
            }
            break;
        }
    }
}

References autocvar_g_playerstats_gamereport_ladder, cvar(), cvar_purechanges_count, cvar_string(), db_close(), db_get(), entity(), ftos(), game_starttime, GetMapname(), LOG_DEBUG, LOG_INFO, matchid, max(), modname, pass, PlayerStats_GameReport_DelayMapVote, PlayerStats_GetGametype(), PS_GR_OUT_DB, PS_GR_OUT_EVL, PS_GR_OUT_PL, PS_GR_OUT_TL, rounds_played, stof(), teamplay, time, url_fclose(), url_fgets(), url_fputs(), URL_READY_CANREAD, URL_READY_CANWRITE, URL_READY_CLOSED, and URL_READY_ERROR.

Referenced by PlayerStats_GameReport().

◆ PlayerStats_GameReport_Init()

void PlayerStats_GameReport_Init ( )

Definition at line 288 of file playerstats.qc.

{
    serverflags &= ~SERVERFLAG_PLAYERSTATS;
    serverflags &= ~SERVERFLAG_PLAYERSTATS_CUSTOM;
 
    if(autocvar_g_playerstats_gamereport_uri == "") { return; }
 
    PS_GR_OUT_DB = db_create();
 
    if(PS_GR_OUT_DB >= 0)
    {
        PlayerStats_GameReport_DelayMapVote = true;
 
        if(autocvar_g_playerstats_gamereport_uri != cvar_defstring("g_playerstats_gamereport_uri"))
            serverflags |= SERVERFLAG_PLAYERSTATS | SERVERFLAG_PLAYERSTATS_CUSTOM;
        else if(checkextension("DP_CRYPTO") && checkextension("DP_QC_URI_POST"))
            // XonStat submission requires player and server IDs, and HTTPS POST
            serverflags |= SERVERFLAG_PLAYERSTATS;
 
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ALIVETIME);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_AVGLATENCY);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_WINS);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_MATCHES);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_JOINS);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_SCOREBOARD_VALID);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_SCOREBOARD_POS);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_RANK);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_HANDICAP_GIVEN);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_HANDICAP_TAKEN);
 
        // accuracy stats
        FOREACH(Weapons, it != WEP_Null, {
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-real"));
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-hit"));
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-fired"));
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-cnt-hit"));
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-cnt-fired"));
            PlayerStats_GameReport_AddEvent(strcat("acc-", it.netname, "-frags"));
        });
 
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_3);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_5);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_10);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_15);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_20);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_25);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_30);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_BOTLIKE);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_FIRSTBLOOD);
        PlayerStats_GameReport_AddEvent(PLAYERSTATS_ACHIEVEMENT_FIRSTVICTIM);
 
        anticheat_register_to_playerstats();
    }
    else { PlayerStats_GameReport_DelayMapVote = false; }
}

Referenced by PlayerStats_GameReport_Reset_All(), and spawnfunc().

◆ PlayerStats_GameReport_Reset_All()

void PlayerStats_GameReport_Reset_All ( )

Definition at line 36 of file playerstats.qc.

{
    strfree(PS_GR_OUT_TL);
    strfree(PS_GR_OUT_PL);
    strfree(PS_GR_OUT_EVL);
 
    if (PS_GR_OUT_DB >= 0)
    {
        db_close(PS_GR_OUT_DB);
        PlayerStats_GameReport_Init();
    }
    if(PS_GR_OUT_DB < 0)
        return;
 
    for (int i = 0; i < 16; ++i)
        if (teamscorekeepers[i])
            PlayerStats_GameReport_AddTeam(i + 1);
    FOREACH_CLIENT(true, {
        // NOTE Adding back a player we are applying any cl_allow_uidtracking change
        // usually only possible by reconnecting to the server
        strfree(it.playerstats_id);
        PlayerStats_GameReport_AddEvent(sprintf("kills-%d", it.playerid));
        PlayerStats_GameReport_AddPlayer(it);
        it.handicap_avg_given_sum = 0;
        it.handicap_avg_taken_sum = 0;
    });
    FOREACH(Scores, true, {
        string label = scores_label(it);
        if (label == "")
            continue;
        PlayerStats_GameReport_AddEvent(strcat(PLAYERSTATS_TOTAL, label));
        PlayerStats_GameReport_AddEvent(strcat(PLAYERSTATS_SCOREBOARD, label));
    });
    for(int i = 0; i < MAX_TEAMSCORE; ++i)
    {
        string label = teamscores_label(i);
        if (label == "")
            continue;
        PlayerStats_GameReport_AddEvent(strcat(PLAYERSTATS_TOTAL, label));
        PlayerStats_GameReport_AddEvent(strcat(PLAYERSTATS_SCOREBOARD, label));
    }
}

References db_close(), FOREACH, FOREACH_CLIENT, MAX_TEAMSCORE, PlayerStats_GameReport_AddEvent(), PlayerStats_GameReport_AddPlayer(), PlayerStats_GameReport_AddTeam(), PlayerStats_GameReport_Init(), PLAYERSTATS_SCOREBOARD, PLAYERSTATS_TOTAL, PS_GR_OUT_DB, PS_GR_OUT_EVL, PS_GR_OUT_PL, PS_GR_OUT_TL, scores_label, strcat(), strfree, teamscorekeepers, and teamscores_label.

Referenced by reset_map().

◆ PlayerStats_PlayerBasic()

void PlayerStats_PlayerBasic	(	entity	joiningplayer,
		float	newrequest )

Definition at line 532 of file playerstats.qc.

{
    GameRules_scoring_add(joiningplayer, SKILL, -1);
    // http://stats.xonotic.org/skill?hashkey=Cm5mzXa1Vn9VX0%2FySV4Pp8ca9CTZvklERDqrrNOUFZU%3D
    if(autocvar_g_playerstats_playerbasic_uri != "")
    {
        string uri = autocvar_g_playerstats_playerbasic_uri;
        if (joiningplayer.crypto_idfp == "") {
            GameRules_scoring_add(joiningplayer, SKILL, -1);
        } else {
            // create the database if it doesn't already exist
            if(PS_B_IN_DB < 0)
                PS_B_IN_DB = db_create();
 
            // now request the information
            uri = strcat(uri, "/skill?game_type_cd=", uri_escape(PlayerStats_GetGametype()));
            uri = strcat(uri, "&hashkey=", uri_escape(joiningplayer.crypto_idfp));
            LOG_DEBUG("Retrieving playerstats from URL: ", uri);
            url_single_fopen(
                uri,
                FILE_READ,
                PlayerStats_PlayerBasic_Handler,
                joiningplayer
            );
 
            // set status appropriately // todo: check whether the player info exists in the database previously
            if(newrequest)
            {
                // database still contains useful information, so don't clear it of a useful status
                joiningplayer.playerstats_basicstatus = PS_B_STATUS_WAITING;
            }
            else
            {
                // database was previously empty or never hit received status for some reason
                joiningplayer.playerstats_basicstatus = PS_B_STATUS_UPDATING;
            }
        }
    }
    else
    {
        // server has this disabled, kill the DB and set status to idle
        GameRules_scoring_add(joiningplayer, SKILL, -1);
        if(PS_B_IN_DB >= 0)
        {
            db_close(PS_B_IN_DB);
            PS_B_IN_DB = -1;
 
            FOREACH_CLIENT(IS_REAL_CLIENT(it), it.playerstats_basicstatus = PS_B_STATUS_IDLE);
        }
    }
}

References autocvar_g_playerstats_playerbasic_uri, db_close(), db_create(), entity(), FILE_READ, FOREACH_CLIENT, GameRules_scoring_add, IS_REAL_CLIENT, LOG_DEBUG, PlayerStats_GetGametype(), PlayerStats_PlayerBasic_Handler(), PS_B_IN_DB, PS_B_STATUS_IDLE, PS_B_STATUS_UPDATING, PS_B_STATUS_WAITING, strcat(), and url_single_fopen().

Referenced by PlayerStats_PlayerBasic_CheckUpdate().

◆ PlayerStats_PlayerBasic_CheckUpdate()

void PlayerStats_PlayerBasic_CheckUpdate ( entity joiningplayer )

Definition at line 599 of file playerstats.qc.

{
    // determine whether we should retrieve playerbasic information again
 
    LOG_DEBUGF("PlayerStats_PlayerBasic_CheckUpdate('%s'): %f",
        joiningplayer.netname,
        time
    );
 
    // TODO: check to see if this playerid is inside the database already somehow...
    // for now we'll just check the field, but this won't work for players who disconnect and reconnect properly
    // although maybe we should just submit another request ANYWAY?
    if(!joiningplayer.playerstats_basicstatus)
    {
        PlayerStats_PlayerBasic(
            joiningplayer,
            (joiningplayer.playerstats_basicstatus == PS_B_STATUS_RECEIVED)
        );
    }
}

References entity(), LOG_DEBUGF, PlayerStats_PlayerBasic(), PS_B_STATUS_RECEIVED, and time.

Referenced by ClientState_attach().

◆ PlayerStats_PlayerBasic_Handler()

void PlayerStats_PlayerBasic_Handler	(	entity	fh,
		entity	p,
		float	status )

Definition at line 620 of file playerstats.qc.

{
    switch(status)
    {
        case URL_READY_CANWRITE:
        {
            // THIS should be never called
            LOG_DEBUG("-- Sending data to player stats server");
            url_fputs(fh, "\n");
            url_fclose(fh);
            return;
        }
 
        case URL_READY_CANREAD:
        {
            string temp = "";
            for (string s; (s = url_fgets(fh)); )
            {
                if (temp != "")
                    temp = strcat(temp, "\n", s);
                else
                    temp = s;
            }
            url_fclose(fh);
            int buf = json_parse(temp, _json_parse_array);
            EXPECT_NE(-1, buf);
            string gametype = PlayerStats_GetGametype();
            if (json_get(buf, "0.game_type_cd") == gametype && gametype != "")
            {
                float mu = stof(json_get(buf, "0.mu"));
                //float sigma = stof(json_get(buf, "0.sigma"));
                float skill = max(0, mu);
                /* we display just the mean skill, since this most accurately represents how players will play on an average match.
                 * displaying mu - 3 * sigma would display worst-case performance, but when applied to every player this becomes meaningless.
                 * also we're not interested in the skill that we're confident players can operate above, rather where we expect them to operate.
                 */
                GameRules_scoring_add(p, SKILL, skill + 1);
                return;
 
            }
            break;
        }
        case URL_READY_CLOSED:
        {
            // url_fclose has finished
            LOG_INFO("Player stats synchronized with server");
            return;
        }
 
        case URL_READY_ERROR:
        default:
        {
            LOG_INFO("Receiving player stats failed: ", ftos(status));
            break;
        }
    }
    GameRules_scoring_add(p, SKILL, -1);
}

References _json_parse_array(), entity(), EXPECT_NE, ftos(), GameRules_scoring_add, gametype, json_get(), json_parse(), LOG_DEBUG, LOG_INFO, max(), PlayerStats_GetGametype(), skill, stof(), strcat(), url_fclose(), url_fgets(), url_fputs(), URL_READY_CANREAD, URL_READY_CANWRITE, URL_READY_CLOSED, and URL_READY_ERROR.

Referenced by PlayerStats_PlayerBasic().

◆ PlayerStats_PlayerDetail()

void PlayerStats_PlayerDetail ( )

Definition at line 715 of file playerstats.qc.

{
    // http://stats.xonotic.org/player/me
    if((autocvar_g_playerstats_playerdetail_uri != "") && (crypto_getmyidstatus(0) > 0))
    {
        // create the database if it doesn't already exist
        if(PS_D_IN_DB < 0)
            PS_D_IN_DB = db_create();
 
        //uri = strcat(uri, "/player/", uri_escape(crypto_getmyidfp(0)));
        LOG_DEBUG("Retrieving playerstats from URL: ", autocvar_g_playerstats_playerdetail_uri);
        url_single_fopen(
            autocvar_g_playerstats_playerdetail_uri,
            FILE_APPEND,
            PlayerStats_PlayerDetail_Handler,
            NULL
        );
 
        PlayerStats_PlayerDetail_Status = PS_D_STATUS_WAITING;
    }
    else
    {
        // player has this disabled, kill the DB and set status to idle
        if(PS_D_IN_DB >= 0)
        {
            db_close(PS_D_IN_DB);
            PS_D_IN_DB = -1;
        }
 
        PlayerStats_PlayerDetail_Status = PS_D_STATUS_IDLE;
    }
}

References autocvar_g_playerstats_playerdetail_uri, db_close(), db_create(), FILE_APPEND, LOG_DEBUG, NULL, PlayerStats_PlayerDetail_Handler(), PlayerStats_PlayerDetail_Status, PS_D_IN_DB, PS_D_STATUS_IDLE, PS_D_STATUS_WAITING, and url_single_fopen().

Referenced by PlayerStats_PlayerDetail_CheckUpdate().

◆ PlayerStats_PlayerDetail_CheckUpdate()

void PlayerStats_PlayerDetail_CheckUpdate ( )

Definition at line 748 of file playerstats.qc.

{
    // determine whether we should retrieve playerdetail information again
    float gamecount = cvar("cl_matchcount");
 
    #if 0
    LOG_INFOF("PlayerStats_PlayerDetail_CheckUpdate(): %f >= %f, %d > %d",
        time,
        PS_D_NEXTUPDATETIME,
        PS_D_LASTGAMECOUNT,
        gamecount
    );
    #endif
 
    if(
        (time >= PS_D_NEXTUPDATETIME)
        ||
        (gamecount > PS_D_LASTGAMECOUNT)
    )
    {
        PlayerStats_PlayerDetail();
        PS_D_NEXTUPDATETIME = (time + autocvar_g_playerstats_playerdetail_autoupdatetime);
        PS_D_LASTGAMECOUNT = gamecount;
    }
}

References autocvar_g_playerstats_playerdetail_autoupdatetime, cvar(), LOG_INFOF, PlayerStats_PlayerDetail(), PS_D_LASTGAMECOUNT, PS_D_NEXTUPDATETIME, and time.

Referenced by XonoticStatsList_showNotify().

◆ PlayerStats_PlayerDetail_Handler()

void PlayerStats_PlayerDetail_Handler	(	entity	fh,
		entity	p,
		float	status )

Definition at line 774 of file playerstats.qc.

{
    switch(status)
    {
        case URL_READY_CANWRITE:
        {
            LOG_DEBUG("PlayerStats_PlayerDetail_Handler(): Sending data to player stats server...");
            url_fputs(fh, "V 1\n");
            #ifdef WATERMARK
            url_fputs(fh, sprintf("R %s\n", WATERMARK));
            #endif
            url_fputs(fh, sprintf("l %s\n", cvar_string("_menu_prvm_language"))); // language
            //url_fputs(fh, sprintf("c %s\n", cvar_string("_cl_country"))); // country
            url_fputs(fh, sprintf("n %s\n", cvar_string("_cl_name"))); // name
            url_fputs(fh, sprintf("m %s %s\n", cvar_string("_cl_playermodel"), cvar_string("_cl_playerskin"))); // model/skin
            url_fputs(fh, "\n");
            url_fclose(fh);
            break;
        }
 
        case URL_READY_CANREAD:
        {
            //print("PlayerStats_PlayerDetail_Handler(): Got response from player stats server:\n");
            string input = "";
            string gametype = "overall";
            while((input = url_fgets(fh)))
            {
                float count = tokenizebyseparator(input, " ");
                string key = "", event = "", data = "";
 
                if(argv(0) == "#") { continue; }
 
                if(count == 2)
                {
                    key = argv(0);
                    data = substring(input, argv_start_index(1), strlen(input) - argv_start_index(1));
                }
                else if(count >= 3)
                {
                    key = argv(0);
                    event = argv(1);
                    data = substring(input, argv_start_index(2), strlen(input) - argv_start_index(2));
                }
                else { continue; }
 
                switch(key)
                {
                    // general info
                    case "V": PlayerStats_PlayerDetail_AddItem("version", data); break;
                    case "R": PlayerStats_PlayerDetail_AddItem("release", data); break;
                    case "T": PlayerStats_PlayerDetail_AddItem("time", data); break;
 
                    // player info
                    case "S": PlayerStats_PlayerDetail_AddItem("statsurl", data); break;
                    case "P": PlayerStats_PlayerDetail_AddItem("hashkey", data); break;
                    case "n": PlayerStats_PlayerDetail_AddItem("playernick", data); break;
                    case "i": PlayerStats_PlayerDetail_AddItem("playerid", data); break;
 
                    // other/event info
                    case "G": gametype = data; break;
                    case "e":
                    {
                        if(event != "" && data != "")
                        {
                            PlayerStats_PlayerDetail_AddItem(
                                sprintf(
                                    "%s/%s",
                                    gametype,
                                    event
                                ),
                                data
                            );
                        }
                        break;
                    }
 
                    default:
                    {
                        LOG_INFOF(
                            "PlayerStats_PlayerDetail_Handler(): ERROR: "
                            "Key went unhandled? Is our version outdated?\n"
                            "PlayerStats_PlayerDetail_Handler(): "
                            "Key '%s', Event '%s', Data '%s'",
                            key,
                            event,
                            data
                        );
                        break;
                    }
                }
 
                #if 0
                LOG_INFOF(
                    "PlayerStats_PlayerDetail_Handler(): "
                    "Key '%s', Event '%s', Data '%s'",
                    key,
                    event,
                    data
                );
                #endif
            }
            //print("PlayerStats_PlayerDetail_Handler(): End of response.\n");
            url_fclose(fh);
            PlayerStats_PlayerDetail_Status = PS_D_STATUS_RECEIVED;
            statslist.getStats(statslist);
            break;
        }
 
        case URL_READY_CLOSED:
        {
            // url_fclose has finished
            LOG_INFO("PlayerStats_PlayerDetail_Handler(): Player stats synchronized with server.");
            break;
        }
 
        case URL_READY_ERROR:
        default:
        {
            LOG_INFO("PlayerStats_PlayerDetail_Handler(): Receiving player stats failed: ", ftos(status));
            PlayerStats_PlayerDetail_Status = PS_D_STATUS_ERROR;
            if(PS_D_IN_DB >= 0)
            {
                db_close(PS_D_IN_DB);
                PS_D_IN_DB = -1;
            }
            break;
        }
    }
}