#include "../panel.qh"

Include dependency graph for scoreboard.qh:

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

Functions
void	Cmd_Scoreboard_SetFields (int argc)

void	Scoreboard_Draw ()

void	Scoreboard_InitScores ()

void	Scoreboard_UpdatePlayerPos (entity pl)

void	Scoreboard_UpdatePlayerTeams ()

void	Scoreboard_UpdateTeamPos (entity Team)

bool	Scoreboard_WouldDraw ()

Function Documentation

◆ Cmd_Scoreboard_SetFields()

void Cmd_Scoreboard_SetFields ( int argc )

Definition at line 412 of file scoreboard.qc.

References argv(), autocvar_scoreboard_columns, cvar_set(), FOREACH, gametype, hud_fontsize, HUD_GetFontsize(), isGametypeInFilter(), LABEL, LOG_INFO, LOG_INFOF, MAX_SBT_FIELDS, ps_primary, ps_secondary, sbt_field, sbt_field_size, sbt_field_title, sbt_num_fields, SCOREBOARD_DEFAULT_COLUMNS, scores_flags, scores_label, SFL_ALLOW_HIDE, strcat(), strcpy, strfree, stringwidth, strlen(), strstrofs, strzone(), substring(), TC, teamplay, tokenizebyseparator, and TranslateScoresLabel().

