#include <common/weapons/_all.qh>

Include dependency graph for world.qh:

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

Macros
#define	autocvar_g_weaponarena cvar_string("g_weaponarena")
#define	WARMUP_START_WEAPONS ((autocvar_g_warmup_allguns == 1) ? (warmup_start_weapons & (weaponsInMap \| start_weapons)) : warmup_start_weapons)

Functions
void	CheckRules_World ()
void	DropToFloor_QC_DelayedInit (entity this)
void	DumpStats (float final)
void	InitializeEntitiesRun ()
void	InitializeEntity (entity e, void(entity this) func, int order)
void	MatchEnd_RestoreSpectatorAndTeamStatus (.int prev_team_field)
void	MatchEnd_RestoreSpectatorStatus ()
bool	MoveToRandomLocationWithinBounds (entity e, vector boundmin, vector boundmax, float goodcontents, float badcontents, float badsurfaceflags, int attempts, float maxaboveground, float minviewdistance, bool frompos)
float	MoveToRandomMapLocation (entity e, float goodcontents, float badcontents, float badsurfaceflags, float attempts, float maxaboveground, float minviewdistance)
void	readlevelcvars ()
void	readplayerstartcvars ()
void	ReadyRestart (bool forceWarmupEnd)
float	RedirectionThink ()
void	SetWinners (.float field, float value)
	STATIC_INIT (g_moveables)
	void (entity this) initialize_entity
int	want_weapon (entity weaponinfo, int allguns)
float	WinningCondition_Scores (float limit, float leadlimit)

Variables
bool	autocvar__endmatch
bool	autocvar__sv_init
string	autocvar__sv_vote_gametype_custom
bool	autocvar_g_jetpack
string	autocvar_g_random_start_weapons
	Holds a list of possible random start weapons.
bool	autocvar_g_use_ammunition
int	autocvar_g_warmup
int	autocvar_g_warmup_allguns
bool	autocvar_g_warmup_allow_timeout
string	autocvar_quit_and_redirect
float	autocvar_quit_and_redirect_timer
bool	autocvar_quit_when_empty
string	autocvar_sessionid
bool	autocvar_sv_curl_serverpackages_auto
bool	autocvar_sv_db_saveasdump
bool	autocvar_sv_dedicated
bool	autocvar_sv_logscores_bots
bool	autocvar_sv_logscores_console
bool	autocvar_sv_logscores_file
string	autocvar_sv_logscores_filename
float	autocvar_sv_mapchange_delay
bool	autocvar_sv_mapformat_is_quake2
bool	autocvar_sv_mapformat_is_quake3
string	autocvar_sv_termsofservice_url
float	autocvar_timelimit_decrement
float	autocvar_timelimit_increment
float	autocvar_timelimit_max
float	autocvar_timelimit_min
float	autocvar_timelimit_overtime
int	autocvar_timelimit_overtimes
float	autocvar_timelimit_suddendeath
string	cache_lastmutatormsg
string	cache_mutatormsg
float	checkrules_equality
int	checkrules_overtimesadded
float	checkrules_suddendeathend
float	checkrules_suddendeathwarning
string	clientstuff
string	cvar_changes
string	cvar_purechanges
float	cvar_purechanges_count
float	default_player_alpha
float	default_weapon_alpha
vector	dropped_origin
string	fog
float	g_grappling_hook
IntrusiveList	g_moveables
float	g_weapon_stay
float	g_weaponarena_random
int	g_weaponarena_type
WepSet	g_weaponarena_weapons
bool	gametype_custom_enabled
entity	initialize_entity_first
entity	initialize_entity_next
int	initialize_entity_order
string	loaded_gametype_custom_string
string	matchid
string	modname
bool	observe_blocked_if_eliminated = false
entity	random_start_ammo
	Entity that contains amount of ammo to give with random start weapons.
int	random_start_weapons_count
	Number of random start weapons to give to players.
string	record_type
string	redirection_target
float	ServerProgsDB
float	start_ammo_cells
float	start_ammo_fuel
float	start_ammo_nails
float	start_ammo_rockets
float	start_ammo_shells
float	start_armorvalue
float	start_health
int	start_items
WepSet	start_weapons
WepSet	start_weapons_default
WepSet	start_weapons_defaultmask
bool	sv_ready_restart_after_countdown
string	sv_termsofservice_url_escaped
float	TemporaryDB
int	warmup_stage
float	warmup_start_ammo_cells
float	warmup_start_ammo_fuel
float	warmup_start_ammo_nails
float	warmup_start_ammo_rockets
float	warmup_start_ammo_shells
float	warmup_start_armorvalue
float	warmup_start_health
WepSet	warmup_start_weapons
WepSet	warmup_start_weapons_default
WepSet	warmup_start_weapons_defaultmask
float	winning
const int	WINNING_NEVER = 2
const int	WINNING_NO = 0
const int	WINNING_STARTSUDDENDEATHOVERTIME = 3
const int	WINNING_YES = 1
int	world_initialized

Macro Definition Documentation

◆ autocvar_g_weaponarena

#define autocvar_g_weaponarena cvar_string("g_weaponarena")

Definition at line 12 of file world.qh.

Referenced by GameLogInit().

◆ WARMUP_START_WEAPONS

#define WARMUP_START_WEAPONS ((autocvar_g_warmup_allguns == 1) ? (warmup_start_weapons & (weaponsInMap | start_weapons)) : warmup_start_weapons)

Definition at line 100 of file world.qh.

Referenced by GiveWarmupResources(), and MUTATOR_HOOKFUNCTION().

Function Documentation

◆ CheckRules_World()

void CheckRules_World ( )

Definition at line 1733 of file world.qc.

