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

Functions
void	Nagger_Init ()

void	ReadyCount ()

void	ReadyRestart_force (bool is_fake_round_start)

void	reset_map (float dorespawn, bool is_fake_round_start)

	STATIC_INIT (g_saved_team)

	void (entity this) reset

void	VoteCommand (int request, entity caller, int argc, string vote_command)

void	VoteCount (float first_count)

void	VoteReset ()

void	VoteThink ()

Variables
bool	autocvar_sv_vote_call

bool	autocvar_sv_vote_change

string	autocvar_sv_vote_commands

bool	autocvar_sv_vote_gamestart

int	autocvar_sv_vote_limit

float	autocvar_sv_vote_majority_factor

float	autocvar_sv_vote_majority_factor_of_voted

bool	autocvar_sv_vote_master

bool	autocvar_sv_vote_master_callable

string	autocvar_sv_vote_master_commands

string	autocvar_sv_vote_master_password

int	autocvar_sv_vote_master_playerlimit

bool	autocvar_sv_vote_no_stops_vote

int	autocvar_sv_vote_nospectators

bool	autocvar_sv_vote_override_mostrecent

bool	autocvar_sv_vote_singlecount

float	autocvar_sv_vote_stop

float	autocvar_sv_vote_timeout

float	autocvar_sv_vote_wait

IntrusiveList	g_saved_team

float	last_ready

entity	nagger

float	ready

float	readycount

const float	RESTART_COUNTDOWN = 10

int	team_saved

const float	VC_ASGNMNT_BOTH = 1

const float	VC_ASGNMNT_CLIENTONLY = 2

const float	VC_ASGNMNT_SERVERONLY = 3

float	vote_abstain_count

float	vote_accept_count

float	vote_called

string	vote_called_command

string	vote_called_display

entity	vote_caller

string	vote_caller_name

float	vote_endtime

const float	VOTE_MASTER = 2

float	vote_master

float	vote_needed_overall

const float	VOTE_NORMAL = 1

const float	VOTE_NULL = 0

string	vote_parsed_command

string	vote_parsed_display

float	vote_reject_count

const float	VOTE_SELECT_ABSTAIN = -2

const float	VOTE_SELECT_ACCEPT = 1

const float	VOTE_SELECT_NULL = 0

const float	VOTE_SELECT_REJECT = -1

float	vote_selection

float	vote_waittime

Function Documentation

◆ Nagger_Init()

void Nagger_Init ( )

Definition at line 97 of file vote.qc.

References nagger, Nagger_SendEntity(), and new_pure.

