TUTORIAL 17 - Scoreboard fragrate
by HypoThermia
Fed up of joining a game part the way through and being unable to win it? Want to show that
you're up there with the best... or that you could have won that match?
Lets take a look at the scoreboard and see how we can get it showing your frags per minute. Along
the way we'll find out about timing and a little on how the server keeps all the clients updated.
1. Working out the fragrate
Start by having a look at cg_scoreboard.c in the cgame directory. It contains
all the code used to draw the scoreboard (surprise!), and compared to other source files
is quite straightforward to understand. After all we have a very clear picture of how a
scoreboard works - don't we?
The first function that we see is CG_DrawClientScore. This simply draws a
line of information that the client knows about the player. Things like the model picture,
frags, ping, time connected, and name. It's made a little more complicated because version
1.15 introduced a second, smaller, scoreboard for a larger number of players.
We have the information we need here to construct a frag rate per minute: the number of frags
and the time connected (score->time). Unfortunately this is in minutes: it doesn't
change quickly enough to be useful. Let's track back to where this information is set and see
what we can do.
CG_DrawClientScore is called from CG_TeamScoreboard, and we can see that
players are grouped into "teams": TEAM_RED, TEAM_BLUE, TEAM_FREE and TEAM_SPECTATOR. It also
appears that the list is already sorted for us, and there's nothing in cg_scoreboard.c
doing that for us. The stats are all stored in the array cg.scores[] so we need to find
where this is modified.
Found it yet? A search shows that it's only modified in cg_servercmds.c, in response
to the server sending out a scores command. All commands sent by the server are processed in
this file: so all the sorting and ordering must be done in the server. This
makes sense: the server carries the master records and arbitrates the game.
Moving over to the code in the game directory we see that the scores command is sent
out by DeathmatchScoreboardMessage() in g_cmds.c. This file handles commands
sent to the server by the client (one of which is a request to update the scores stored by
the client). This information is only sent out if there's a scoreboard to update.
Com_sprintf (entry, sizeof(entry),
" %i %i %i %i %i %i", level.sortedClients[i],
cl->ps.persistant[PERS_SCORE], ping, (level.time - cl->pers.enterTime)/60000,
scoreFlags, g_entities[level.sortedClients[i]].s.powerups);
The scores are sent out as a long string of numbers. We can see that the 4th number in each group
of six is the time connected to the server in minutes. The "divide by 60000" occurs because the
standard unit of time in Quake3 is the millisecond - the conversion to minutes is made at this point.
2. The changes we need to make
We could adjust DeathmatchScoreboardMessage() to send out a calculated frag rate
as well, but there's a more efficient way. Since the number of frags and the time connected are
already sent, we'll just adjust these instead. If we change the time connected to seconds we
can then get a fragrate that updates with an accuracy every second (at best).
We'll store the fragrate in the client as an integer: the actual fragrate per minute multiplied
up by 100. I've also imposed an (arbitrary) minimum 10 seconds for caclulating the fragrate. This
keeps any "logon and frag" luck to a minimum.
The scoreboard will have to be re-sorted by fragrate: done in the client because
this is a client preference. This preference will be stored in a system variable.
We're almost there. One more issue we need to concern ourselves with: the scoreboard can be
updated during the intermission (when someone disconnects for example), so we don't want our
time information to keep on changing during this period.
After a little digging around we find that there's a variable already set up to help us:
level.intermissiontime. It's set to zero when the server is playing a level, and marks
the time (in milliseconds) at which the intermission started. It helps the server time the duration
of the intermission - and we can make use of it too.
Let's get our hands dirty.
3. Coding the changes
First of all we'll make the only server modification that's required (g_cmds.c) so
the connect time is sent in seconds (remembering that the unit of time is the millisecond in Quake3).
The use of level.intermissiontime prevents our fragrate times from ticking down while
we're in the intermission.
/*
==================
DeathmatchScoreboardMessage
==================
*/
void DeathmatchScoreboardMessage( gentity_t *ent ) {
char entry[1024];
char string[1400];
int stringlength;
int i, j;
gclient_t *cl;
int numSorted;
int scoreFlags;
int playtime;
// send the latest information on all clients
string[0] = 0;
stringlength = 0;
scoreFlags = 0;
// don't send more than 32 scores (FIXME?)
numSorted = level.numConnectedClients;
if ( numSorted > 32 ) {
numSorted = 32;
}
for (i=0 ; i < numSorted ; i++) {
int ping;
cl = &level.clients[level.sortedClients[i]];
if ( cl->pers.connected == CON_CONNECTING ) {
ping = -1;
} else {
ping = cl->ps.ping < 999 ? cl->ps.ping : 999;
}
// HypoThermia: get the correct time (rate shouldn't change
// during intermission)
playtime = level.time;
if (level.intermissiontime)
playtime = level.intermissiontime;
// Hypothermia: send over time in seconds instead of minutes
Com_sprintf (entry, sizeof(entry),
" %i %i %i %i %i %i", level.sortedClients[i],
cl->ps.persistant[PERS_SCORE], ping, (playtime - cl->pers.enterTime)/1000,
scoreFlags, g_entities[level.sortedClients[i]].s.powerups);
j = strlen(entry);
if (stringlength + j > 1024)
break;
strcpy (string + stringlength, entry);
stringlength += j;
}
trap_SendServerCommand( ent-g_entities, va("scores %i %i %i%s", i,
level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE],
string ) );
}
From now on it's client side stuff. We need a new variable in the score_t struct
to store the fragrate (cg_local.h):
typedef struct {
int client;
int score;
int ping;
int time;
int scoreFlags;
int fragrate;
} score_t;
Next we're updating cg_servercmds.c so it handles the changed connect time. This is also
a good place to calculate the fragrate. Remember that the time is now in seconds and that fragrate
stores 100 times the number of frags per minute.
This is in CG_ParseScores():
cg.scores[i].time = atoi( CG_Argv( i * 6 + 7 ) );
cg.scores[i].scoreFlags = atoi( CG_Argv( i * 6 + 8 ) );
powerups = atoi( CG_Argv( i * 6 + 9 ) );
// HypoThermia: fragrate based on minimum of 10 seconds
if (cg.scores[i].time < 10)
cg.scores[i].fragrate = 600 * cg.scores[i].score;
else
cg.scores[i].fragrate = (6000 * cg.scores[i].score) / cg.scores[i].time;
// HypoThermia: correct time value back to minutes
cg.scores[i].time /= 60;
if ( cg.scores[i].client < 0 || cg.scores[i].client >= MAX_CLIENTS ) {
cg.scores[i].client = 0;
}
With all the information in place we now need to adapt the scoreboard so it'll
display the fragrate. First of all, though, we'll add a system variable that stores
the type of scoreboard we've chosen to display:
Back in cg_local.h we add a reference to a global variable:
extern vmCvar_t cg_blood;
extern vmCvar_t cg_predictItems;
extern vmCvar_t cg_deferPlayers;
extern vmCvar_t cg_fragRateScoreboard;
and the static declaration of this variable into cg_main.c:
vmCvar_t cg_deferPlayers;
vmCvar_t cg_drawTeamOverlay;
vmCvar_t cg_teamOverlayUserinfo;
vmCvar_t cg_fragRateScoreboard;
and finally link it into the list of client commands (still in cg_main.c). Notice
that we don't need to do any more: we automatically get TAB completion in the console, and the
variable is saved from session to session by using the flag CVAR_ARCHIVE.
{ &cg_drawTeamOverlay, "cg_drawTeamOverlay", "0", CVAR_ARCHIVE },
{ &cg_teamOverlayUserinfo, "teamoverlay", "0", CVAR_ROM | CVAR_USERINFO },
{ &cg_stats, "cg_stats", "0", 0 },
{ &cg_fragRateScoreboard, "cg_fragRateScoreboard", "0", CVAR_ARCHIVE },
This variable has a default value of 0. When set to 1 the fragrate will be displayed in the scoreboard.
Finally we get to make the changes to the scoreboard display. We need to convert the
fragrate back into a "floating point" display format, and to sort the scoreboard into the
correct order.
First the display of the scoreboard. Notice that the changes to the "connecting" and
"SPECT" formating strings realign the names properly. We also have to make sure we don't
overstep the formatting limits, and handle the negative numbers properly. We also have to handle
the case where the decimal part is less that ten, otherwise we'd get things like
5.9 instead of 5.09.
I don't think anyone is going to reach 99.99 frags per minute so we cap it there,
nor are they going to get a suicide rate below about 10 per minute.
These changes are in cg_scoreboard.c in CG_DrawClientScore().
// draw the score line
if ( score->ping == -1 ) {
Com_sprintf(string, sizeof(string),
" connecting %s", ci->name);
} else if ( ci->team == TEAM_SPECTATOR ) {
Com_sprintf(string, sizeof(string),
" SPECT%4i %4i %s", score->ping, score->time, ci->name);
} else if (cg_fragRateScoreboard.integer) {
// HypoThermia: display fractional fragrate
int whole,frac;
char* fmt; // format string used
if (score->fragrate < 0)
{
frac = ( -score->fragrate) % 100;
whole = -( -score->fragrate - frac) / 100;
}
else if (score->fragrate < 9999)
{
frac = score->fragrate % 100;
whole = score->fragrate / 100;
}
else
{
whole = 99;
frac = 99;
}
if (frac < 10)
fmt = "%2i.0%1i %4i %4i %s";
else
fmt = "%2i.%2i %4i %4i %s";
Com_sprintf(string, sizeof(string),
fmt, whole, frac, score->ping, score->time, ci->name);
}
else {
Com_sprintf(string, sizeof(string),
"%5i %4i %4i %s", score->score, score->ping, score->time, ci->name);
}
and a small modification to the highlight showing your score so it doesn't leave a text overhang
on the left:
} else {
hcolor[0] = 0.7;
hcolor[1] = 0.7;
hcolor[2] = 0.7;
}
hcolor[3] = fade * 0.7;
CG_FillRect( SB_SCORELINE_X, y,
640 - SB_SCORELINE_X - BIGCHAR_WIDTH, BIGCHAR_HEIGHT+1, hcolor );
Last of all we need to sort the scores.
As the results are already sorted by total frags, we need to re-sort it for fragrate. I've only
done this for standard deathmatch (TEAM_FREE), it doesn't really make much sense for other game
types. The changes go into CG_TeamScoreboard() as this constructs each type of
team for the scoreboard.
Instead of checking each item on the list and displaying only the correct ones (as the original
CG_TeamScoreboard() did), we construct a list of items to be displayed. This list
is sorted if needed, and then displayed. The variable count has been removed,
it returns the number of lines drawn, and has been superceded by indexcount.
Although there is a sort being performed each frame the scoreboard is drawn,
it's a quick one (rarely more than 16 items), and only moves pointers around in an array.
/*
=================
CG_TeamScoreboard
=================
*/
static int CG_TeamScoreboard( int y, team_t team, float fade, int maxClients, int lineHeight ) {
int i, j;
score_t *score;
float color[4];
clientInfo_t *ci;
score_t * scorelist[MAX_CLIENTS];
int indexcount;
color[0] = color[1] = color[2] = 1.0;
color[3] = fade;
// HypoThermia: build an indexed array into given team type
indexcount = 0;
for ( i = 0; i < cg.numScores && indexcount < maxClients; i++ )
{
score = &cg.scores[i];
if ( team != cgs.clientinfo[ score->client ].team )
continue;
scorelist[indexcount] = score;
indexcount++;
}
// HypoThermia: sort the score by frag rate for FREE players only
// use a quick and dirty sort because we're moving pointers around
if ( team == TEAM_FREE && cg_fragRateScoreboard.integer)
{
for ( i = 0; i < indexcount - 1; i++ )
for ( j = i + 1; j < indexcount; j++ )
if (scorelist[j]->fragrate > scorelist[i]->fragrate)
{
score_t *t;
t = scorelist[i];
scorelist[i] = scorelist[j];
scorelist[j] = t;
}
}
for ( i = 0 ; i < indexcount ; i++ ) {
CG_DrawClientScore( y + lineHeight * i, scorelist[i], color, fade, lineHeight == SB_NORMAL_HEIGHT );
}
return indexcount;
}
That's it! Compile the changes and try out the new scoreboard.
4. Following on
There are a number of changes that you might want to make. Displaying the
fragrate and total number of frags is easily done, but the original scoreboard is too
wide to do this. You'll have to drop back to permanently using the scoreboard for large
numbers of players because of its smaller font.
Of more interest is a game that relies only on fragrate to determine the winner.
This requires more server side modifications, and the trick of storing 100 times the
actual fragrate in an integer may be useful.
Finally you might want a fragrate on your HUD. This is a little more involved as this
tutorial uses information that is only sent when the scoreboard is displayed.
|