{
    VoteThink();
    MapVote_Think();
 
    SetDefaultAlpha();
 
    if (intermission_running) // someone else quit the game already
    {
        if(player_count == 0) // Nobody there? Then let's go to the next map
            MapVote_Start();
            // this will actually check the player count in the next frame
            // again, but this shouldn't hurt
        return;
    }
 
    float timelimit = autocvar_timelimit * 60;
    float fraglimit = autocvar_fraglimit;
    float leadlimit = autocvar_leadlimit;
    if (leadlimit < 0) leadlimit = 0;
 
    if(warmup_stage || time <= game_starttime) // NOTE: this is <= to prevent problems in the very tic where the game starts
    {
        if(timelimit > 0)
            timelimit = 0; // timelimit is not made for warmup
        if(fraglimit > 0)
            fraglimit = 0; // no fraglimit for now
        leadlimit = 0; // no leadlimit for now
    }
 
    if (autocvar__endmatch || timelimit < 0)
    {
        // endmatch
        NextLevel();
        return;
    }
 
    if(timelimit > 0)
        timelimit += game_starttime;
 
    int overtimes_prev = overtimes;
    int wantovertime = 0;
 
    if(checkrules_suddendeathend)
    {
        if(!checkrules_suddendeathwarning)
        {
            checkrules_suddendeathwarning = true;
            if(g_race && !g_race_qualifying)
                Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_RACE_FINISHLAP);
            else
                Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_OVERTIME_FRAG);
        }
    }
    else
    {
        if (timelimit && time >= timelimit)
        {
            if(g_race && (g_race_qualifying == 2) && timelimit > 0)
            {
                float totalplayers;
                float playerswithlaps;
                float readyplayers;
                totalplayers = playerswithlaps = readyplayers = 0;
                FOREACH_CLIENT(IS_PLAYER(it), {
                    ++totalplayers;
                    if(GameRules_scoring_add(it, RACE_FASTEST, 0))
                        ++playerswithlaps;
                    if(it.ready)
                        ++readyplayers;
                });
 
                // at least 2 of the players have completed a lap: start the RACE
                // otherwise, the players should end the qualifying on their own
                if(readyplayers || playerswithlaps >= 2)
                {
                    checkrules_suddendeathend = 0;
                    ReadyRestart(true); // go to race
                    return;
                }
                else
                    wantovertime |= InitiateSuddenDeath();
            }
            else
                wantovertime |= InitiateSuddenDeath();
        }
    }
 
    if (checkrules_suddendeathend && time >= checkrules_suddendeathend)
    {
        NextLevel();
        return;
    }
 
    int checkrules_status = WinningCondition_RanOutOfSpawns();
    if(checkrules_status == WINNING_YES)
        bprint("Hey! Someone ran out of spawns!\n");
    else if(MUTATOR_CALLHOOK(CheckRules_World, checkrules_status, timelimit, fraglimit))
        checkrules_status = M_ARGV(0, float);
    else
        checkrules_status = WinningCondition_Scores(fraglimit, leadlimit);
 
    if(checkrules_status == WINNING_STARTSUDDENDEATHOVERTIME)
    {
        checkrules_status = WINNING_NEVER;
        checkrules_overtimesadded = -1;
        wantovertime |= InitiateSuddenDeath();
    }
 
    if(checkrules_status == WINNING_NEVER)
        // equality cases! Nobody wins if the overtime ends in a draw.
        ClearWinners();
 
    if(wantovertime)
    {
        if(checkrules_status == WINNING_NEVER)
            InitiateOvertime();
        else
            checkrules_status = WINNING_YES;
    }
 
    if(checkrules_suddendeathend)
        if(checkrules_status != WINNING_NEVER || time >= checkrules_suddendeathend)
            checkrules_status = WINNING_YES;
 
    if(checkrules_status == WINNING_YES)
    {
        if (overtimes == OVERTIME_SUDDENDEATH && overtimes != overtimes_prev)
        {
            // if suddendeathend overtime has just begun, revert it
            checkrules_suddendeathend = 0;
            overtimes = overtimes_prev;
        }
        //print("WINNING\n");
        NextLevel();
    }
}

References autocvar__endmatch, autocvar_fraglimit, autocvar_leadlimit, autocvar_timelimit, bprint(), checkrules_overtimesadded, checkrules_suddendeathend, checkrules_suddendeathwarning, CheckRules_World(), ClearWinners(), FOREACH_CLIENT, g_race, g_race_qualifying, game_starttime, GameRules_scoring_add, InitiateOvertime(), InitiateSuddenDeath(), intermission_running, IS_PLAYER, M_ARGV, MapVote_Start(), MapVote_Think(), MUTATOR_CALLHOOK, NextLevel(), NULL, OVERTIME_SUDDENDEATH, overtimes, player_count, ReadyRestart(), Send_Notification(), SetDefaultAlpha(), time, VoteThink(), warmup_stage, WINNING_NEVER, WINNING_STARTSUDDENDEATHOVERTIME, WINNING_YES, WinningCondition_RanOutOfSpawns(), and WinningCondition_Scores().

Referenced by CheckRules_World(), MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and StartFrame().

◆ DropToFloor_QC_DelayedInit()

void DropToFloor_QC_DelayedInit ( entity this )

Definition at line 2399 of file world.qc.

{
    InitializeEntity(this, DropToFloor_QC, INITPRIO_DROPTOFLOOR);
}

References DropToFloor_QC(), entity(), InitializeEntity(), and INITPRIO_DROPTOFLOOR.

Referenced by ctf_FlagSetup(), dom_controlpoint_setup(), MUTATOR_HOOKFUNCTION(), ons_ControlPoint_Setup(), ons_GeneratorSetup(), spawn_item_key(), StartItem(), and turret_initialize().

◆ DumpStats()

void DumpStats ( float final )

Definition at line 1272 of file world.qc.

