#include "mapvoting.qh"

Include dependency graph for sv_mapvoting.qh:

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

Macros
#define	autocvar_g_maplist cvar_string("g_maplist")
#define	autocvar_g_maplist_votable cvar("g_maplist_votable")

Functions
float	GameTypeVote_Finished (int pos)
string	GameTypeVote_MapInfo_FixName (string m)
bool	GameTypeVote_SetGametype (Gametype type, string gametype_string, bool call_hooks)
float	GameTypeVote_Start ()
void	MapVote_Start ()
void	MapVote_Think ()

Variables
bool	autocvar_g_maplist_check_waypoints
bool	autocvar_g_maplist_ignore_sizes
int	autocvar_g_maplist_index
string	autocvar_g_maplist_mostrecent
int	autocvar_g_maplist_mostrecent_count
bool	autocvar_g_maplist_selectrandom
float	autocvar_g_maplist_shuffle
bool	autocvar_g_maplist_sizes_count_bots = true
bool	autocvar_g_maplist_sizes_count_maxplayers = true
bool	autocvar_g_maplist_votable_abstain
int	autocvar_g_maplist_votable_detail
int	autocvar_g_maplist_votable_reduce_count
float	autocvar_g_maplist_votable_reduce_time
string	autocvar_g_maplist_votable_screenshot_dir
bool	autocvar_g_maplist_votable_show_suggester
bool	autocvar_g_maplist_votable_suggestions
bool	autocvar_g_maplist_votable_suggestions_override_mostrecent
float	autocvar_g_maplist_votable_timeout
int	autocvar_rescan_pending
bool	autocvar_sv_vote_gametype
bool	autocvar_sv_vote_gametype_default_current
int	autocvar_sv_vote_gametype_detail
bool	autocvar_sv_vote_gametype_maplist_reset = true
string	autocvar_sv_vote_gametype_options
int	autocvar_sv_vote_gametype_reduce_count
float	autocvar_sv_vote_gametype_reduce_time
float	autocvar_sv_vote_gametype_timeout
bool	gametypevote
string	getmapname_stored
int	mapvote
bool	mapvote_initialized
bool	mapvote_run
Gametype	match_gametype
string	mv_pakfile [MAPVOTE_COUNT]
	(maps) pk3 file location
int	mv_ranked [MAPVOTE_COUNT]
	(shared) maps/gametypes ranked by most votes, first = most
int	mv_reduce_count
float	mv_rng [MAPVOTE_COUNT]
	(shared) random() value for each map/gametype to determine tiebreakers
bool	mv_show_suggester
	(maps) whether to show suggesters, only for maps since you can't suggest gametypes
int	mv_ssdir_i [MAPVOTE_COUNT]
	(shared) where to look for screenshots (mv_ssdirs index), set to 0 for gametype voting
int	mv_suggestion_ptr
	(maps) index of where the next suggestion should be (starts as 0)
string	mv_suggestions [MAPVOTE_COUNT]
	(maps) name of the suggested map, later copied into mv_entries
int	mv_voters
	(shared) number of human voters present
float	mv_winner_time
Gametype	voted_gametype
string	voted_gametype_string

Macro Definition Documentation

◆ autocvar_g_maplist

#define autocvar_g_maplist cvar_string("g_maplist")

Definition at line 5 of file sv_mapvoting.qh.

Referenced by getmaplist(), and Maplist_Init().

◆ autocvar_g_maplist_votable

#define autocvar_g_maplist_votable cvar("g_maplist_votable")

Definition at line 12 of file sv_mapvoting.qh.

Referenced by MapVote_Init(), and MapVote_Think().

Function Documentation

◆ GameTypeVote_Finished()

float GameTypeVote_Finished ( int pos )

Definition at line 649 of file sv_mapvoting.qc.

{
    if (!gametypevote || gametypevote_finished)
        return false;
 
    match_gametype = MapInfo_CurrentGametype();
    voted_gametype = GameTypeVote_Type_FromString(mv_entries[pos]);
    strcpy(voted_gametype_string, mv_entries[pos]);
 
    GameTypeVote_SetGametype(voted_gametype, voted_gametype_string, true);
 
    // save to a cvar so it can be applied back when gametype is temporary
    // changed on gametype vote end of the next game
    if (mv_flags[pos] & GTV_CUSTOM)
        cvar_set("_sv_vote_gametype_custom", voted_gametype_string);
 
    gametypevote_finished = true;
    return true;
}

References cvar_set(), gametypevote, gametypevote_finished, GameTypeVote_SetGametype(), GameTypeVote_Type_FromString(), GTV_CUSTOM, MapInfo_CurrentGametype(), match_gametype, mv_entries, mv_flags, strcpy, voted_gametype, and voted_gametype_string.

Referenced by MapVote_Finished().

◆ GameTypeVote_MapInfo_FixName()

string GameTypeVote_MapInfo_FixName ( string m )

