scoreboard.qh File Reference

#include "../panel.qh"

Include dependency graph for scoreboard.qh:

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

Go to the source code of this file.

Macros
#define	GET_NEXTMAP()

Functions
void	Cmd_Scoreboard_SetFields (int argc)
float	HUD_Scoreboard_InputEvent (float bInputType, float nPrimary, float nSecondary)
void	Scoreboard_Draw ()
void	Scoreboard_InitScores ()
void	Scoreboard_UI_Enable (int mode)
void	Scoreboard_UpdatePlayerPos (entity pl)
void	Scoreboard_UpdatePlayerTeams ()
void	Scoreboard_UpdateTeamPos (entity Team)
bool	Scoreboard_WouldDraw ()

Variables
string	autocvar__nextmap
bool	autocvar__scoreboard_team_selection
bool	autocvar_cl_deathscoreboard
float	autocvar_cl_deathscoreboard_delay = 1
float	autocvar_hud_panel_scoreboard_namesize = 15
string	autocvar_scoreboard_columns
bool	ignored
int	numplayers
int	SB_PANEL_FIRST = 1
int	SB_PANEL_MAX = 2
int	SB_PANEL_RANKINGS = 2
int	SB_PANEL_SCOREBOARD = 1
bool	sb_showscores
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
int	scoreboard_selected_columns_layout
int	scoreboard_selected_panel
float	scoreboard_selected_panel_time
entity	scoreboard_selected_player
entity	scoreboard_selected_team
float	scoreboard_top
int	scoreboard_ui_enabled
int	ts_max
	team size
int	ts_min

Macro Definition Documentation

GET_NEXTMAP

#define GET_NEXTMAP

(

)

Value:

autocvar__nextmap

Definition at line 12 of file scoreboard.qh.

Referenced by Scoreboard_Draw().

Function Documentation

Cmd_Scoreboard_SetFields()

void Cmd_Scoreboard_SetFields

(

int

argc

)

Definition at line 767 of file scoreboard.qc.