{
    float file;
    string s;
    float to_console;
    float to_eventlog;
    float to_file;
    float i;
 
    to_console = autocvar_sv_logscores_console;
    to_eventlog = autocvar_sv_eventlog;
    to_file = autocvar_sv_logscores_file;
 
    if(!final)
    {
        to_console = true; // always print printstats replies
        to_eventlog = false; // but never print them to the event log
    }
 
    if(to_eventlog)
        if(autocvar_sv_eventlog_console)
            to_console = false; // otherwise we get the output twice
 
    if(final)
        s = ":scores:";
    else
        s = ":status:";
    s = strcat(s, GetGametype(), "_", GetMapname(), ":", ftos(rint(time)));
 
    if(to_console)
        LOG_HELP(s);
    if(to_eventlog)
        GameLogEcho(s);
 
    file = -1;
    if(to_file)
    {
        file = fopen(autocvar_sv_logscores_filename, FILE_APPEND);
        if(file == -1)
            to_file = false;
        else
            fputs(file, strcat(s, "\n"));
    }
 
    s = strcat(":labels:player:", GetPlayerScoreString(NULL, 0));
    if(to_console)
        LOG_HELP(s);
    if(to_eventlog)
        GameLogEcho(s);
    if(to_file)
        fputs(file, strcat(s, "\n"));
 
    FOREACH_CLIENT(IS_REAL_CLIENT(it) || (IS_BOT_CLIENT(it) && autocvar_sv_logscores_bots), {
        s = strcat(":player:see-labels:", GetPlayerScoreString(it, 0), ":");
        s = strcat(s, ftos(rint(time - CS(it).jointime)), ":");
        if(IS_PLAYER(it) || INGAME_JOINED(it))
            s = strcat(s, ftos(it.team), ":");
        else
            s = strcat(s, "spectator:");
 
        if(to_console)
            LOG_HELP(s, playername(it.netname, it.team, false));
        if(to_eventlog)
            GameLogEcho(strcat(s, ftos(it.playerid), ":", playername(it.netname, it.team, false)));
        if(to_file)
            fputs(file, strcat(s, playername(it.netname, it.team, false), "\n"));
    });
 
    if(teamplay)
    {
        s = strcat(":labels:teamscores:", GetTeamScoreString(0, 0));
        if(to_console)
            LOG_HELP(s);
        if(to_eventlog)
            GameLogEcho(s);
        if(to_file)
            fputs(file, strcat(s, "\n"));
 
        for(i = 1; i < 16; ++i)
        {
            s = strcat(":teamscores:see-labels:", GetTeamScoreString(i, 0));
            s = strcat(s, ":", ftos(i));
            if(to_console)
                LOG_HELP(s);
            if(to_eventlog)
                GameLogEcho(s);
            if(to_file)
                fputs(file, strcat(s, "\n"));
        }
    }
 
    if(to_console)
        LOG_HELP(":end");
    if(to_eventlog)
        GameLogEcho(":end");
    if(to_file)
    {
        fputs(file, ":end\n");
        fclose(file);
    }
}

References autocvar_sv_eventlog, autocvar_sv_eventlog_console, autocvar_sv_logscores_bots, autocvar_sv_logscores_console, autocvar_sv_logscores_file, autocvar_sv_logscores_filename, CS(), fclose(), FILE_APPEND, fopen(), FOREACH_CLIENT, fputs(), ftos(), GameLogEcho(), GetGametype(), GetMapname(), GetPlayerScoreString(), GetTeamScoreString(), INGAME_JOINED, IS_BOT_CLIENT, IS_PLAYER, IS_REAL_CLIENT, jointime, LOG_HELP, NULL, playername(), rint(), strcat(), teamplay, and time.

Referenced by GameCommand_printstats(), and NextLevel().

◆ InitializeEntitiesRun()

void InitializeEntitiesRun ( )

Definition at line 2234 of file world.qc.

{
    entity startoflist = initialize_entity_first;
    initialize_entity_first = NULL;
    delete_fn = remove_except_protected;
    for (entity e = startoflist; e; e = e.initialize_entity_next)
    {
        e.remove_except_protected_forbidden = 1;
    }
    for (entity e = startoflist; e; )
    {
        e.remove_except_protected_forbidden = 0;
        e.initialize_entity_order = 0;
        entity next = e.initialize_entity_next;
        e.initialize_entity_next = NULL;
        var void(entity this) func = e.initialize_entity;
        e.initialize_entity = func_null;
        if (e.classname == "initialize_entity")
        {
            entity wrappee = e.enemy;
            builtin_remove(e);
            e = wrappee;
        }
        //dprint("Delayed initialization: ", e.classname, "\n");
        if (func)
        {
            func(e);
        }
        else
        {
            eprint(e);
            backtrace(strcat("Null function in: ", e.classname, "\n"));
        }
        e = next;
    }
    delete_fn = remove_unsafely;
}

References backtrace, delete_fn(), entity(), eprint(), func_null(), initialize_entity_first, next, NULL, remove_except_protected(), remove_unsafely(), strcat(), and void.

Referenced by StartFrame().

◆ InitializeEntity()

void InitializeEntity	(	entity	e,
		void(entity this)	func,
		int	order )

Definition at line 2201 of file world.qc.

{
    entity prev, cur;
 
    if (!e || e.initialize_entity)
    {
        // make a proxy initializer entity
        entity e_old = e;
        e = new(initialize_entity);
        e.enemy = e_old;
    }
 
    e.initialize_entity = func;
    e.initialize_entity_order = order;
 
    cur = initialize_entity_first;
    prev = NULL;
    for (;;)
    {
        if (!cur || cur.initialize_entity_order > order)
        {
            // insert between prev and cur
            if (prev)
                prev.initialize_entity_next = e;
            else
                initialize_entity_first = e;
            e.initialize_entity_next = cur;
            return;
        }
        prev = cur;
        cur = cur.initialize_entity_next;
    }
}

References entity(), initialize_entity_first, NULL, and prev.

◆ MatchEnd_RestoreSpectatorAndTeamStatus()

void MatchEnd_RestoreSpectatorAndTeamStatus ( .int prev_team_field )

Definition at line 1378 of file world.qc.