Definition at line 66 of file sv_mapvoting.qc.

{
    if (autocvar_sv_vote_gametype)
    {
        MapInfo_Enumerate();
        _MapInfo_FilterGametype(GameTypeVote_GetMask(), 0, MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags(), 0);
    }
    return MapInfo_FixName(m);
}

References _MapInfo_FilterGametype(), autocvar_sv_vote_gametype, GameTypeVote_GetMask(), MapInfo_Enumerate(), MapInfo_FixName(), MapInfo_ForbiddenFlags(), and MapInfo_RequiredFlags().

Referenced by DoNextMapOverride(), GotoMap(), and MapVote_Suggest().

◆ GameTypeVote_SetGametype()

bool GameTypeVote_SetGametype	(	Gametype	type,
		string	gametype_string,
		bool	call_hooks )

Definition at line 590 of file sv_mapvoting.qc.

{
    if (gametype_string == "")
        gametype_string = MapInfo_Type_ToString(type);
    if (!call_hooks)
        // custom gametype is disabled because gametype hooks can't be executed
        gametype_custom_enabled = false;
    else
    {
        gametype_custom_enabled = (gametype_string != MapInfo_Type_ToString(type));
 
        localcmd("\nsv_vote_gametype_hook_all\n");
        localcmd("\nsv_vote_gametype_hook_", gametype_string, "\n");
    }
 
    if (MapInfo_CurrentGametype() == type)
        return true;
 
    Gametype tsave = MapInfo_CurrentGametype();
 
    MapInfo_SwitchGameType(type);
 
    MapInfo_Enumerate();
    MapInfo_FilterGametype(type, MapInfo_CurrentFeatures(), MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags(), 0);
    if (MapInfo_count > 0)
    {
        // update lsmaps in case the gametype changed, this way people can easily list maps for it
        if (lsmaps_reply != "")
            strunzone(lsmaps_reply);
        lsmaps_reply = strzone(getlsmaps());
 
        if (!match_gametype) // don't show this msg if we are temporarily switching gametype
            bprint("Gametype successfully switched to ", MapInfo_Type_ToString(type), "\n");
    }
    else
    {
        bprint("Cannot use this gametype: no map for it found\n");
        MapInfo_SwitchGameType(tsave);
        MapInfo_FilterGametype(MapInfo_CurrentGametype(), MapInfo_CurrentFeatures(), MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags(), 0);
        return false;
    }
 
    bool do_reset = autocvar_sv_vote_gametype_maplist_reset;
    string gvmaplist = strcat("sv_vote_gametype_", gametype_string, "_maplist");
    if (cvar_type(gvmaplist) & CVAR_TYPEFLAG_EXISTS)
    {
        // force a reset if the provided list is empty
        if (cvar_string(gvmaplist) == "")
            do_reset = true;
        else
            cvar_set("g_maplist", cvar_string(gvmaplist));
    }
    if (do_reset)
        cvar_set("g_maplist", MapInfo_ListAllowedMaps(type, MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags()));
 
    return true;
}

References autocvar_sv_vote_gametype_maplist_reset, bprint(), cvar_set(), cvar_string(), CVAR_TYPEFLAG_EXISTS, gametype_custom_enabled, getlsmaps(), localcmd(), lsmaps_reply, MapInfo_count, MapInfo_CurrentFeatures(), MapInfo_CurrentGametype(), MapInfo_Enumerate(), MapInfo_FilterGametype(), MapInfo_ForbiddenFlags(), MapInfo_ListAllowedMaps(), MapInfo_RequiredFlags(), MapInfo_SwitchGameType(), MapInfo_Type_ToString(), match_gametype, strcat(), strunzone(), and strzone().

Referenced by GameCommand_gametype(), GameTypeVote_Finished(), MapVote_Init(), and MapVote_Think().

◆ GameTypeVote_Start()

float GameTypeVote_Start ( )

Definition at line 687 of file sv_mapvoting.qc.