{
    TC(int, argc);
    if (!gametype)
        return; // do nothing, we don't know gametype and scores yet
 
    int i;
    bool have_name = false, have_primary = false, have_secondary = false, have_separator = false;
 
    // 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 && it != ps_secondary && 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");
 
    string str, pattern;
    int slash;
    bool nocomplain;
    for (i = 1; i < argc - 1; ++i)
    {
        str = argv(i+1);
        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));
 
        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, 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" && str != "skill") // server can disable the fps or skill fields
                    LOG_INFOF("^1Error:^7 Unknown score field: '%s'", str);
 
                strfree(sbt_field_title[sbt_num_fields]);
                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;
    int 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[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[i] = sbt_field[i-1];
                }
                sbt_field_title[1] = strzone("|");
                sbt_field[1] = SP_SEPARATOR;
                ++sbt_num_fields;
                LOG_INFO("fixed missing field '|'");
            }
        }
        else if (!have_separator)
        {
            strcpy(sbt_field_title[sbt_num_fields], "|");
            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[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[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;
    sb_field_sizes_init = 1;
}

Referenced by Scoreboard_InitScores().

HUD_Scoreboard_InputEvent()

float HUD_Scoreboard_InputEvent	(	float	bInputType,
		float	nPrimary,
		float	nSecondary )

Definition at line 231 of file scoreboard.qc.

{
    if (!scoreboard_ui_enabled || scoreboard_ui_disabling)
        return false;
 
    if (bInputType == 3)
    {
        mousepos.x = nPrimary;
        mousepos.y = nSecondary;
        return true;
    }
 
    if (bInputType == 2)
        return false;
 
    // at this point bInputType can only be 0 or 1 (key pressed or released)
    bool key_pressed = bInputType == 0;
 
    // ESC to exit (TAB-ESC works too)
    if (nPrimary == K_ESCAPE)
    {
        if (!key_pressed)
            return true;
        HUD_Scoreboard_UI_Disable();
        return true;
    }
 
    // block any input while a menu dialog is fading
    if (autocvar__menu_alpha)
    {
        hudShiftState = 0;
        return true;
    }
 
    // allow console bind to work
    string con_keys = findkeysforcommand("toggleconsole", 0);
    int keys = tokenize(con_keys); // findkeysforcommand returns data for this
 
    bool hit_con_bind = false;
    for (int i = 0; i < keys; ++i)
        if (nPrimary == stof(argv(i)))
            hit_con_bind = true;
 
    if (key_pressed)
    {
        if (nPrimary == K_ALT)    hudShiftState |= S_ALT;
        if (nPrimary == K_CTRL)   hudShiftState |= S_CTRL;
        if (nPrimary == K_SHIFT)  hudShiftState |= S_SHIFT;
        if (nPrimary == K_TAB)    hudShiftState |= S_TAB;
    }
    else
    {
        if (nPrimary == K_ALT)    hudShiftState &= ~S_ALT;
        if (nPrimary == K_CTRL)   hudShiftState &= ~S_CTRL;
        if (nPrimary == K_SHIFT)  hudShiftState &= ~S_SHIFT;
        if (nPrimary == K_TAB)    hudShiftState &= ~S_TAB;
    }
 
    if (nPrimary == K_TAB)
    {
        if (!key_pressed)
            return true;
        if (scoreboard_ui_enabled == 2)
        {
            if (hudShiftState & S_SHIFT)
                goto uparrow_action;
            else
                goto downarrow_action;
        }
 
        if (hudShiftState & S_SHIFT)
        {
            --scoreboard_selected_panel;
            if (scoreboard_selected_panel == SB_PANEL_RANKINGS && !rankings_cnt)
                --scoreboard_selected_panel;
            if (scoreboard_selected_panel < SB_PANEL_FIRST)
                scoreboard_selected_panel = SB_PANEL_MAX;
        }
        else
        {
            ++scoreboard_selected_panel;
            if (scoreboard_selected_panel == SB_PANEL_RANKINGS && !rankings_cnt)
                ++scoreboard_selected_panel;
            if (scoreboard_selected_panel > SB_PANEL_MAX)
                scoreboard_selected_panel = SB_PANEL_FIRST;
        }
 
        scoreboard_selected_panel_time = time;
    }
    else if (nPrimary == K_DOWNARROW)
    {
        if (!key_pressed)
            return true;
        LABEL(downarrow_action);
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD)
        {
            if (scoreboard_ui_enabled == 2)
            {
                bool scoreboard_selected_team_found = !scoreboard_selected_team;
 
                entity curr_team = NULL;
                for (entity tm = teams.sort_next; tm; tm = tm.sort_next)
                {
                    if (tm.team == NUM_SPECTATOR)
                        continue;
                    curr_team = tm;
                    if (scoreboard_selected_team_found)
                        goto ok_team;
                    if (scoreboard_selected_team == tm)
                        scoreboard_selected_team_found = true;
                }
                LABEL(ok_team);
                if (curr_team == scoreboard_selected_team) // loop reached the last team
                    curr_team = NULL;
                scoreboard_selected_team = curr_team;
            }
            else
            {
                bool scoreboard_selected_player_found = !scoreboard_selected_player;
 
                entity curr_pl = NULL;
                for (entity pl, tm = teams.sort_next; tm; tm = tm.sort_next)
                    if (tm.team != NUM_SPECTATOR)
                        for (pl = players.sort_next; pl; pl = pl.sort_next)
                        {
                            if (pl.team != tm.team)
                                continue;
                            curr_pl = pl;
                            if (scoreboard_selected_player_found)
                                goto ok_done;
                            if (scoreboard_selected_player == pl)
                                scoreboard_selected_player_found = true;
                        }
                LABEL(ok_done);
                if (curr_pl == scoreboard_selected_player) // loop reached the last player
                    curr_pl = NULL;
                scoreboard_selected_player = curr_pl;
            }
        }
    }
    else if (nPrimary == K_UPARROW)
    {
        if (!key_pressed)
            return true;
        LABEL(uparrow_action);
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD)
        {
            if (scoreboard_ui_enabled == 2)
            {
                entity prev_team = NULL;
                for (entity tm = teams.sort_next; tm; tm = tm.sort_next)
                {
                    if (tm.team == NUM_SPECTATOR)
                        continue;
                    if (tm == scoreboard_selected_team)
                        goto ok_team2;
                    prev_team = tm;
                }
                LABEL(ok_team2);
                scoreboard_selected_team = prev_team;
            }
            else
            {
                entity prev_pl = NULL;
                for (entity pl, tm = teams.sort_next; tm; tm = tm.sort_next)
                    if (tm.team != NUM_SPECTATOR)
                        for (pl = players.sort_next; pl; pl = pl.sort_next)
                        {
                            if (pl.team != tm.team)
                                continue;
                            if (pl == scoreboard_selected_player)
                                goto ok_done2;
                            prev_pl = pl;
                        }
                LABEL(ok_done2);
                scoreboard_selected_player = prev_pl;
            }
        }
    }
    else if (nPrimary == K_RIGHTARROW)
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_RANKINGS)
            rankings_start_column = min(rankings_start_column + 1, (ceil(RANKINGS_RECEIVED_CNT / rankings_rows) - rankings_columns));
    }
    else if (nPrimary == K_LEFTARROW)
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_RANKINGS)
            rankings_start_column = max(rankings_start_column - 1, 0);
    }
    else if (nPrimary == K_ENTER || nPrimary == K_SPACE || nPrimary == K_KP_ENTER)
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD)
        {
            if (scoreboard_ui_enabled == 2)
            {
                string team_name;
                if (!scoreboard_selected_team || (hudShiftState & S_SHIFT))
                    team_name = "auto";
                else
                    team_name = Static_Team_ColorName(scoreboard_selected_team.team);
                localcmd(sprintf("cmd selectteam %s; cmd join\n", team_name));
                HUD_Scoreboard_UI_Disable();
            }
            else if (scoreboard_selected_player)
                localcmd(sprintf("spectate %d\n", scoreboard_selected_player.sv_entnum + 1));
        }
    }
    else if (nPrimary == 'c' && (hudShiftState & S_CTRL))
    {
        if (!key_pressed)
            return true;
        if (scoreboard_ui_enabled == 1 && scoreboard_selected_panel == SB_PANEL_SCOREBOARD)
        {
            switch (scoreboard_selected_columns_layout)
            {
                case 0:
                    if (autocvar_scoreboard_columns != "" && autocvar_scoreboard_columns != "all" && autocvar_scoreboard_columns != "default")
                    {
                        localcmd(sprintf("scoreboard_columns_set\n")); // sets the layout saved in scoreboard_columns
                        scoreboard_selected_columns_layout = 1;
                        break;
                    }
                    // fallthrough
                case 1:
                    localcmd(sprintf("scoreboard_columns_set default\n"));
                    scoreboard_selected_columns_layout = 2;
                    break;
                case 2:
                    localcmd(sprintf("scoreboard_columns_set all\n"));
                    scoreboard_selected_columns_layout = 0;
                    break;
            }
        }
    }
    else if (nPrimary == 'r' && (hudShiftState & S_CTRL))
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD)
            localcmd("toggle hud_panel_scoreboard_scores_per_round\n");
    }
    else if (nPrimary == 't' && (hudShiftState & S_CTRL))
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD
            && scoreboard_selected_player)
        {
            localcmd(sprintf("commandmode tell \"%s^7\"\n", entcs_GetName(scoreboard_selected_player.sv_entnum)));
            HUD_Scoreboard_UI_Disable();
        }
    }
    else if (nPrimary == 'k' && (hudShiftState & S_CTRL))
    {
        if (!key_pressed)
            return true;
        if (scoreboard_selected_panel == SB_PANEL_SCOREBOARD
            && scoreboard_selected_player)
        {
            localcmd(sprintf("vcall kick \"%s^7\"\n", entcs_GetName(scoreboard_selected_player.sv_entnum)));
        }
    }
    else if (hit_con_bind || nPrimary == K_PAUSE)
        return false;
 
    return true;
}