{
    bool fix_team = (teamplay && prev_team_field != team);
    FOREACH_CLIENT(true,
    {
        if (!IS_PLAYER(it) && INGAME_JOINING(it))
        {
            INGAME_STATUS_CLEAR(it);
            PutObserverInServer(it, true, false);
            bprint(playername(it.netname, it.team, false), " has been moved back to spectator\n");
            it.winning = false;
        }
        else if (fix_team && INGAME_JOINED(it) && it.(prev_team_field) && it.team != it.(prev_team_field))
        {
            Player_SetForcedTeamIndex(it, TEAM_FORCE_DEFAULT);
            if (MoveToTeam(it, Team_TeamToIndex(it.(prev_team_field)), 6))
            {
                string pl_name = playername(it.netname, it.team, false);
                bprint(pl_name, " has been moved back to the ", Team_ColoredFullName(it.team), "\n");
            }
            it.winning = (it.team == WinningConditionHelper_winnerteam);
        }
    });
}

References bprint(), FOREACH_CLIENT, INGAME_JOINED, INGAME_JOINING, INGAME_STATUS_CLEAR, IS_PLAYER, MoveToTeam(), Player_SetForcedTeamIndex(), playername(), PutObserverInServer(), team, Team_ColoredFullName, TEAM_FORCE_DEFAULT, Team_TeamToIndex(), teamplay, and WinningConditionHelper_winnerteam.

Referenced by MatchEnd_RestoreSpectatorStatus(), and MUTATOR_HOOKFUNCTION().

◆ MatchEnd_RestoreSpectatorStatus()

void MatchEnd_RestoreSpectatorStatus ( )

Definition at line 1403 of file world.qc.

{
    MatchEnd_RestoreSpectatorAndTeamStatus(team);
}

References MatchEnd_RestoreSpectatorAndTeamStatus(), and team.

Referenced by MUTATOR_HOOKFUNCTION().

◆ MoveToRandomLocationWithinBounds()

bool MoveToRandomLocationWithinBounds	(	entity	e,
		vector	boundmin,
		vector	boundmax,
		float	goodcontents,
		float	badcontents,
		float	badsurfaceflags,
		int	attempts,
		float	maxaboveground,
		float	minviewdistance,
		bool	frompos )

Definition at line 1125 of file world.qc.

{
    float m = e.dphitcontentsmask;
    e.dphitcontentsmask = goodcontents | badcontents;
 
    vector org = boundmin;
    vector delta = boundmax - boundmin;
 
    vector start, end;
    start = end = org;
    int j; // used after the loop
    for(j = 0; j < attempts; ++j)
    {
        start.x = org.x + random() * delta.x;
        start.y = org.y + random() * delta.y;
        start.z = org.z + random() * delta.z;
 
        // rule 1: start inside world bounds, and outside
        // solid, and don't start from somewhere where you can
        // fall down to evil
        tracebox(start, e.mins, e.maxs, start - '0 0 1' * delta.z, MOVE_NORMAL, e);
        if (trace_fraction >= 1)
            continue;
        if (trace_startsolid)
            continue;
        if (trace_dphitcontents & badcontents)
            continue;
        if (trace_dphitq3surfaceflags & badsurfaceflags)
            continue;
 
        // rule 2: if we are too high, lower the point
        if (trace_fraction * delta.z > maxaboveground)
            start = trace_endpos + '0 0 1' * maxaboveground;
        vector enddown = trace_endpos;
 
        // rule 3: make sure we aren't outside the map. This only works
        // for somewhat well formed maps. A good rule of thumb is that
        // the map should have a convex outside hull.
        // these can be traceLINES as we already verified the starting box
        vector mstart = start + 0.5 * (e.mins + e.maxs);
        traceline(mstart, mstart + '1 0 0' * delta.x, MOVE_NORMAL, e);
        if (trace_fraction >= 1 || trace_dphittexturename == "common/caulk")
            continue;
        traceline(mstart, mstart - '1 0 0' * delta.x, MOVE_NORMAL, e);
        if (trace_fraction >= 1 || trace_dphittexturename == "common/caulk")
            continue;
        traceline(mstart, mstart + '0 1 0' * delta.y, MOVE_NORMAL, e);
        if (trace_fraction >= 1 || trace_dphittexturename == "common/caulk")
            continue;
        traceline(mstart, mstart - '0 1 0' * delta.y, MOVE_NORMAL, e);
        if (trace_fraction >= 1 || trace_dphittexturename == "common/caulk")
            continue;
        traceline(mstart, mstart + '0 0 1' * delta.z, MOVE_NORMAL, e);
        if (trace_fraction >= 1 || trace_dphittexturename == "common/caulk")
            continue;
 
        // rule 4: we must "be seen" by some spawnpoint or item
        // Note that checkpvs from mstart to item can detect visibility if mstart is behind
        // patch brushes (curved walls) that don't block visibility from the outside, however
        // the next traceline from item to mstart correctly detects invisibility in this case
        entity sp = NULL;
        if(frompos)
        {
            if((traceline(e.origin, mstart, MOVE_NORMAL, e), trace_fraction) >= 1)
                sp = e;
        }
        if(!sp)
        {
            IL_EACH(g_spawnpoints, checkpvs(mstart, it),
            {
                if((traceline(it.origin, mstart, MOVE_NORMAL, e), trace_fraction) >= 1)
                {
                    sp = it;
                    break;
                }
            });
        }
        if(!sp)
        {
            int items_checked = 0;
            IL_EACH(g_items, checkpvs(mstart, it),
            {
                if((traceline(it.origin + (it.mins + it.maxs) * 0.5, mstart, MOVE_NORMAL, e), trace_fraction) >= 1)
                {
                    sp = it;
                    break;
                }
 
                ++items_checked;
                if(items_checked >= attempts)
                    break; // sanity
            });
 
            if(!sp)
                continue;
        }
 
        float vlen_delta = vlen(delta);
        // find a random vector to "look at"
        end.x = org.x + random() * delta.x;
        end.y = org.y + random() * delta.y;
        end.z = org.z + random() * delta.z;
        end = start + normalize(end - start) * vlen_delta;
 
        // rule 4: start TO end must not be too short
        tracebox(start, e.mins, e.maxs, end, MOVE_NORMAL, e);
        if(trace_startsolid)
            continue;
        if(trace_fraction < minviewdistance / vlen_delta)
            continue;
 
        // rule 5: don't want to look at sky
        if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
            continue;
 
        // rule 6: we must not end up in trigger_hurt
        if(tracebox_hits_trigger_hurt(start, e.mins, e.maxs, enddown))
            continue;
 
        break;
    }
 
    e.dphitcontentsmask = m;
 
    if(j < attempts)
    {
        setorigin(e, start);
        e.angles = vectoangles(end - start);
        LOG_DEBUG("Needed ", ftos(j + 1), " attempts");
        return true;
    }
    return false;
}