Referenced by Scoreboard_InitScores().

 {
     TC(int, argc);
     int i, slash;
     string str, pattern;
     bool have_name = false, have_primary = false, have_secondary = false, have_separator = false;
     int missing;
 
     if(!gametype)
         return; // do nothing, we don't know gametype and scores yet
 
     // sbt_fields uses strunzone on the titles!
     if(!sbt_field_title[0])
         for(i = 0; i < MAX_SBT_FIELDS; ++i)
             sbt_field_title[i] = strzone("(null)");
 
     // TODO: re enable with gametype dependant cvars?
     if(argc < 3) // no arguments provided
         argc = tokenizebyseparator(strcat("0 1 ", autocvar_scoreboard_columns), " ");
 
     if(argc < 3)
         argc = tokenizebyseparator(strcat("0 1 ", SCOREBOARD_DEFAULT_COLUMNS), " ");
 
     if(argc == 3)
     {
         if(argv(2) == "default" || argv(2) == "expand_default")
         {
             if(argv(2) == "expand_default")
                 cvar_set("scoreboard_columns", SCOREBOARD_DEFAULT_COLUMNS);
             argc = tokenizebyseparator(strcat("0 1 ", SCOREBOARD_DEFAULT_COLUMNS), " ");
         }
         else if(argv(2) == "all" || argv(2) == "ALL")
         {
             string s = "ping pl name |"; // scores without label (not really scores)
             if(argv(2) == "ALL")
             {
                 // scores without label
                 s = strcat(s, " ", "sum");
                 s = strcat(s, " ", "kdratio");
                 s = strcat(s, " ", "frags");
             }
             FOREACH(Scores, true, {
                 if(it != ps_primary)
                 if(it != ps_secondary)
                 if(scores_label(it) != "")
                     s = strcat(s, " ", scores_label(it));
             });
             if(ps_secondary != ps_primary)
                 s = strcat(s, " ", scores_label(ps_secondary));
             s = strcat(s, " ", scores_label(ps_primary));
             argc = tokenizebyseparator(strcat("0 1 ", s), " ");
         }
     }
 
 
     sbt_num_fields = 0;
 
     hud_fontsize = HUD_GetFontsize("hud_fontsize");
 
     for(i = 1; i < argc - 1; ++i)
     {
         str = argv(i+1);
         bool nocomplain = false;
         if(substring(str, 0, 1) == "?")
         {
             nocomplain = true;
             str = substring(str, 1, strlen(str) - 1);
         }
 
         slash = strstrofs(str, "/", 0);
         if(slash >= 0)
         {
             pattern = substring(str, 0, slash);
             str = substring(str, slash + 1, strlen(str) - (slash + 1));
 
             if (!isGametypeInFilter(gametype, teamplay, false, pattern))
                 continue;
         }
 
         str = strtolower(str);
         strcpy(sbt_field_title[sbt_num_fields], TranslateScoresLabel(str));
         sbt_field_size[sbt_num_fields] = stringwidth(sbt_field_title[sbt_num_fields], false, hud_fontsize);
 
         PlayerScoreField j;
         switch(str)
         {
             // fields without a label (not networked via the score system)
             case "ping": sbt_field[sbt_num_fields] = SP_PING; break;
             case "pl": sbt_field[sbt_num_fields] = SP_PL; break;
             case "name": case "nick": sbt_field[sbt_num_fields] = SP_NAME; have_name = true; break;
             case "|": sbt_field[sbt_num_fields] = SP_SEPARATOR; have_separator = true; break;
             case "kd": case "kdr": case "kdratio": sbt_field[sbt_num_fields] = SP_KDRATIO; break;
             case "sum": case "diff": case "k-d": sbt_field[sbt_num_fields] = SP_SUM; break;
             case "frags": sbt_field[sbt_num_fields] = SP_FRAGS; break;
             default: // fields with a label
             {
                 // map alternative labels
                 if (str == "damage") str = "dmg";
                 if (str == "damagetaken") str = "dmgtaken";
 
                 FOREACH(Scores, true, {
                     if (str == strtolower(scores_label(it))) {
                         j = it;
                         goto found; // sorry, but otherwise fteqcc -O3 miscompiles this and warns about "unreachable code"
                     }
                 });
 
                 // NOTE: can't check STAT(SHOWFPS) here, if checked too early it returns false anyway
                 if(!nocomplain && str != "fps") // server can disable the fps field
                     LOG_INFOF("^1Error:^7 Unknown score field: '%s'", str);
 
                 strfree(sbt_field_title[sbt_num_fields]);
                 sbt_field_size[sbt_num_fields] = 0;
                 continue;
 
                 LABEL(found)
                 sbt_field[sbt_num_fields] = j;
                 if(j == ps_primary)
                     have_primary = true;
                 if(j == ps_secondary)
                     have_secondary = true;
 
             }
         }
         ++sbt_num_fields;
         if(sbt_num_fields >= MAX_SBT_FIELDS)
             break;
     }
 
     if(scores_flags(ps_primary) & SFL_ALLOW_HIDE)
         have_primary = true;
     if(scores_flags(ps_secondary) & SFL_ALLOW_HIDE)
         have_secondary = true;
     if(ps_primary == ps_secondary)
         have_secondary = true;
     missing = (!have_primary) + (!have_secondary) + (!have_separator) + (!have_name);
 
     if(sbt_num_fields + missing < MAX_SBT_FIELDS)
     {
         if(!have_name)
         {
             strfree(sbt_field_title[sbt_num_fields]);
             for(i = sbt_num_fields; i > 0; --i)
             {
                 sbt_field_title[i] = sbt_field_title[i-1];
                 sbt_field_size[i] = sbt_field_size[i-1];
                 sbt_field[i] = sbt_field[i-1];
             }
             sbt_field_title[0] = strzone(TranslateScoresLabel("name"));
             sbt_field[0] = SP_NAME;
             ++sbt_num_fields;
             LOG_INFO("fixed missing field 'name'");
 
             if(!have_separator)
             {
                 strfree(sbt_field_title[sbt_num_fields]);
                 for(i = sbt_num_fields; i > 1; --i)
                 {
                     sbt_field_title[i] = sbt_field_title[i-1];
                     sbt_field_size[i] = sbt_field_size[i-1];
                     sbt_field[i] = sbt_field[i-1];
                 }
                 sbt_field_title[1] = strzone("|");
                 sbt_field[1] = SP_SEPARATOR;
                 sbt_field_size[1] = stringwidth("|", false, hud_fontsize);
                 ++sbt_num_fields;
                 LOG_INFO("fixed missing field '|'");
             }
         }
         else if(!have_separator)
         {
             strcpy(sbt_field_title[sbt_num_fields], "|");
             sbt_field_size[sbt_num_fields] = stringwidth("|", false, hud_fontsize);
             sbt_field[sbt_num_fields] = SP_SEPARATOR;
             ++sbt_num_fields;
             LOG_INFO("fixed missing field '|'");
         }
         if(!have_secondary)
         {
             strcpy(sbt_field_title[sbt_num_fields], TranslateScoresLabel(scores_label(ps_secondary)));
             sbt_field_size[sbt_num_fields] = stringwidth(sbt_field_title[sbt_num_fields], false, hud_fontsize);
             sbt_field[sbt_num_fields] = ps_secondary;
             ++sbt_num_fields;
             LOG_INFOF("fixed missing field '%s'", scores_label(ps_secondary));
         }
         if(!have_primary)
         {
             strcpy(sbt_field_title[sbt_num_fields], TranslateScoresLabel(scores_label(ps_primary)));
             sbt_field_size[sbt_num_fields] = stringwidth(sbt_field_title[sbt_num_fields], false, hud_fontsize);
             sbt_field[sbt_num_fields] = ps_primary;
             ++sbt_num_fields;
             LOG_INFOF("fixed missing field '%s'", scores_label(ps_primary));
         }
     }
 
     sbt_field[sbt_num_fields] = SP_END;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scoreboard_Draw()

void Scoreboard_Draw ( )

Definition at line 1774 of file scoreboard.qc.

 {
     if(!autocvar__hud_configure)
     {
         if(!hud_draw_maximized) return;
 
         // frametime checks allow to toggle the scoreboard even when the game is paused
         if(scoreboard_active) {
             if (scoreboard_fade_alpha == 0)
                 scoreboard_time = time;
             if(hud_configure_menu_open == 1)
                 scoreboard_fade_alpha = 1;
             float scoreboard_fadeinspeed = autocvar_hud_panel_scoreboard_fadeinspeed;
             if (scoreboard_fadeinspeed && frametime)
                 scoreboard_fade_alpha = min(1, scoreboard_fade_alpha + frametime * scoreboard_fadeinspeed);
             else
                 scoreboard_fade_alpha = 1;
             if(hud_fontsize_str != autocvar_hud_fontsize)
             {
                 hud_fontsize = HUD_GetFontsize("hud_fontsize");
                 Scoreboard_initFieldSizes();
                 strcpy(hud_fontsize_str, autocvar_hud_fontsize);
             }
         }
         else {
             float scoreboard_fadeoutspeed = autocvar_hud_panel_scoreboard_fadeoutspeed;
             if (scoreboard_fadeoutspeed && frametime)
                 scoreboard_fade_alpha = max(0, scoreboard_fade_alpha - frametime * scoreboard_fadeoutspeed);
             else
                 scoreboard_fade_alpha = 0;
         }
 
         if (!scoreboard_fade_alpha)
         {
             scoreboard_acc_fade_alpha = 0;
             scoreboard_itemstats_fade_alpha = 0;
             return;
         }
     }
     else
         scoreboard_fade_alpha = 0;
 
     if (autocvar_hud_panel_scoreboard_dynamichud)
         HUD_Scale_Enable();
     else
         HUD_Scale_Disable();
 
     if(scoreboard_fade_alpha <= 0)
         return;
     panel_fade_alpha *= scoreboard_fade_alpha;
     HUD_Panel_LoadCvars();
 
     sbt_bg_alpha = autocvar_hud_panel_scoreboard_table_bg_alpha * panel_fg_alpha;
     sbt_highlight = autocvar_hud_panel_scoreboard_table_highlight;
     sbt_highlight_alpha = autocvar_hud_panel_scoreboard_table_highlight_alpha * panel_fg_alpha;
     sbt_highlight_alpha_self = autocvar_hud_panel_scoreboard_table_highlight_alpha_self * panel_fg_alpha;
     sbt_highlight_alpha_eliminated = autocvar_hud_panel_scoreboard_table_highlight_alpha_eliminated * panel_fg_alpha;
     sbt_fg_alpha = autocvar_hud_panel_scoreboard_table_fg_alpha * panel_fg_alpha;
     sbt_fg_alpha_self = autocvar_hud_panel_scoreboard_table_fg_alpha_self * panel_fg_alpha;
 
     // don't overlap with con_notify
     if(!autocvar__hud_configure)
         panel_pos.y = max((autocvar_con_notify * autocvar_con_notifysize), panel_pos.y);
 
     float excess = max(0, max_namesize - autocvar_hud_panel_scoreboard_namesize * hud_fontsize.x);
     float fixed_scoreboard_width = bound(vid_conwidth * autocvar_hud_panel_scoreboard_minwidth, vid_conwidth - excess, vid_conwidth * 0.93);
     scoreboard_left = 0.5 * (vid_conwidth - fixed_scoreboard_width);
     scoreboard_right = scoreboard_left + fixed_scoreboard_width;
     panel_pos.x = scoreboard_left;
     panel_size.x = fixed_scoreboard_width;
 
     Scoreboard_UpdatePlayerTeams();
 
     scoreboard_top = panel_pos.y;
     vector pos = panel_pos;
     entity tm;
     string str;
     vector str_pos;
 
     vector sb_gameinfo_type_fontsize, sb_gameinfo_detail_fontsize;
 
     // Begin of Game Info Section
     sb_gameinfo_type_fontsize = hud_fontsize * 2.5;
     sb_gameinfo_detail_fontsize = hud_fontsize * 1.3;
 
     // Game Info: Game Type
     str = MapInfo_Type_ToText(gametype);
     draw_beginBoldFont();
     drawcolorcodedstring(pos + '0.5 0 0' * (panel_size.x - stringwidth(str, true, sb_gameinfo_type_fontsize)), str, sb_gameinfo_type_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
     draw_endBoldFont();
 
     // Game Info: Game Detail
     float tl = STAT(TIMELIMIT);
     float fl = STAT(FRAGLIMIT);
     float ll = STAT(LEADLIMIT);
     float ll_and_fl = STAT(LEADLIMIT_AND_FRAGLIMIT);
     str = "";
     if(tl > 0)
         str = strcat(str, sprintf(_("^3%1.0f minutes"), tl));
     if(!gametype.m_hidelimits)
     {
         if(fl > 0)
         {
             if(tl > 0)
                 str = strcat(str, "^7 / "); // delimiter
             if(teamplay)
             {
                 str = strcat(str, sprintf(_("^5%s %s"), ScoreString(teamscores_flags(ts_primary), fl),
                     (teamscores_label(ts_primary) == "score")   ? CTX(_("SCO^points")) :
                     (teamscores_label(ts_primary) == "fastest") ? "" :
                     TranslateScoresLabel(teamscores_label(ts_primary))));
             }
             else
             {
                 str = strcat(str, sprintf(_("^5%s %s"), ScoreString(scores_flags(ps_primary), fl),
                     (scores_label(ps_primary) == "score")   ? CTX(_("SCO^points")) :
                     (scores_label(ps_primary) == "fastest") ? "" :
                     TranslateScoresLabel(scores_label(ps_primary))));
             }
         }
         if(ll > 0)
         {
             if(tl > 0 || fl > 0)
             {
                 // delimiter
                 if (ll_and_fl && fl > 0)
                     str = strcat(str, "^7 & ");
                 else
                     str = strcat(str, "^7 / ");
             }
 
             if(teamplay)
             {
                 str = strcat(str, sprintf(_("^2+%s %s"), ScoreString(teamscores_flags(ts_primary), ll),
                     (teamscores_label(ts_primary) == "score")   ? CTX(_("SCO^points")) :
                     (teamscores_label(ts_primary) == "fastest") ? "" :
                     TranslateScoresLabel(teamscores_label(ts_primary))));
             }
             else
             {
                 str = strcat(str, sprintf(_("^2+%s %s"), ScoreString(scores_flags(ps_primary), ll),
                     (scores_label(ps_primary) == "score")   ? CTX(_("SCO^points")) :
                     (scores_label(ps_primary) == "fastest") ? "" :
                     TranslateScoresLabel(scores_label(ps_primary))));
             }
         }
     }
 
     pos.y += sb_gameinfo_type_fontsize.y;
     drawcolorcodedstring(pos + '1 0 0' * (panel_size.x - stringwidth(str, true, sb_gameinfo_detail_fontsize)), str, sb_gameinfo_detail_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL); // align right
     // map name
     str = sprintf(_("^7Map: ^2%s"), shortmapname);
     drawcolorcodedstring(pos, str, sb_gameinfo_detail_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL); // align left
     // End of Game Info Section
 
     pos.y += sb_gameinfo_detail_fontsize.y + hud_fontsize.y * 0.3; // space between Game Info Section and score table
     if(panel.current_panel_bg != "0")
         pos.y += panel_bg_border;
 
     // Draw the scoreboard
     float scale = autocvar_hud_panel_scoreboard_table_bg_scale;
     if(scale <= 0)
         scale = 0.25;
     vector bg_size = draw_getimagesize("gfx/scoreboard/scoreboard_bg") * scale;
 
     if(teamplay)
     {
         vector panel_bg_color_save = panel_bg_color;
         vector team_score_baseoffset;
         vector team_size_baseoffset;
         if (autocvar_hud_panel_scoreboard_team_size_position != 1) // team size not on left
         {
             // put team score to the left of scoreboard (and team size to the right)
             team_score_baseoffset = eY * hud_fontsize.y - eX * hud_fontsize.x * 0.5;
             team_size_baseoffset = eY * hud_fontsize.y + eX * hud_fontsize.x * 0.5;
             if(panel.current_panel_bg != "0")
             {
                 team_score_baseoffset.x -= panel_bg_border;
                 team_size_baseoffset.x += panel_bg_border;
             }
         }
         else
         {
             // put team score to the right of scoreboard (and team size to the left)
             team_score_baseoffset = eY * hud_fontsize.y + eX * hud_fontsize.x * 0.5;
             team_size_baseoffset = eY * hud_fontsize.y - eX * hud_fontsize.x * 0.5;
             if(panel.current_panel_bg != "0")
             {
                 team_score_baseoffset.x += panel_bg_border;
                 team_size_baseoffset.x -= panel_bg_border;
             }
         }
 
         int team_size_total = 0;
         if (autocvar_hud_panel_scoreboard_team_size_position != 0) // team size not off
         {
             // calculate team size total (sum of all team sizes)
             for(tm = teams.sort_next; tm; tm = tm.sort_next)
                 if(tm.team != NUM_SPECTATOR)
                     team_size_total += tm.team_size;
         }
 
         for(tm = teams.sort_next; tm; tm = tm.sort_next)
         {
             if(tm.team == NUM_SPECTATOR)
                 continue;
             if(!tm.team)
                 continue;
 
             draw_beginBoldFont();
             vector rgb = Team_ColorRGB(tm.team);
             str = ftos(tm.(teamscores(ts_primary)));
             if (autocvar_hud_panel_scoreboard_team_size_position != 1) // team size not on left
             {
                 // team score on the left (default)
                 str_pos = pos + team_score_baseoffset - eX * stringwidth(str, false, hud_fontsize * 1.5);
             }
             else
             {
                 // team score on the right
                 str_pos = pos + team_score_baseoffset + eX * (panel_size.x + hud_fontsize.x * 1.5);
             }
             drawstring(str_pos, str, hud_fontsize * 1.5, rgb, panel_fg_alpha, DRAWFLAG_NORMAL);
 
             // team size (if set to show on the side)
             if (autocvar_hud_panel_scoreboard_team_size_position != 0) // team size not off
             {
                 // calculate the starting position for the whole team size info string
                 str = sprintf("%d/%d", tm.team_size, team_size_total);
                 if (autocvar_hud_panel_scoreboard_team_size_position == 1)
                 {
                     // team size on the left
                     str_pos = pos + team_size_baseoffset - eX * stringwidth(str, false, hud_fontsize * 1.5);
                 }
                 else
                 {
                     // team size on the right
                     str_pos = pos + team_size_baseoffset + eX * (panel_size.x + hud_fontsize.x * 1.5);
                 }
                 str = sprintf("%d", tm.team_size);
                 drawstring(str_pos, str, hud_fontsize * 1.5, rgb, panel_fg_alpha, DRAWFLAG_NORMAL);
                 str_pos += eX * stringwidth(str, true, hud_fontsize * 1.5) + eY * hud_fontsize.y * .5;
                 str = sprintf("/%d", team_size_total);
                 drawstring(str_pos, str, hud_fontsize, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
             }
 
 
             // secondary score, e.g. keyhunt
             if(ts_primary != ts_secondary)
             {
                 str = ftos(tm.(teamscores(ts_secondary)));
                 if (autocvar_hud_panel_scoreboard_team_size_position != 1) // team size not on left
                 {
                     // left
                     str_pos = pos + team_score_baseoffset - vec2(stringwidth(str, false, hud_fontsize), hud_fontsize.y * -1.5);
                 }
                 else
                 {
                     // right
                     str_pos = pos + team_score_baseoffset + vec2(panel_size.x + hud_fontsize.x * 1.5, hud_fontsize.y * 1.5);
                 }
 
                 drawstring(str_pos, str, hud_fontsize, rgb, panel_fg_alpha, DRAWFLAG_NORMAL);
             }
             draw_endBoldFont();
             if(autocvar_hud_panel_scoreboard_bg_teams_color_team > 0)
                 panel_bg_color = rgb * autocvar_hud_panel_scoreboard_bg_teams_color_team;
             else if(panel_bg_color_team > 0)
                 panel_bg_color = rgb * panel_bg_color_team;
             else
                 panel_bg_color = rgb;
             pos = Scoreboard_MakeTable(pos, tm, panel_bg_color, bg_size);
         }
         panel_bg_color = panel_bg_color_save;
     }
     else
     {
         for(tm = teams.sort_next; tm; tm = tm.sort_next)
             if(tm.team != NUM_SPECTATOR)
                 break;
 
         // display it anyway
         pos = Scoreboard_MakeTable(pos, tm, panel_bg_color, bg_size);
     }
 
     // draw scoreboard spectators before accuracy and item stats
     if (autocvar_hud_panel_scoreboard_spectators_position == 0) {
         pos = Scoreboard_Spectators_Draw(pos);
     }
 
     // draw accuracy and item stats
     if (Scoreboard_AccuracyStats_WouldDraw(pos.y))
         pos = Scoreboard_AccuracyStats_Draw(pos, panel_bg_color, bg_size);
     if (Scoreboard_ItemStats_WouldDraw(pos.y))
         pos = Scoreboard_ItemStats_Draw(pos, panel_bg_color, bg_size);
 
     // draw scoreboard spectators after accuracy and item stats and before rankings
     if (autocvar_hud_panel_scoreboard_spectators_position == 1) {
         pos = Scoreboard_Spectators_Draw(pos);
     }
 
     if(MUTATOR_CALLHOOK(ShowRankings)) {
         string ranktitle = M_ARGV(0, string);
         string unit = GetSpeedUnit(autocvar_hud_panel_physics_speed_unit);
         if(race_speedaward) {
             drawcolorcodedstring(pos, sprintf(_("Speed award: %d%s ^7(%s^7)"), race_speedaward, unit, ColorTranslateRGB(race_speedaward_holder)), hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
             pos.y += 1.25 * hud_fontsize.y;
         }
         if(race_speedaward_alltimebest) {
             drawcolorcodedstring(pos, sprintf(_("All-time fastest: %d%s ^7(%s^7)"), race_speedaward_alltimebest, unit, ColorTranslateRGB(race_speedaward_alltimebest_holder)), hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
             pos.y += 1.25 * hud_fontsize.y;
         }
         if (race_speedaward || race_speedaward_alltimebest)
             pos.y += 0.25 * hud_fontsize.y;
         pos = Scoreboard_Rankings_Draw(pos, ranktitle, playerslots[player_localnum], panel_bg_color, bg_size);
     }
     else
         rankings_cnt = 0;
 
     // draw scoreboard spectators after rankings
     if (autocvar_hud_panel_scoreboard_spectators_position == 2) {
         pos = Scoreboard_Spectators_Draw(pos);
     }
 
     pos = Scoreboard_MapStats_Draw(pos, panel_bg_color, bg_size);
 
     // draw scoreboard spectators after mapstats
     if (autocvar_hud_panel_scoreboard_spectators_position == 3) {
         pos = Scoreboard_Spectators_Draw(pos);
     }
 
 
     // print information about respawn status
     float respawn_time = STAT(RESPAWN_TIME);
     if(!intermission)
     if(respawn_time)
     {
         if(respawn_time < 0)
         {
             // a negative number means we are awaiting respawn, time value is still the same
             respawn_time *= -1; // remove mark now that we checked it
 
             if(respawn_time < time) // it happens for a few frames when server is respawning the player
                 str = ""; // draw an empty string to not change suddenly scoreboard_bottom
             else
                 str = sprintf(_("^1Respawning in ^3%s^1..."),
                     (autocvar_hud_panel_scoreboard_respawntime_decimals ?
                         count_seconds_decs(respawn_time - time, autocvar_hud_panel_scoreboard_respawntime_decimals)
                         :
                         count_seconds(ceil(respawn_time - time))
                     )
                 );
         }
         else if(time < respawn_time)
         {
             str = sprintf(_("You are dead, wait ^3%s^7 before respawning"),
                 (autocvar_hud_panel_scoreboard_respawntime_decimals ?
                     count_seconds_decs(respawn_time - time, autocvar_hud_panel_scoreboard_respawntime_decimals)
                     :
                     count_seconds(ceil(respawn_time - time))
                 )
             );
         }
         else if(time >= respawn_time)
             str = sprintf(_("You are dead, press ^2%s^7 to respawn"), getcommandkey("jump", "+jump"));
 
         pos.y += 1.2 * hud_fontsize.y;
         drawcolorcodedstring(pos + '0.5 0 0' * (panel_size.x - stringwidth(str, true, hud_fontsize)), str, hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
     }
 
     pos.y += hud_fontsize.y;
     if (scoreboard_fade_alpha < 1)
         scoreboard_bottom = scoreboard_top + (pos.y - scoreboard_top) * scoreboard_fade_alpha;
     else if (pos.y != scoreboard_bottom)
     {
         if (pos.y > scoreboard_bottom)
             scoreboard_bottom = min(pos.y, scoreboard_bottom + frametime * 10 * (pos.y - scoreboard_top));
         else
             scoreboard_bottom = max(pos.y, scoreboard_bottom - frametime * 10 * (pos.y - scoreboard_top));
     }
 
     if (rankings_cnt)
     {
         if (scoreboard_fade_alpha == 1)
         {
             if (scoreboard_bottom > 0.95 * vid_conheight)
                 rankings_rows = max(1, rankings_rows - 1);
             else if (scoreboard_bottom + 1.25 * hud_fontsize.y < 0.95 * vid_conheight)
                 rankings_rows = min(ceil(RANKINGS_RECEIVED_CNT / rankings_columns), rankings_rows + 1);
         }
         rankings_cnt = rankings_rows * rankings_columns;
     }
 }

Here is the call graph for this function:

◆ Scoreboard_InitScores()

void Scoreboard_InitScores ( )

Definition at line 172 of file scoreboard.qc.

References Cmd_Scoreboard_SetFields(), FOREACH, MAX_TEAMSCORE, NULL, ps_primary, ps_secondary, sb_extra_sorting_field, scores_flags, scores_label, SFL_SORT_PRIO_MASK, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_SECONDARY, teamscores_flags, ts_primary, and ts_secondary.

Referenced by NET_HANDLE().

 {
     int i, f;
 
     ps_primary = ps_secondary = NULL;
     ts_primary = ts_secondary = -1;
     FOREACH(Scores, true, {
         f = (scores_flags(it) & SFL_SORT_PRIO_MASK);
         if(f == SFL_SORT_PRIO_PRIMARY)
             ps_primary = it;
         if(f == SFL_SORT_PRIO_SECONDARY)
             ps_secondary = it;
         if(ps_primary == it || ps_secondary == it)
             continue;
         if (scores_label(it) == "kills")      sb_extra_sorting_field[0] = it;
         if (scores_label(it) == "deaths")     sb_extra_sorting_field[1] = it;
         if (scores_label(it) == "suicides")   sb_extra_sorting_field[2] = it;
         if (scores_label(it) == "dmg")        sb_extra_sorting_field[3] = it;
         if (scores_label(it) == "dmgtaken")   sb_extra_sorting_field[4] = it;
     });
     if(ps_secondary == NULL)
         ps_secondary = ps_primary;
 
     for(i = 0; i < MAX_TEAMSCORE; ++i)
     {
         f = (teamscores_flags(i) & SFL_SORT_PRIO_MASK);
         if(f == SFL_SORT_PRIO_PRIMARY)
             ts_primary = i;
         if(f == SFL_SORT_PRIO_SECONDARY)
             ts_secondary = i;
     }
     if(ts_secondary == -1)
         ts_secondary = ts_primary;
 
     Cmd_Scoreboard_SetFields(0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scoreboard_UpdatePlayerPos()

void Scoreboard_UpdatePlayerPos ( entity pl )

Definition at line 298 of file scoreboard.qc.

References entity(), players, Scoreboard_ComparePlayerScores(), and SORT_SWAP.

Referenced by NET_HANDLE(), Playerchecker_Think(), and Scoreboard_UpdatePlayerTeams().

 {
     entity ent;
     for(ent = player.sort_next; ent && Scoreboard_ComparePlayerScores(player, ent); ent = player.sort_next)
     {
         SORT_SWAP(player, ent);
     }
     for(ent = player.sort_prev; ent != players && Scoreboard_ComparePlayerScores(ent, player); ent = player.sort_prev)
     {
         SORT_SWAP(ent, player);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scoreboard_UpdatePlayerTeams()

void Scoreboard_UpdatePlayerTeams ( )

Definition at line 210 of file scoreboard.qc.

References entity(), players, Scoreboard_UpdatePlayerPos(), and SetTeam().

Referenced by Scoreboard_Draw().

 {
     entity pl, tmp;
     //int num = 0;
     for(pl = players.sort_next; pl; pl = pl.sort_next)
     {
         //num += 1;
         int Team = entcs_GetScoreTeam(pl.sv_entnum);
         if(SetTeam(pl, Team))
         {
             tmp = pl.sort_prev;
             Scoreboard_UpdatePlayerPos(pl);
             if(tmp)
                 pl = tmp;
             else
                 pl = players.sort_next;
         }
     }
     /*
     if(num != lastpnum)
         print(strcat("PNUM: ", ftos(num), "\n"));
     lastpnum = num;
     */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scoreboard_UpdateTeamPos()

void Scoreboard_UpdateTeamPos ( entity Team )

Definition at line 344 of file scoreboard.qc.

References entity(), Scoreboard_CompareTeamScores(), SORT_SWAP, and teams.

Referenced by NET_HANDLE().

 {
     entity ent;
     for(ent = Team.sort_next; ent && Scoreboard_CompareTeamScores(Team, ent); ent = Team.sort_next)
     {
         SORT_SWAP(Team, ent);
     }
     for(ent = Team.sort_prev; ent != teams && Scoreboard_CompareTeamScores(ent, Team); ent = Team.sort_prev)
     {
         SORT_SWAP(ent, Team);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scoreboard_WouldDraw()

bool Scoreboard_WouldDraw ( )

Definition at line 1187 of file scoreboard.qc.

References active_minigame, autocvar_cl_deathscoreboard, HUD_MinigameMenu_IsOpened(), HUD_Radar_Clickable(), intermission, MUTATOR_CALLHOOK, QuickMenu_IsOpened(), scoreboard_showscores, scoreboard_showscores_force, and spectatee_status.

Referenced by CSQC_UpdateView().

 {
     if (MUTATOR_CALLHOOK(DrawScoreboard))
         return false;
     else if (QuickMenu_IsOpened())
         return false;
     else if (HUD_Radar_Clickable())
         return false;
     else if (scoreboard_showscores)
         return true;
     else if (intermission == 1)
         return true;
     else if (intermission == 2)
         return false;
     else if (spectatee_status != -1 && STAT(HEALTH) <= 0 && autocvar_cl_deathscoreboard && !MUTATOR_CALLHOOK(DrawDeathScoreboard)
         && (!HUD_MinigameMenu_IsOpened() || !active_minigame))
     {
         return true;
     }
     else if (scoreboard_showscores_force || MUTATOR_CALLHOOK(DrawScoreboard_Force))
         return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ autocvar_cl_deathscoreboard

bool autocvar_cl_deathscoreboard

Definition at line 4 of file scoreboard.qh.

Referenced by Scoreboard_WouldDraw().

◆ autocvar_scoreboard_columns

string autocvar_scoreboard_columns

Definition at line 5 of file scoreboard.qh.

Referenced by Cmd_Scoreboard_SetFields().

◆ scoreboard_acc_fade_alpha

float scoreboard_acc_fade_alpha

Definition at line 11 of file scoreboard.qh.

Referenced by Scoreboard_AccuracyStats_Draw(), and Scoreboard_Draw().

◆ scoreboard_active

bool scoreboard_active

Definition at line 9 of file scoreboard.qh.

Referenced by AuxiliaryXhair_Draw2D(), CSQC_UpdateView(), HUD_Configure_Frame(), HUD_Crosshair(), and Scoreboard_Draw().

◆ scoreboard_bottom

float scoreboard_bottom

Definition at line 15 of file scoreboard.qh.

Referenced by HUD_Notify().

◆ scoreboard_fade_alpha

float scoreboard_fade_alpha

Definition at line 10 of file scoreboard.qh.

Referenced by HUD_Main(), HUD_Notify(), HUD_Panel_Draw(), Scoreboard_AccuracyStats_Draw(), Scoreboard_Draw(), and Scoreboard_ItemStats_Draw().

◆ scoreboard_itemstats_fade_alpha

float scoreboard_itemstats_fade_alpha

Definition at line 12 of file scoreboard.qh.

Referenced by Scoreboard_Draw(), and Scoreboard_ItemStats_Draw().

◆ scoreboard_left

float scoreboard_left

Definition at line 16 of file scoreboard.qh.

Referenced by HUD_Notify(), and Scoreboard_Draw().

◆ scoreboard_right

float scoreboard_right

Definition at line 17 of file scoreboard.qh.

Referenced by HUD_Notify(), and Scoreboard_Draw().

◆ scoreboard_showscores

bool scoreboard_showscores

Definition at line 7 of file scoreboard.qh.

Referenced by Scoreboard_WouldDraw().

◆ scoreboard_top

float scoreboard_top

Definition at line 14 of file scoreboard.qh.

Referenced by HUD_Notify(), and Scoreboard_Draw().

Variables
bool	autocvar_cl_deathscoreboard

string	autocvar_scoreboard_columns

float	scoreboard_acc_fade_alpha

bool	scoreboard_active

float	scoreboard_bottom

float	scoreboard_fade_alpha

float	scoreboard_itemstats_fade_alpha

float	scoreboard_left

float	scoreboard_right

bool	scoreboard_showscores

float	scoreboard_top

Functions

Variables

Function Documentation

◆ Cmd_Scoreboard_SetFields()

◆ Scoreboard_Draw()

◆ Scoreboard_InitScores()

◆ Scoreboard_UpdatePlayerPos()

◆ Scoreboard_UpdatePlayerTeams()

◆ Scoreboard_UpdateTeamPos()

◆ Scoreboard_WouldDraw()

Variable Documentation

◆ autocvar_cl_deathscoreboard

◆ autocvar_scoreboard_columns

◆ scoreboard_acc_fade_alpha

◆ scoreboard_active

◆ scoreboard_bottom

◆ scoreboard_fade_alpha

◆ scoreboard_itemstats_fade_alpha

◆ scoreboard_left

◆ scoreboard_right

◆ scoreboard_showscores

◆ scoreboard_top