References argv(), autocvar__menu_alpha, autocvar_scoreboard_columns, ceil(), entcs_GetName(), entity(), HUD_Scoreboard_UI_Disable(), hudShiftState, K_ALT, K_CTRL, K_DOWNARROW, K_ENTER, K_ESCAPE, K_KP_ENTER, K_LEFTARROW, K_PAUSE, K_RIGHTARROW, K_SHIFT, K_SPACE, K_TAB, K_UPARROW, LABEL, localcmd(), max(), min(), mousepos, NULL, NUM_SPECTATOR, players, prev_team, rankings_cnt, rankings_columns, RANKINGS_RECEIVED_CNT, rankings_rows, rankings_start_column, S_ALT, S_CTRL, S_SHIFT, S_TAB, SB_PANEL_FIRST, SB_PANEL_MAX, SB_PANEL_RANKINGS, SB_PANEL_SCOREBOARD, scoreboard_selected_columns_layout, scoreboard_selected_panel, scoreboard_selected_panel_time, scoreboard_selected_player, scoreboard_selected_team, scoreboard_ui_disabling, scoreboard_ui_enabled, Static_Team_ColorName(), stof(), teams, time, and tokenize().

Referenced by CSQC_InputEvent().

Scoreboard_Draw()

void Scoreboard_Draw