References checkpvs(), entity(), ftos(), g_items, g_spawnpoints, IL_EACH, LOG_DEBUG, MOVE_NORMAL, normalize(), NULL, org, Q3SURFACEFLAG_SKY, random(), trace_dphitcontents, trace_dphitq3surfaceflags, trace_dphittexturename, trace_endpos, trace_fraction, trace_startsolid, tracebox_hits_trigger_hurt(), vectoangles(), vector, and vlen().

Referenced by M_Mage_Attack_Teleport(), and MoveToRandomMapLocation().

◆ MoveToRandomMapLocation()

float MoveToRandomMapLocation	(	entity	e,
		float	goodcontents,
		float	badcontents,
		float	badsurfaceflags,
		float	attempts,
		float	maxaboveground,
		float	minviewdistance )

Definition at line 1259 of file world.qc.

{
    return MoveToRandomLocationWithinBounds(e, world.mins, world.maxs, goodcontents, badcontents, badsurfaceflags, attempts, maxaboveground, minviewdistance, false);
}

References entity(), MoveToRandomLocationWithinBounds(), and world.

Referenced by buff_Respawn(), CheatImpulse(), invasion_SpawnChosenMonster(), ka_RespawnBall(), and tka_RespawnBall().

◆ readlevelcvars()

void readlevelcvars ( )

Definition at line 2157 of file world.qc.

{
    serverflags &= ~SERVERFLAG_ALLOW_FULLBRIGHT;
    if(cvar("sv_allow_fullbright"))
        serverflags |= SERVERFLAG_ALLOW_FULLBRIGHT;
 
    serverflags &= ~SERVERFLAG_FORBID_PICKUPTIMER;
    if(cvar("sv_forbid_pickuptimer"))
        serverflags |= SERVERFLAG_FORBID_PICKUPTIMER;
 
    sv_ready_restart_after_countdown = cvar("sv_ready_restart_after_countdown");
 
    if(cvar("g_campaign"))
        warmup_stage = 0; // no warmup during campaign
    else
    {
        warmup_stage = autocvar_g_warmup;
        if (warmup_stage < 0 || warmup_stage > 1)
            warmup_limit = -1; // don't start until there's enough players
        else if (warmup_stage == 1)
        {
            // this code is duplicated in ReadyCount()
            warmup_limit = cvar("g_warmup_limit");
            if(warmup_limit == 0)
                warmup_limit = autocvar_timelimit * 60;
        }
    }
 
    g_weapon_stay = cvar(strcat("g_", GetGametype(), "_weapon_stay"));
    if (!g_weapon_stay)
        g_weapon_stay = cvar("g_weapon_stay");
    MUTATOR_CALLHOOK(SetWeaponStay, g_weapon_stay);
    g_weapon_stay = M_ARGV(0, int);
 
    MUTATOR_CALLHOOK(ReadLevelCvars);
 
    if (!warmup_stage && !autocvar_g_campaign)
        game_starttime = time + cvar("g_start_delay");
 
    FOREACH(Weapons, it != WEP_Null, { it.wr_init(it); });
 
    readplayerstartcvars();
}

References autocvar_g_campaign, autocvar_g_warmup, autocvar_timelimit, cvar(), FOREACH, g_weapon_stay, game_starttime, GetGametype(), M_ARGV, MUTATOR_CALLHOOK, readplayerstartcvars(), SERVERFLAG_ALLOW_FULLBRIGHT, SERVERFLAG_FORBID_PICKUPTIMER, serverflags, strcat(), sv_ready_restart_after_countdown, time, warmup_limit, warmup_stage, and Weapons.

Referenced by spawnfunc().

◆ readplayerstartcvars()

void readplayerstartcvars ( )

Definition at line 1969 of file world.qc.