{
    MapVote_ClearAllVotes();
    MapVote_UnzoneStrings();
 
    mv_count = 0;
    mv_timeout = time + autocvar_sv_vote_gametype_timeout;
    mv_abstain = false;
    mv_detail = autocvar_sv_vote_gametype_detail;
 
    int n = tokenizebyseparator(autocvar_sv_vote_gametype_options, " ");
    n = min(MAPVOTE_COUNT, n);
 
    int really_available = 0;
    int which_available = -1;
    int i;
    for (i = 0; i < n; ++i)
        if (GameTypeVote_AddVotable(argv(i))
        && (mv_flags[i] & GTV_AVAILABLE))
        {
            ++really_available;
            which_available = i;
        }
 
    mv_count_real = mv_count;
 
    gametypevote = true;
 
    const string current_gametype_string = (gametype_custom_enabled)
        ? loaded_gametype_custom_string
        : MapInfo_Type_ToString(MapInfo_CurrentGametype());
 
    if (really_available == 0)
    {
        if (mv_count > 0)
            strunzone(mv_entries[0]);
        mv_entries[0] = strzone(current_gametype_string);
        current_gametype_index = 0;
        //GameTypeVote_Finished(0);
        MapVote_Finished(current_gametype_index);
        return false;
    }
    if (really_available == 1)
    {
        current_gametype_index = which_available;
        //GameTypeVote_Finished(which_available);
        MapVote_Finished(current_gametype_index);
        return false;
    }
    current_gametype_index = -1;
    if (autocvar_sv_vote_gametype_default_current) // find current gametype index
        for (i = 0; i < mv_count_real; ++i)
            if (mv_entries[i] == current_gametype_string)
            {
                current_gametype_index = i;
                break;
            }
 
    mv_count_real = mv_count;
 
    mv_reduce_time = time + autocvar_sv_vote_gametype_reduce_time;
    mv_reduce_count = autocvar_sv_vote_gametype_reduce_count;
    if (mv_count_real < 3 || mv_reduce_time <= time)
        mv_reduce_time = 0;
 
    MapVote_Spawn();
    return true;
}

References argv(), autocvar_sv_vote_gametype_default_current, autocvar_sv_vote_gametype_detail, autocvar_sv_vote_gametype_options, autocvar_sv_vote_gametype_reduce_count, autocvar_sv_vote_gametype_reduce_time, autocvar_sv_vote_gametype_timeout, current_gametype_index, gametype_custom_enabled, gametypevote, GameTypeVote_AddVotable(), GTV_AVAILABLE, loaded_gametype_custom_string, MapInfo_CurrentGametype(), MapInfo_Type_ToString(), MapVote_ClearAllVotes(), MAPVOTE_COUNT, MapVote_Finished(), MapVote_Spawn(), MapVote_UnzoneStrings(), min(), mv_abstain, mv_count, mv_count_real, mv_detail, mv_entries, mv_flags, mv_reduce_count, mv_reduce_time, mv_timeout, strunzone(), strzone(), time, and tokenizebyseparator.

Referenced by MapVote_Think().

◆ MapVote_Start()

void MapVote_Start ( )

Definition at line 506 of file sv_mapvoting.qc.

{
    // if mapvote is already running, don't do this initialization again
    if (mapvote_run)
        return;
 
    // don't start mapvote until after playerstats gamereport is sent
    if (PlayerStats_GameReport_DelayMapVote)
        return;
 
    MapInfo_Enumerate();
    if (MapInfo_FilterGametype(MapInfo_CurrentGametype(), MapInfo_CurrentFeatures(), MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags(), 1))
        mapvote_run = true;
}

References MapInfo_CurrentFeatures(), MapInfo_CurrentGametype(), MapInfo_Enumerate(), MapInfo_FilterGametype(), MapInfo_ForbiddenFlags(), MapInfo_RequiredFlags(), mapvote_run, and PlayerStats_GameReport_DelayMapVote.

Referenced by CheckRules_World(), and IntermissionThink().

◆ MapVote_Think()

void MapVote_Think ( )

Definition at line 521 of file sv_mapvoting.qc.

{
    // no think delay, so that impulses (votes) are checked every frame
 
    if (!mapvote_run)
        return;
 
    if (mv_winner_time)
    {
        if (time > mv_winner_time + 1)
        {
            if (voted_gametype)
            {
                // clear match_gametype so that GameTypeVote_SetGametype
                // prints the gametype switch message
                match_gametype = NULL;
                GameTypeVote_SetGametype(voted_gametype, voted_gametype_string, true);
            }
 
            Map_Goto_SetStr(mv_entries[mv_winner]);
            Map_Goto(0);
            strfree(voted_gametype_string);
        }
        return;
    }
 
    if (alreadychangedlevel)
        return;
 
    if (!mapvote_initialized)
    {
        if (autocvar_rescan_pending == 1)
        {
            cvar_set("rescan_pending", "2");
            localcmd("\nfs_rescan\nrescan_pending 3\n");
            return;
        }
        else if (autocvar_rescan_pending == 2)
            return;
        else if (autocvar_rescan_pending == 3)
        {
            // now build missing mapinfo files
            if (!MapInfo_FilterGametype(MapInfo_CurrentGametype(), MapInfo_CurrentFeatures(), MapInfo_RequiredFlags(), MapInfo_ForbiddenFlags(), 1))
                return;
 
            // we're done, start the timer
            cvar_set("rescan_pending", "0");
        }
 
        mapvote_initialized = true;
        if (DoNextMapOverride(0))
            return;
        if (!autocvar_g_maplist_votable || player_count <= 0)
        {
            GotoNextMap(0);
            return;
        }
 
        if (autocvar_sv_vote_gametype)
            GameTypeVote_Start();
        else if (get_nextmap() == "")
            MapVote_Init();
    }
 
    MapVote_Tick();
}