(

)

Definition at line 2401 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;
 
            static string hud_fontsize_str;
            if (hud_fontsize_str != autocvar_hud_fontsize)
            {
                hud_fontsize = HUD_GetFontsize("hud_fontsize");
                strcpy(hud_fontsize_str, autocvar_hud_fontsize);
                sb_field_sizes_init = 1;
            }
 
            static float scoreboard_table_fieldtitle_maxwidth_prev;
            if (scoreboard_table_fieldtitle_maxwidth_prev != autocvar_hud_panel_scoreboard_table_fieldtitle_maxwidth)
            {
                scoreboard_table_fieldtitle_maxwidth_prev = autocvar_hud_panel_scoreboard_table_fieldtitle_maxwidth;
                sbt_field_title_maxwidth = bound(0.01, autocvar_hud_panel_scoreboard_table_fieldtitle_maxwidth, 0.1);
                sbt_field_title_maxwidth *= vid_conwidth;
                sb_field_sizes_init = 1;
            }
        }
        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;
 
    // field sizes can be initialized now after panel_size.x calculation
    if (!sbt_field_size[0] || sb_field_sizes_init)
    {
        bool compress = (sb_field_sizes_init == 2);
        Scoreboard_initFieldSizes(compress);
        sb_field_sizes_init = 0;
    }
 
    Scoreboard_UpdatePlayerTeams();
 
    scoreboard_top = panel_pos.y;
    vector pos = panel_pos;
 
    if (scoreboard_ui_enabled)
        drawfill('0 0 0', eX * vid_conwidth + eY * vid_conheight, '0 0 0', 0.7 * panel_fade_alpha, DRAWFLAG_NORMAL);
 
    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;
 
    string str;
    if (GET_NEXTMAP() != "")
    {
        // NOTE: nextmap is drawn before title to avoid covering title in case of long map name
        str = strcat("^7", _("Next map:"), " ^9", GET_NEXTMAP());
        drawcolorcodedstring(pos + vec2(hud_fontsize.x * 0.5, sb_gameinfo_type_fontsize.y - hud_fontsize.y * 1.25),
            str, hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
    }
 
    // Game Info: Gametype
    if (scoreboard_ui_enabled == 2)
        str = _("Team Selection");
    else if (gametype_custom_name != "")
        str = gametype_custom_name;
    else
        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();
 
    pos.y += sb_gameinfo_type_fontsize.y;
    // Game Info: Game Detail
    if (scoreboard_ui_enabled == 2)
    {
        if (scoreboard_selected_team)
            str = sprintf(_("^7Press ^3%s^7 to join the selected team"), translate_key("SPACE"));
        else
            str = sprintf(_("^7Press ^3%s^7 to auto-select a team and join"), translate_key("SPACE"));
        drawcolorcodedstring(pos + '0.5 0 0' * (panel_size.x - stringwidth(str, true, sb_gameinfo_detail_fontsize)), str, sb_gameinfo_detail_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 
        pos.y += sb_gameinfo_detail_fontsize.y + hud_fontsize.y * 0.3;
        str = sprintf(_("^7Press ^3%s ^7to select a specific team"), translate_key("TAB"));
        drawcolorcodedstring(pos + '0.5 0 0' * (panel_size.x - stringwidth(str, true, sb_gameinfo_detail_fontsize)), str, sb_gameinfo_detail_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
    }
    else
    {
        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, "^3", count_minutes(floor(tl)));
        if (!gametype.m_hidelimits)
        {
            if (fl > 0)
            {
                if (tl > 0)
                    str = strcat(str, "^7 / "); // delimiter
                str = strcat(str, Scoreboard_Fraglimit_Draw(fl, false));
            }
            if (ll > 0 && (ll < fl || fl <= 0))
            {
                if (tl > 0 || fl > 0)
                {
                    // delimiter
                    if (ll_and_fl && fl > 0)
                        str = strcat(str, "^7 & ");
                    else
                        str = strcat(str, "^7 / ");
                }
                str = strcat(str, Scoreboard_Fraglimit_Draw(ll, true));
            }
        }
        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 and player count
        if (campaign)
            str = "";
        else
            str = sprintf(_("^5%d^7/^5%d ^7players"), numplayers, srv_maxplayers ? srv_maxplayers : maxclients);
        str = strcat("^7", _("Map:"), " ^2", mi_shortname, "    ", str); // reusing "Map:" translatable string
        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;
 
    entity tm;
    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;
        }
 
        vector str_pos;
        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 * 0.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);
    }
 
    // if the name column is too small, try to compress all other field titles
    if (sbt_field_size[name_field_index] < sbt_field_title_width[name_field_index] + hud_fontsize.x)
        sb_field_sizes_init = 2;
 
    // 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_speed_unit);
        float conversion_factor = GetSpeedUnitFactor(autocvar_hud_speed_unit);
        if (race_speedaward_alltimebest)
        {
            string name;
            float namesize = autocvar_hud_panel_scoreboard_namesize * hud_fontsize.x;
            str = "";
            if (race_speedaward)
            {
                name = textShortenToWidth(ColorTranslateRGB(race_speedaward_holder), namesize, hud_fontsize, stringwidth_colors);
                str = sprintf(_("Speed award: %d%s ^7(%s^7)"), race_speedaward * conversion_factor, unit, name);
                str = strcat(str, " / ");
            }
            name = textShortenToWidth(ColorTranslateRGB(race_speedaward_alltimebest_holder), namesize, hud_fontsize, stringwidth_colors);
            str = strcat(str, sprintf(_("All-time fastest: %d%s ^7(%s^7)"), race_speedaward_alltimebest * conversion_factor, unit, name));
            drawcolorcodedstring(pos, str, hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
            pos.y += 1.25 * hud_fontsize.y; // line height + line spacing
        }
        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 && 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;
    }
}