{
    // initialize starting values for players
    start_weapons              = '0 0 0';
    start_weapons_default      = '0 0 0';
    start_weapons_defaultmask  = '0 0 0';
    start_items = 0;
    start_ammo_shells   = 0;
    start_ammo_nails    = 0;
    start_ammo_rockets  = 0;
    start_ammo_cells    = 0;
    if (random_start_ammo == NULL)
        random_start_ammo = new_pure(random_start_ammo);
    start_health      = cvar("g_balance_health_start");
    start_armorvalue  = cvar("g_balance_armor_start");
 
    string s = cvar_string("g_weaponarena");
    MUTATOR_CALLHOOK(SetWeaponArena, s);
    s = M_ARGV(0, string);
    switch (s)
    {
        case "0": case "": case "off":
            g_weaponarena_type = WEPARENA_OFF;
            g_weaponarena_weapons = '0 0 0';
            break;
        case "all": case "1":
            g_weaponarena_type = WEPARENA_ALL;
            g_weaponarena_weapons = weapons_all();
            break;
        case "devall":
            g_weaponarena_type = WEPARENA_DEVALL;
            g_weaponarena_weapons = weapons_devall();
            break;
        case "standard": case "most":
            g_weaponarena_type = WEPARENA_STANDARD;
            g_weaponarena_weapons = weapons_standard();
            break;
        case "extended":
            g_weaponarena_type = WEPARENA_EXTENDED;
            g_weaponarena_weapons = weapons_extended();
            break;
        case "extended_available":
            g_weaponarena_type = WEPARENA_EXTENDED_AVAILABLE;
            g_weaponarena_weapons = weapons_extended();
 
            // this needs to run after weaponsInMapAll is initialized
            InitializeEntity(NULL, weaponarena_available_update, INITPRIO_FINDTARGET);
            break;
        case "all_available":
            g_weaponarena_type = WEPARENA_ALL_AVAILABLE;
            g_weaponarena_weapons = weapons_all();
 
            // this needs to run after weaponsInMapAll is initialized
            InitializeEntity(NULL, weaponarena_available_update, INITPRIO_FINDTARGET);
            break;
        case "devall_available":
            g_weaponarena_type = WEPARENA_DEVALL_AVAILABLE;
            g_weaponarena_weapons = weapons_devall();
 
            // this needs to run after weaponsInMapAll is initialized
            InitializeEntity(NULL, weaponarena_available_update, INITPRIO_FINDTARGET);
            break;
        case "standard_available": case "most_available":
            g_weaponarena_type = WEPARENA_STANDARD_AVAILABLE;
            g_weaponarena_weapons = weapons_standard();
 
            // this needs to run after weaponsInMapAll is initialized
            InitializeEntity(NULL, weaponarena_available_update, INITPRIO_FINDTARGET);
            break;
        case "none":
            g_weaponarena_type = WEPARENA_NONE;
            g_weaponarena_weapons = '0 0 0';
            break;
        default:
        {
            g_weaponarena_weapons = '0 0 0';
            Weapon wep;
            int t = tokenize_console(s);
            for (int j = 0; j < t; ++j)
            {
                wep = Weapon_from_name(argv(j));
                if (wep != WEP_Null)
                    g_weaponarena_weapons |= wep.m_wepset;
            }
            g_weaponarena_type = (g_weaponarena_weapons) ? WEPARENA_CUSTOM : WEPARENA_NONE;
        }
    }
 
    if (g_weaponarena_type != WEPARENA_OFF)
    {
        g_weapon_stay = 0; // incompatible
        start_weapons = g_weaponarena_weapons;
        start_items |= IT_UNLIMITED_AMMO | IT_UNLIMITED_SUPERWEAPONS;
    }
    else
        FOREACH(Weapons, it != WEP_Null,
        {
            int w = want_weapon(it, false);
            WepSet set = it.m_wepset;
            if (w & 1)
                start_weapons |= set;
            if (w & 2)
                start_weapons_default |= set;
            if (w & 4)
                start_weapons_defaultmask |= set;
        });
 
    if (cvar("g_balance_superweapons_time") < 0)
        start_items |= IT_UNLIMITED_SUPERWEAPONS;
    if (!cvar("g_use_ammunition"))
        start_items |= IT_UNLIMITED_AMMO;
 
    start_ammo_shells   = cvar("g_start_ammo_shells");
    start_ammo_nails    = cvar("g_start_ammo_nails");
    start_ammo_rockets  = cvar("g_start_ammo_rockets");
    start_ammo_cells    = cvar("g_start_ammo_cells");
    start_ammo_fuel     = cvar("g_start_ammo_fuel");
    random_start_weapons_count = cvar("g_random_start_weapons_count");
    SetResource(random_start_ammo, RES_SHELLS,  cvar("g_random_start_shells"));
    SetResource(random_start_ammo, RES_BULLETS, cvar("g_random_start_bullets"));
    SetResource(random_start_ammo, RES_ROCKETS, cvar("g_random_start_rockets"));
    SetResource(random_start_ammo, RES_CELLS,   cvar("g_random_start_cells"));
 
    warmup_start_ammo_shells   = start_ammo_shells;
    warmup_start_ammo_nails    = start_ammo_nails;
    warmup_start_ammo_rockets  = start_ammo_rockets;
    warmup_start_ammo_cells    = start_ammo_cells;
    warmup_start_ammo_fuel     = start_ammo_fuel;
    warmup_start_health        = start_health;
    warmup_start_armorvalue    = start_armorvalue;
    warmup_start_weapons              = start_weapons;
    warmup_start_weapons_default      = start_weapons_default;
    warmup_start_weapons_defaultmask  = start_weapons_defaultmask;
 
    if (g_weaponarena_type == WEPARENA_OFF)
    {
        warmup_start_ammo_shells   = cvar("g_warmup_start_ammo_shells");
        warmup_start_ammo_nails    = cvar("g_warmup_start_ammo_nails");
        warmup_start_ammo_rockets  = cvar("g_warmup_start_ammo_rockets");
        warmup_start_ammo_cells    = cvar("g_warmup_start_ammo_cells");
        warmup_start_ammo_fuel     = cvar("g_warmup_start_ammo_fuel");
        warmup_start_health        = cvar("g_warmup_start_health");
        warmup_start_armorvalue    = cvar("g_warmup_start_armor");
        warmup_start_weapons              = '0 0 0';
        warmup_start_weapons_default      = '0 0 0';
        warmup_start_weapons_defaultmask  = '0 0 0';
        FOREACH(Weapons, it != WEP_Null,
        {
            int w = want_weapon(it, autocvar_g_warmup_allguns);
            WepSet set = it.m_wepset;
            if (w & 1)
                warmup_start_weapons |= set;
            if (w & 2)
                warmup_start_weapons_default |= set;
            if (w & 4)
                warmup_start_weapons_defaultmask |= set;
        });
    }
 
    if (autocvar_g_jetpack)
        start_items |= ITEM_Jetpack.m_itemid;
 
    MUTATOR_CALLHOOK(SetStartItems);
 
    if (start_items & ITEM_Jetpack.m_itemid)
    {
        start_items |= ITEM_FuelRegen.m_itemid;
        start_ammo_fuel = max(start_ammo_fuel, cvar("g_balance_fuel_rotstable"));
        warmup_start_ammo_fuel = max(warmup_start_ammo_fuel, cvar("g_balance_fuel_rotstable"));
    }
 
    start_ammo_shells   = max(0, start_ammo_shells);
    start_ammo_nails    = max(0, start_ammo_nails);
    start_ammo_rockets  = max(0, start_ammo_rockets);
    start_ammo_cells    = max(0, start_ammo_cells);
    start_ammo_fuel     = max(0, start_ammo_fuel);
    SetResource(random_start_ammo, RES_SHELLS,  max(0, GetResource(random_start_ammo, RES_SHELLS)));
    SetResource(random_start_ammo, RES_BULLETS, max(0, GetResource(random_start_ammo, RES_BULLETS)));
    SetResource(random_start_ammo, RES_ROCKETS, max(0, GetResource(random_start_ammo, RES_ROCKETS)));
    SetResource(random_start_ammo, RES_CELLS,   max(0, GetResource(random_start_ammo, RES_CELLS)));
 
    warmup_start_ammo_shells   = max(0, warmup_start_ammo_shells);
    warmup_start_ammo_nails    = max(0, warmup_start_ammo_nails);
    warmup_start_ammo_rockets  = max(0, warmup_start_ammo_rockets);
    warmup_start_ammo_cells    = max(0, warmup_start_ammo_cells);
    warmup_start_ammo_fuel     = max(0, warmup_start_ammo_fuel);
}

