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_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
	player is ignored
int	numplayers
const int	SB_PANEL_FIRST = 1
const int	SB_PANEL_MAX = 2
const int	SB_PANEL_RANKINGS = 2
const int	SB_PANEL_SCOREBOARD = 1
bool	sb_showscores
	set by +showscores engine command
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
	maximum team size
int	ts_min
	minimum team size

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 774 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-dependent 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, 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 238 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(strcat("cmd join ", team_name, "\n"));
                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("scoreboard_columns_set\n"); // sets the layout saved in scoreboard_columns
                        scoreboard_selected_columns_layout = 1;
                        break;
                    }
                    // fallthrough
                case 1:
                    localcmd("scoreboard_columns_set default\n");
                    scoreboard_selected_columns_layout = 2;
                    break;
                case 2:
                    localcmd("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(strcat("commandmode tell \"", entcs_GetName(scoreboard_selected_player.sv_entnum), "^7\"\n"));
            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(strcat("vcall kick \"", entcs_GetName(scoreboard_selected_player.sv_entnum), "^7\"\n"));
    }
    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(), strcat(), teams, time, and tokenize().

Referenced by CSQC_InputEvent().

Scoreboard_InitScores()

void Scoreboard_InitScores

(

)

Definition at line 521 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 205 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 663 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 553 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: ", itos(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, ts_min, and update_time.

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 709 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 1874 of file scoreboard.qc.

{
    deathscoreboard = false;
    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))
    {
        if (gametype.m_1v1) // display all info if 1v1 even if dead - only 2 players, lots of room
            deathscoreboard = true;
        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, deathscoreboard, gametype, 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

player is ignored

Definition at line 30 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

const 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

const int SB_PANEL_MAX = 2

Definition at line 54 of file scoreboard.qh.

Referenced by HUD_Scoreboard_InputEvent().

SB_PANEL_RANKINGS

const 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

const 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

set by +showscores engine command

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

maximum team size

Definition at line 28 of file scoreboard.qh.

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

ts_min

int ts_min

minimum team size

Definition at line 27 of file scoreboard.qh.

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