References autocvar__hud_configure, autocvar_con_notify, autocvar_con_notifysize, autocvar_hud_fontsize, autocvar_hud_panel_scoreboard_bg_teams_color_team, autocvar_hud_panel_scoreboard_dynamichud, autocvar_hud_panel_scoreboard_fadeinspeed, autocvar_hud_panel_scoreboard_fadeoutspeed, autocvar_hud_panel_scoreboard_minwidth, autocvar_hud_panel_scoreboard_namesize, autocvar_hud_panel_scoreboard_respawntime_decimals, autocvar_hud_panel_scoreboard_spectators_position, autocvar_hud_panel_scoreboard_table_bg_alpha, autocvar_hud_panel_scoreboard_table_bg_scale, autocvar_hud_panel_scoreboard_table_fg_alpha, autocvar_hud_panel_scoreboard_table_fg_alpha_self, autocvar_hud_panel_scoreboard_table_fieldtitle_maxwidth, autocvar_hud_panel_scoreboard_table_highlight, autocvar_hud_panel_scoreboard_table_highlight_alpha, autocvar_hud_panel_scoreboard_table_highlight_alpha_eliminated, autocvar_hud_panel_scoreboard_table_highlight_alpha_self, autocvar_hud_panel_scoreboard_team_size_position, autocvar_hud_speed_unit, bound(), campaign, ceil(), ColorTranslateRGB(), count_minutes, count_seconds, count_seconds_decs, draw_beginBoldFont, draw_endBoldFont, drawcolorcodedstring, drawfill, DRAWFLAG_NORMAL, drawstring, entity(), eX, eY, floor(), frametime, ftos(), gametype, gametype_custom_name, GET_NEXTMAP, getcommandkey, GetSpeedUnit(), GetSpeedUnitFactor(), hud_configure_menu_open, hud_draw_maximized, hud_fontsize, HUD_GetFontsize(), HUD_Panel_LoadCvars(), HUD_Scale_Disable(), HUD_Scale_Enable(), intermission, M_ARGV, MapInfo_Type_ToText(), max(), max_namesize, maxclients, mi_shortname, min(), MUTATOR_CALLHOOK, name, name_field_index, NUM_SPECTATOR, numplayers, panel, panel_bg_border, panel_bg_color, panel_bg_color_team, panel_fade_alpha, panel_fg_alpha, panel_pos, panel_size, player_localnum, playerslots, race_speedaward, race_speedaward_alltimebest, race_speedaward_alltimebest_holder, race_speedaward_holder, rankings_cnt, rankings_columns, RANKINGS_RECEIVED_CNT, rankings_rows, respawn_time, sb_field_sizes_init, sbt_bg_alpha, sbt_fg_alpha, sbt_fg_alpha_self, sbt_field_size, sbt_field_title_maxwidth, sbt_field_title_width, sbt_highlight, sbt_highlight_alpha, sbt_highlight_alpha_eliminated, sbt_highlight_alpha_self, scale, scoreboard_acc_fade_alpha, Scoreboard_AccuracyStats_Draw(), Scoreboard_AccuracyStats_WouldDraw(), scoreboard_active, scoreboard_bottom, scoreboard_fade_alpha, Scoreboard_Fraglimit_Draw(), Scoreboard_initFieldSizes(), Scoreboard_ItemStats_Draw(), scoreboard_itemstats_fade_alpha, Scoreboard_ItemStats_WouldDraw(), scoreboard_left, Scoreboard_MakeTable(), Scoreboard_MapStats_Draw(), Scoreboard_Rankings_Draw(), scoreboard_right, scoreboard_selected_team, Scoreboard_Spectators_Draw(), scoreboard_time, scoreboard_top, scoreboard_ui_enabled, Scoreboard_UpdatePlayerTeams(), srv_maxplayers, STAT, strcat(), strcpy, stringwidth, stringwidth_colors(), Team_ColorRGB(), teamplay, teams, textShortenToWidth(), time, translate_key(), ts_primary, ts_secondary, vec2, vector, vid_conheight, and vid_conwidth.