References argv(), autocvar_g_jetpack, autocvar_g_warmup_allguns, cvar(), cvar_string(), FOREACH, g_weapon_stay, g_weaponarena_type, g_weaponarena_weapons, GetResource(), InitializeEntity(), INITPRIO_FINDTARGET, IT_UNLIMITED_AMMO, IT_UNLIMITED_SUPERWEAPONS, M_ARGV, max(), MUTATOR_CALLHOOK, new_pure, NULL, random_start_ammo, random_start_weapons_count, SetResource(), start_ammo_cells, start_ammo_fuel, start_ammo_nails, start_ammo_rockets, start_ammo_shells, start_armorvalue, start_health, start_items, start_weapons, start_weapons_default, start_weapons_defaultmask, tokenize_console, want_weapon(), warmup_start_ammo_cells, warmup_start_ammo_fuel, warmup_start_ammo_nails, warmup_start_ammo_rockets, warmup_start_ammo_shells, warmup_start_armorvalue, warmup_start_health, warmup_start_weapons, warmup_start_weapons_default, warmup_start_weapons_defaultmask, Weapon_from_name(), weaponarena_available_update(), Weapons, weapons_all(), weapons_devall(), weapons_extended(), weapons_standard(), WEPARENA_ALL, WEPARENA_ALL_AVAILABLE, WEPARENA_CUSTOM, WEPARENA_DEVALL, WEPARENA_DEVALL_AVAILABLE, WEPARENA_EXTENDED, WEPARENA_EXTENDED_AVAILABLE, WEPARENA_NONE, WEPARENA_OFF, WEPARENA_STANDARD, and WEPARENA_STANDARD_AVAILABLE.

Referenced by readlevelcvars().

◆ ReadyRestart()

void ReadyRestart ( bool forceWarmupEnd )

Definition at line 526 of file vote.qc.

{
    if (MUTATOR_CALLHOOK(ReadyRestart_Deny))
    {
        // NOTE: ReadyRestart support is mandatory in campaign
        if (autocvar_g_campaign)
            error("ReadyRestart must be supported in campaign mode!");
        localcmd("restart\n"); // if ReadyRestart is denied, restart the server
    }
    else if (intermission_running || race_completing) // game is over, ReadyRestart no longer available
        localcmd("restart\n");
    else
        localcmd("\nsv_hook_readyrestart\n");
 
    if(forceWarmupEnd || autocvar_g_campaign)
        warmup_stage = 0; // forcefully end warmup and go to match stage
    else
        warmup_stage = autocvar_g_warmup; // go into warmup if it's enabled, otherwise restart into match stage
 
    ReadyRestart_force(false);
}

References autocvar_g_campaign, autocvar_g_warmup, error, intermission_running, localcmd(), MUTATOR_CALLHOOK, race_completing, ReadyRestart_force(), and warmup_stage.

Referenced by CheckRules_World(), GameCommand_allready(), GameCommand_resetmatch(), Join(), ReadyCount(), and StartFrame().

◆ RedirectionThink()

float RedirectionThink ( )

Definition at line 2532 of file world.qc.

{
    float clients_found;
 
    if(redirection_target == "")
        return false;
 
    if(!redirection_timeout)
    {
        cvar_set("sv_public", "-2");
        redirection_timeout = time + 0.6; // this will only try twice... should be able to keep more clients
        if(redirection_target == "self")
            bprint("^3SERVER NOTICE:^7 restarting the server\n");
        else
            bprint("^3SERVER NOTICE:^7 redirecting everyone to ", redirection_target, "\n");
    }
 
    if(time < redirection_nextthink)
        return true;
 
    redirection_nextthink = time + 1;
 
    clients_found = 0;
    FOREACH_CLIENT(IS_REAL_CLIENT(it), {
        // TODO add timer
        LOG_INFO("Redirecting: sending connect command to ", it.netname);
        if(redirection_target == "self")
            stuffcmd(it, "\ndisconnect; defer ", ftos(autocvar_quit_and_redirect_timer), " reconnect\n");
        else
            stuffcmd(it, strcat("\ndisconnect; defer ", ftos(autocvar_quit_and_redirect_timer), " \"connect ", redirection_target, "\"\n"));
        ++clients_found;
    });
 
    LOG_INFO("Redirecting: ", ftos(clients_found), " clients left.");
 
    if(time > redirection_timeout || clients_found == 0)
        localcmd("\nwait; wait; wait; quit\n");
 
    return true;
}

References autocvar_quit_and_redirect_timer, bprint(), cvar_set(), FOREACH_CLIENT, ftos(), IS_REAL_CLIENT, localcmd(), LOG_INFO, redirection_nextthink, redirection_target, redirection_timeout, strcat(), stuffcmd, and time.

Referenced by StartFrame().