Referenced by spawnfunc().

 {
     Net_LinkEntity(nagger = new_pure(nagger), false, 0, Nagger_SendEntity);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadyCount()

void ReadyCount ( )

Definition at line 498 of file vote.qc.

References bound(), cvar(), floor(), FOREACH_CLIENT, INGAME_JOINED, IS_PLAYER, IS_REAL_CLIENT, Nagger_ReadyCounted(), readycount, and ReadyRestart().

Referenced by ClientCommand_ready(), ClientDisconnect(), and PutObserverInServer().

 {
     float ready_needed_factor, ready_needed_count;
     float t_ready = 0, t_players = 0;
 
     FOREACH_CLIENT(IS_REAL_CLIENT(it) && (IS_PLAYER(it) || INGAME_JOINED(it)), {
         ++t_players;
         if (it.ready) ++t_ready;
     });
 
     readycount = t_ready;
 
     Nagger_ReadyCounted();
 
     ready_needed_factor = bound(0.5, cvar("g_warmup_majority_factor"), 0.999);
     ready_needed_count = floor(t_players * ready_needed_factor) + 1;
 
     if (readycount >= ready_needed_count) ReadyRestart(true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadyRestart_force()

void ReadyRestart_force ( bool is_fake_round_start )

Definition at line 426 of file vote.qc.

References autocvar_sv_eventlog, autocvar_sv_timeout, autocvar_sv_timeout_number, autocvar_teamplay_lockonrestart, autocvar_timelimit_overtime, bprint(), checkrules_overtimesadded, checkrules_suddendeathend, checkrules_suddendeathwarning, CS(), cvar_set(), entity(), FOREACH_CLIENT, ftos(), g_race_qualifying, GameLogEcho(), IS_PLAYER, IS_REAL_CLIENT, localcmd, lockteams, Nagger_ReadyCounted(), new_pure, readycount, ReadyRestart_think(), reset_map(), RESTART_COUNTDOWN, setthink, sv_ready_restart_after_countdown, teamplay, time, VoteReset(), and warmup_stage.

Referenced by assault_new_round(), and ReadyRestart().

 {
     if (time <= game_starttime && game_stopped)
         return;
     if (!is_fake_round_start)
         bprint("^1Match is restarting...\n");
 
     VoteReset();
 
     // clear overtime, we have to decrease timelimit to its original value again.
     if (checkrules_overtimesadded > 0 && g_race_qualifying != 2)
         cvar_set("timelimit", ftos(autocvar_timelimit - (checkrules_overtimesadded * autocvar_timelimit_overtime)));
     checkrules_suddendeathend = checkrules_overtimesadded = checkrules_suddendeathwarning = overtimes = 0;
 
     if(warmup_stage)
         game_starttime = time; // Warmup: No countdown in warmup
     else
         game_starttime = time + RESTART_COUNTDOWN; // Go into match mode
 
     // clear player attributes
     FOREACH_CLIENT(IS_PLAYER(it), {
         it.alivetime = 0;
         CS(it).killcount = 0;
     });
 
     // if we're ending the warmup stage call the corresponding hook
     if(!is_fake_round_start && !warmup_stage)
         localcmd("\nsv_hook_warmupend\n");
 
     // reset the .ready status of all players (also spectators)
     FOREACH_CLIENT(IS_REAL_CLIENT(it), { it.ready = false; });
     readycount = 0;
     Nagger_ReadyCounted();  // NOTE: this causes a resend of that entity, and will also turn off warmup state on the client
 
     // lock teams with lockonrestart
     if (autocvar_teamplay_lockonrestart && teamplay)
         lockteams = !warmup_stage;
 
     // initiate the restart-countdown-announcer entity
     if (!is_fake_round_start && sv_ready_restart_after_countdown && !warmup_stage)
     {
         entity restart_timer = new_pure(restart_timer);
         setthink(restart_timer, ReadyRestart_think);
         restart_timer.nextthink = game_starttime;
     }
 
     // after a restart every players number of allowed timeouts gets reset, too
     if (autocvar_sv_timeout)
     {
         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), { CS(it).allowed_timeouts = autocvar_sv_timeout_number; });
     }
 
     if (!sv_ready_restart_after_countdown || warmup_stage)
         reset_map(true, is_fake_round_start);
 
     if (autocvar_sv_eventlog) GameLogEcho(":restart");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_map()

void reset_map	(	float	dorespawn,
		bool	is_fake_round_start
	)

◆ STATIC_INIT()

STATIC_INIT ( g_saved_team )

Definition at line 78 of file vote.qh.

References IL_NEW.

78 { g_saved_team = IL_NEW(); }

IL_NEW

#define IL_NEW()

Definition: intrusivelist.qh:39

g_saved_team

IntrusiveList g_saved_team

Definition: vote.qh:77

◆ void()

void ( entity this )

◆ VoteCommand()

void VoteCommand	(	int	request,
		entity	caller,
		int	argc,
		string	vote_command
	)

Definition at line 1264 of file vote.qc.

References argv(), CMD_REQUEST_COMMAND, CMD_REQUEST_USAGE, GetCommandPrefix(), print_to(), strcat(), VoteCommand_macro_command(), and VoteCommand_macro_help().

Referenced by COMMON_COMMAND().

 {
     // Guide for working with argc arguments by example:
     // argc:   1    - 2      - 3     - 4
     // argv:   0    - 1      - 2     - 3
     // cmd     vote - master - login - password
 
     switch (request)
     {
         case CMD_REQUEST_COMMAND:
         {
             if (VoteCommand_macro_command(caller, argc, vote_command)) return;
         }
 
         default:
             print_to(caller, strcat(((argv(1) != "") ? strcat("Unknown vote command \"", argv(1), "\"") : "No command provided"), ". For a list of supported commands, try ", GetCommandPrefix(caller), " vote help.\n"));
         case CMD_REQUEST_USAGE:
         {
             VoteCommand_macro_help(caller, argc);
             return;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VoteCount()

void VoteCount ( float first_count )

Definition at line 207 of file vote.qc.

References autocvar_sv_vote_majority_factor, autocvar_sv_vote_majority_factor_of_voted, autocvar_sv_vote_master_playerlimit, bound(), floor(), FOREACH_CLIENT, IS_CLIENT, IS_PLAYER, IS_REAL_CLIENT, min(), Nagger_VoteCountChanged(), print_to(), spectators_allowed, time, vote_abstain_count, vote_accept_count, vote_called, vote_caller, vote_endtime, VOTE_MASTER, vote_needed_overall, vote_reject_count, VOTE_SELECT_ABSTAIN, VOTE_SELECT_ACCEPT, VoteAccept(), VoteReject(), VoteReset(), VoteSpam(), and VoteTimeout().

Referenced by ClientDisconnect(), PutObserverInServer(), VoteCommand_abstain(), VoteCommand_call(), VoteCommand_master(), VoteCommand_no(), VoteCommand_yes(), and VoteThink().

 {
     // declarations
     vote_accept_count = vote_reject_count = vote_abstain_count = 0;
 
     float vote_player_count = 0, notvoters = 0;
     float vote_real_player_count = 0, vote_real_accept_count = 0;
     float vote_real_reject_count = 0, vote_real_abstain_count = 0;
     float vote_needed_of_voted, final_needed_votes;
     float vote_factor_overall, vote_factor_of_voted;
 
     Nagger_VoteCountChanged();
 
     // add up all the votes from each connected client
     FOREACH_CLIENT(IS_REAL_CLIENT(it) && IS_CLIENT(it), {
         ++vote_player_count;
         if (IS_PLAYER(it))   ++vote_real_player_count;
         switch (it.vote_selection)
         {
             case VOTE_SELECT_REJECT:
             { ++vote_reject_count;
               { if (IS_PLAYER(it)) ++vote_real_reject_count; } break;
             }
             case VOTE_SELECT_ACCEPT:
             { ++vote_accept_count;
               { if (IS_PLAYER(it)) ++vote_real_accept_count; } break;
             }
             case VOTE_SELECT_ABSTAIN:
             { ++vote_abstain_count;
               { if (IS_PLAYER(it)) ++vote_real_abstain_count; } break;
             }
             default: break;
         }
     });
 
     // Check to see if there are enough players on the server to allow master voting... otherwise, vote master could be used for evil.
     if ((vote_called == VOTE_MASTER) && autocvar_sv_vote_master_playerlimit > vote_player_count)
     {
         if (vote_caller)   vote_caller.vote_waittime = 0;
         print_to(vote_caller, "^1There are not enough players on this server to allow you to become vote master.");
         VoteReset();
         return;
     }
 
     // if spectators aren't allowed to vote and there are players in a match, then only count the players in the vote and ignore spectators.
     if (!spectators_allowed && (vote_real_player_count > 0))
     {
         vote_accept_count = vote_real_accept_count;
         vote_reject_count = vote_real_reject_count;
         vote_abstain_count = vote_real_abstain_count;
         vote_player_count = vote_real_player_count;
     }
 
     // people who have no opinion in any way :D
     notvoters = (vote_player_count - vote_accept_count - vote_reject_count - vote_abstain_count);
 
     // determine the goal for the vote to be passed or rejected normally
     vote_factor_overall = bound(0.5, autocvar_sv_vote_majority_factor, 0.999);
     vote_needed_overall = floor((vote_player_count - vote_abstain_count) * vote_factor_overall) + 1;
 
     // if the vote times out, determine the amount of votes needed of the people who actually already voted
     vote_factor_of_voted = bound(0.5, autocvar_sv_vote_majority_factor_of_voted, 0.999);
     vote_needed_of_voted = floor((vote_accept_count + vote_reject_count) * vote_factor_of_voted) + 1;
 
     // are there any players at all on the server? it could be an admin vote
     if (vote_player_count == 0 && first_count)
     {
         VoteSpam(0, -1, "yes");  // no players at all, just accept it
         VoteAccept();
         return;
     }
 
     // since there ARE players, finally calculate the result of the vote
     if (vote_accept_count >= vote_needed_overall)
     {
         VoteSpam(notvoters, -1, "yes");  // there is enough acceptions to pass the vote
         VoteAccept();
         return;
     }
 
     if (vote_reject_count > vote_player_count - vote_abstain_count - vote_needed_overall)
     {
         VoteSpam(notvoters, -1, "no");  // there is enough rejections to deny the vote
         VoteReject();
         return;
     }
 
     // there is not enough votes in either direction, now lets just calculate what the voters have said
     if (time > vote_endtime)
     {
         final_needed_votes = vote_needed_overall;
 
         if (autocvar_sv_vote_majority_factor_of_voted)
         {
             if (vote_accept_count >= vote_needed_of_voted)
             {
                 VoteSpam(notvoters, min(vote_needed_overall, vote_needed_of_voted), "yes");
                 VoteAccept();
                 return;
             }
 
             if (vote_accept_count + vote_reject_count > 0)
             {
                 VoteSpam(notvoters, min(vote_needed_overall, vote_needed_of_voted), "no");
                 VoteReject();
                 return;
             }
 
             final_needed_votes = min(vote_needed_overall, vote_needed_of_voted);
         }
 
         // it didn't pass or fail, so not enough votes to even make a decision.
         VoteSpam(notvoters, final_needed_votes, "timeout");
         VoteTimeout();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VoteReset()

void VoteReset ( )

Definition at line 128 of file vote.qc.

References FOREACH_CLIENT, Nagger_VoteChanged(), NULL, strfree, string_null, vote_called, vote_called_command, vote_called_display, vote_caller, vote_caller_name, vote_endtime, VOTE_NULL, vote_parsed_command, and vote_parsed_display.

Referenced by InitGameplayMode(), NextLevel(), ReadyRestart_force(), VoteAccept(), VoteCount(), VoteReject(), VoteStop(), and VoteTimeout().

 {
     FOREACH_CLIENT(true, { it.vote_selection = 0; });
 
     if (vote_called)
     {
         strfree(vote_called_command);
         strfree(vote_called_display);
         strfree(vote_caller_name);
     }
 
     vote_called = VOTE_NULL;
     vote_caller = NULL;
     vote_endtime = 0;
 
     vote_parsed_command = string_null;
     vote_parsed_display = string_null;
 
     Nagger_VoteChanged();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VoteThink()

void VoteThink ( )

Definition at line 324 of file vote.qc.

References time, vote_endtime, and VoteCount().

Referenced by CheckRules_World().

 {
     if (vote_endtime > 0)        // a vote was called
     {
         if (time > vote_endtime) // time is up
             VoteCount(false);
     }
 }