Scoreboard_InitScores()

void Scoreboard_InitScores

(

)

Definition at line 514 of file scoreboard.qc.

{
    ps_primary = ps_secondary = NULL;
    ts_primary = ts_secondary = -1;
 
    int f;
    FOREACH(Scores, !(scores_flags(it) & SFL_NOT_SORTABLE),
    {
        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_secondary == NULL)
        ps_secondary = ps_primary;
 
    for (int 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);
}

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

Referenced by NET_HANDLE().

Scoreboard_UI_Enable()

void Scoreboard_UI_Enable

(

int

mode

)

Definition at line 198 of file scoreboard.qc.

{
    if (isdemo())
        return;
 
    if (mode == 1)
    {
        if (scoreboard_ui_enabled == 2 || !teamplay || intermission)
            return;
 
        // release player's pressed keys as they aren't released elsewhere
        // in particular jump needs to be released as it may open the team selection
        // (when server detects jump has been pressed it sends the command to open the team selection)
        Release_Common_Keys();
        scoreboard_ui_enabled = 2;
        scoreboard_selected_panel = SB_PANEL_SCOREBOARD;
    }
    else
    {
        if (scoreboard_ui_enabled == 1)
            return;
        scoreboard_ui_enabled = 1;
        scoreboard_selected_panel = SB_PANEL_FIRST;
    }
    scoreboard_selected_player = NULL;
    scoreboard_selected_team = NULL;
    scoreboard_selected_panel_time = time;
}

References intermission, isdemo(), NULL, Release_Common_Keys(), SB_PANEL_FIRST, SB_PANEL_SCOREBOARD, scoreboard_selected_panel, scoreboard_selected_panel_time, scoreboard_selected_player, scoreboard_selected_team, scoreboard_ui_enabled, teamplay, and time.

Referenced by CSQC_InputEvent(), and CSQC_UpdateView().

Scoreboard_UpdatePlayerPos()

void Scoreboard_UpdatePlayerPos

(

entity

pl

)

Definition at line 656 of file scoreboard.qc.

{
    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);
}

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

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

Scoreboard_UpdatePlayerTeams()

void Scoreboard_UpdatePlayerTeams

(

)

Definition at line 546 of file scoreboard.qc.