◆ SetWinners()

void SetWinners	(	.float	field,
		float	value )

Definition at line 1547 of file world.qc.

{
    FOREACH_CLIENT(IS_PLAYER(it) || INGAME(it), { it.winning = (it.(field) == value); });
}

References FOREACH_CLIENT, INGAME, and IS_PLAYER.

Referenced by WinningCondition_Assault(), WinningCondition_Invasion(), and WinningCondition_Scores().

◆ STATIC_INIT()

STATIC_INIT ( g_moveables )

Definition at line 157 of file world.qh.

157{ g_moveables = IL_NEW(); }

IL_NEW

#define IL_NEW()

Definition intrusivelist.qh:48

g_moveables

IntrusiveList g_moveables

Definition world.qh:156

References g_moveables, and IL_NEW.

◆ void()

void ( entity this )

References entity().

◆ want_weapon()

int want_weapon	(	entity	weaponinfo,
		int	allguns )

Definition at line 1871 of file world.qc.

{
    int d = 0;
    bool allow_mutatorblocked = false;
 
    if(!weaponinfo.m_id)
        return 0;
 
    bool mutator_returnvalue = MUTATOR_CALLHOOK(WantWeapon, weaponinfo, d, allguns, allow_mutatorblocked);
    d = M_ARGV(1, float);
    allguns = M_ARGV(2, int);
    allow_mutatorblocked = M_ARGV(3, bool);
 
    if(allguns == 1)
        d = boolean(!(weaponinfo.spawnflags & WEP_FLAG_HIDDEN));
    else if(allguns == 2)
        d = boolean((weaponinfo.spawnflags & WEP_FLAG_NORMAL) && !(weaponinfo.spawnflags & WEP_FLAG_HIDDEN));
    else if(!mutator_returnvalue)
        d = !(!weaponinfo.weaponstart);
 
    if(!allow_mutatorblocked && (weaponinfo.spawnflags & WEP_FLAG_MUTATORBLOCKED)) // never default mutator blocked guns
        d = 0;
 
    float t = weaponinfo.weaponstartoverride;
 
    //LOG_INFOF("want_weapon: %s - d: %d t: %d\n", weaponinfo.netname, d, t);
 
    // bit order in t:
    // 1: want or not
    // 2: is default?
    // 4: is set by default?
    if(t < 0)
        t = 4 | (3 * d);
    else
        t |= (2 * d);
 
    return t;
}

References boolean, entity(), M_ARGV, MUTATOR_CALLHOOK, WEP_FLAG_HIDDEN, WEP_FLAG_MUTATORBLOCKED, and WEP_FLAG_NORMAL.

Referenced by readplayerstartcvars(), and weapons_start().

◆ WinningCondition_Scores()

float WinningCondition_Scores	(	float	limit,
		float	leadlimit )

Definition at line 1568 of file world.qc.

{
    // TODO make everything use THIS winning condition (except LMS)
    WinningConditionHelper(NULL);
 
    if(teamplay)
    {
        for (int i = 1; i <= AVAILABLE_TEAMS; ++i)
        {
            Team_SetTeamScore(Team_GetTeamFromIndex(i),
                TeamScore_GetCompareValue(Team_IndexToTeam(i)));
        }
    }
 
    ClearWinners();
    if(WinningConditionHelper_winner)
        WinningConditionHelper_winner.winning = 1;
    if(WinningConditionHelper_winnerteam >= 0)
        SetWinners(team, WinningConditionHelper_winnerteam);
 
    if(WinningConditionHelper_lowerisbetter)
    {
        WinningConditionHelper_topscore = -WinningConditionHelper_topscore;
        WinningConditionHelper_secondscore = -WinningConditionHelper_secondscore;
        limit = -limit;
    }
 
    if(WinningConditionHelper_zeroisworst)
        leadlimit = 0; // not supported in this mode
 
    if(MUTATOR_CALLHOOK(Scores_CountFragsRemaining))
    {
        float fragsleft;
        if (checkrules_suddendeathend && time >= checkrules_suddendeathend)
        {
            fragsleft = 1;
        }
        else
        {
            fragsleft = FLOAT_MAX;
            float leadingfragsleft = FLOAT_MAX;
            if (limit)
                fragsleft = limit - WinningConditionHelper_topscore;
            if (leadlimit)
                leadingfragsleft = WinningConditionHelper_secondscore + leadlimit - WinningConditionHelper_topscore;
 
            if (limit && leadlimit && autocvar_leadlimit_and_fraglimit)
                fragsleft = max(fragsleft, leadingfragsleft);
            else
                fragsleft = min(fragsleft, leadingfragsleft);
        }
 
        if (fragsleft_last != fragsleft) // do not announce same remaining frags multiple times
        {
            if (fragsleft == 1)
                Send_Notification(NOTIF_ALL, NULL, MSG_ANNCE, ANNCE_REMAINING_FRAG_1);
            else if (fragsleft == 2)
                Send_Notification(NOTIF_ALL, NULL, MSG_ANNCE, ANNCE_REMAINING_FRAG_2);
            else if (fragsleft == 3)
                Send_Notification(NOTIF_ALL, NULL, MSG_ANNCE, ANNCE_REMAINING_FRAG_3);
 
            fragsleft_last = fragsleft;
        }
    }
 
    bool fraglimit_reached = (limit && WinningConditionHelper_topscore >= limit);
    bool leadlimit_reached = (leadlimit && WinningConditionHelper_topscore - WinningConditionHelper_secondscore >= leadlimit);
 
    bool limit_reached;
    // only respect leadlimit_and_fraglimit when both limits are set or the game will never end
    if (limit && leadlimit && autocvar_leadlimit_and_fraglimit)
        limit_reached = (fraglimit_reached && leadlimit_reached);
    else
        limit_reached = (fraglimit_reached || leadlimit_reached);
 
    return GetWinningCode(
        WinningConditionHelper_topscore && limit_reached,
        WinningConditionHelper_equality
    );
}