{
    static float update_time;
    if (time <= update_time)
        return;
    update_time = time;
 
    numplayers = 0;
    //int num = 0;
    for (entity tmp, pl = players.sort_next; pl; pl = pl.sort_next)
    {
        numplayers += pl.team != NUM_SPECTATOR;
        //++num;
        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;
    */
 
    // update the smallest and largest team sizes
    if (!teamplay || !teams.sort_next)
        ts_min = ts_max = 0;
    else
    {
        ts_min = 255, ts_max = 0;
 
        for (entity tm = teams.sort_next; tm; tm = tm.sort_next)
        {
            if (tm.team == NUM_SPECTATOR)
                continue;
 
            if (ts_min > tm.team_size)
                ts_min = tm.team_size;
            if (ts_max < tm.team_size)
                ts_max = tm.team_size;
        }
    }
}

References entcs_GetScoreTeam(), entity(), NUM_SPECTATOR, numplayers, players, Scoreboard_UpdatePlayerPos(), SetTeam(), teamplay, teams, time, ts_max, and ts_min.

Referenced by Announcer_Duel(), HUD_InfoMessages(), HUD_Quickmenu_PlayerListEntries(), HUD_Score_Rankings(), HUD_Timer(), and Scoreboard_Draw().

Scoreboard_UpdateTeamPos()

void Scoreboard_UpdateTeamPos

(

entity

Team

)

Definition at line 702 of file scoreboard.qc.

{
    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);
}

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

Referenced by NET_HANDLE().

Scoreboard_WouldDraw()

bool Scoreboard_WouldDraw

(

)

Definition at line 1764 of file scoreboard.qc.

{
    if (scoreboard_ui_enabled)
    {
        if (scoreboard_ui_disabling)
        {
            if (scoreboard_fade_alpha == 0)
                HUD_Scoreboard_UI_Disable_Instantly();
            return false;
        }
        if (intermission && scoreboard_ui_enabled == 2)
        {
            HUD_Scoreboard_UI_Disable_Instantly();
            return false;
        }
        return true;
    }
    else if (MUTATOR_CALLHOOK(DrawScoreboard))
        return false;
    else if (QuickMenu_IsOpened())
        return false;
    else if (HUD_Radar_Clickable())
        return false;
    else if (sb_showscores) // set by +showscores engine command
        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)
        && time - CSQCModel_server2csqc(player_localentnum - 1).death_time >= autocvar_cl_deathscoreboard_delay
        && (!HUD_MinigameMenu_IsOpened() || !active_minigame))
    {
        return true;
    }
    else if (scoreboard_showscores_force || MUTATOR_CALLHOOK(DrawScoreboard_Force))
        return true;
    return false;
}

References active_minigame, autocvar_cl_deathscoreboard, autocvar_cl_deathscoreboard_delay, CSQCModel_server2csqc(), death_time, HUD_MinigameMenu_IsOpened(), HUD_Radar_Clickable(), HUD_Scoreboard_UI_Disable_Instantly(), intermission, MUTATOR_CALLHOOK, player_localentnum, QuickMenu_IsOpened(), sb_showscores, scoreboard_fade_alpha, scoreboard_showscores_force, scoreboard_ui_disabling, scoreboard_ui_enabled, spectatee_status, STAT, and time.

Referenced by CSQC_UpdateView().

Variable Documentation

autocvar__nextmap

string autocvar__nextmap

Definition at line 9 of file scoreboard.qh.

autocvar__scoreboard_team_selection

bool autocvar__scoreboard_team_selection

Definition at line 41 of file scoreboard.qh.

Referenced by CSQC_UpdateView().

autocvar_cl_deathscoreboard

bool autocvar_cl_deathscoreboard

Definition at line 4 of file scoreboard.qh.

Referenced by Scoreboard_WouldDraw().

autocvar_cl_deathscoreboard_delay

float autocvar_cl_deathscoreboard_delay = 1

Definition at line 5 of file scoreboard.qh.

Referenced by Scoreboard_WouldDraw().

autocvar_hud_panel_scoreboard_namesize

float autocvar_hud_panel_scoreboard_namesize = 15

Definition at line 7 of file scoreboard.qh.

Referenced by centerprint_SetDuelTitle(), Scoreboard_Draw(), Scoreboard_DrawOthers(), and Scoreboard_Rankings_Draw().

autocvar_scoreboard_columns

string autocvar_scoreboard_columns

Definition at line 6 of file scoreboard.qh.

Referenced by Cmd_Scoreboard_SetFields(), and HUD_Scoreboard_InputEvent().

ignored

bool ignored

Definition at line 29 of file scoreboard.qh.

numplayers

int numplayers

Definition at line 26 of file scoreboard.qh.

Referenced by HUD_InfoMessages(), HUD_Timer(), Invasion_RoundStart(), Scoreboard_Draw(), and Scoreboard_UpdatePlayerTeams().

SB_PANEL_FIRST

int SB_PANEL_FIRST = 1

Definition at line 51 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), and Scoreboard_UI_Enable().

SB_PANEL_MAX

int SB_PANEL_MAX = 2

Definition at line 54 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent().

SB_PANEL_RANKINGS

int SB_PANEL_RANKINGS = 2

Definition at line 53 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), and Scoreboard_Rankings_Draw().

SB_PANEL_SCOREBOARD

int SB_PANEL_SCOREBOARD = 1

Definition at line 52 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), Scoreboard_DrawItem(), Scoreboard_DrawOthers(), Scoreboard_MakeTable(), and Scoreboard_UI_Enable().

sb_showscores

bool sb_showscores

Definition at line 14 of file scoreboard.qh.

Referenced by HUD_Scoreboard_UI_Disable(), and Scoreboard_WouldDraw().

scoreboard_acc_fade_alpha

float scoreboard_acc_fade_alpha

Definition at line 18 of file scoreboard.qh.

Referenced by Scoreboard_AccuracyStats_Draw(), and Scoreboard_Draw().

scoreboard_active

bool scoreboard_active

Definition at line 16 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 22 of file scoreboard.qh.

Referenced by HUD_CenterPrint(), HUD_Notify(), and Scoreboard_Draw().

scoreboard_fade_alpha

float scoreboard_fade_alpha

Definition at line 17 of file scoreboard.qh.

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

scoreboard_itemstats_fade_alpha

float scoreboard_itemstats_fade_alpha

Definition at line 19 of file scoreboard.qh.

Referenced by Scoreboard_Draw(), and Scoreboard_ItemStats_Draw().

scoreboard_left

float scoreboard_left

Definition at line 23 of file scoreboard.qh.

Referenced by HUD_Notify(), Scoreboard_Draw(), Scoreboard_MakeTable(), and Scoreboard_Rankings_Draw().

scoreboard_right

float scoreboard_right

Definition at line 24 of file scoreboard.qh.

Referenced by HUD_Notify(), Scoreboard_Draw(), Scoreboard_MakeTable(), and Scoreboard_Rankings_Draw().

scoreboard_selected_columns_layout

int scoreboard_selected_columns_layout

Definition at line 48 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent().

scoreboard_selected_panel

int scoreboard_selected_panel

Definition at line 44 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), HUD_Scoreboard_UI_Disable_Instantly(), Scoreboard_DrawItem(), Scoreboard_DrawOthers(), Scoreboard_MakeTable(), Scoreboard_Rankings_Draw(), and Scoreboard_UI_Enable().

scoreboard_selected_panel_time

float scoreboard_selected_panel_time

Definition at line 45 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), Scoreboard_MakeTable(), Scoreboard_Rankings_Draw(), and Scoreboard_UI_Enable().

scoreboard_selected_player

entity scoreboard_selected_player

Definition at line 46 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), HUD_Scoreboard_UI_Disable_Instantly(), Scoreboard_DrawItem(), Scoreboard_DrawOthers(), and Scoreboard_UI_Enable().

scoreboard_selected_team

entity scoreboard_selected_team

Definition at line 47 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent(), HUD_Scoreboard_UI_Disable_Instantly(), Scoreboard_Draw(), Scoreboard_MakeTable(), and Scoreboard_UI_Enable().

scoreboard_top

float scoreboard_top

Definition at line 21 of file scoreboard.qh.

Referenced by HUD_Notify(), and Scoreboard_Draw().

scoreboard_ui_enabled

int scoreboard_ui_enabled

Definition at line 40 of file scoreboard.qh.

Referenced by HUD_QuickMenu_Forbidden(), HUD_Radar_Mouse(), HUD_Scoreboard_InputEvent(), HUD_Scoreboard_UI_Disable_Instantly(), Scoreboard_Draw(), Scoreboard_DrawItem(), Scoreboard_DrawOthers(), Scoreboard_MakeTable(), Scoreboard_UI_Enable(), and Scoreboard_WouldDraw().

ts_max

int ts_max

team size

Definition at line 27 of file scoreboard.qh.

Referenced by HUD_InfoMessages(), HUD_Timer(), Scoreboard_UpdatePlayerTeams(), and TeamBalance_SizeDifference().

ts_min

int ts_min

Definition at line 27 of file scoreboard.qh.

Referenced by HUD_InfoMessages(), HUD_Timer(), Scoreboard_UpdatePlayerTeams(), and TeamBalance_SizeDifference().