sv_ctf.qc File Reference

#include "sv_ctf.qh"
#include <common/effects/all.qh>
#include <common/mapobjects/teleporters.qh>
#include <common/mapobjects/triggers.qh>
#include <common/mutators/mutator/powerups/_mod.qh>
#include <common/vehicles/all.qh>
#include <server/command/vote.qh>
#include <server/client.qh>
#include <server/gamelog.qh>
#include <server/intermission.qh>
#include <server/damage.qh>
#include <server/world.qh>
#include <server/items/items.qh>
#include <server/race.qh>
#include <server/teamplay.qh>
#include <lib/warpzone/common.qh>

Include dependency graph for sv_ctf.qc:

Go to the source code of this file.

Macros
#define	X(s, b)

Functions
void	ctf_CalculatePassVelocity (entity flag, vector to, vector from, float turnrate)
void	ctf_CaptureRecord (entity flag, entity player)
bool	ctf_CaptureShield_CheckStatus (entity p)
bool	ctf_CaptureShield_Customize (entity this, entity client)
void	ctf_CaptureShield_Spawn (entity flag)
void	ctf_CaptureShield_Touch (entity this, entity toucher)
void	ctf_CaptureShield_Update (entity player, bool wanted_status)
void	ctf_CheckFlagReturn (entity flag, int returntype)
bool	ctf_CheckPassDirection (vector head_center, vector passer_center, vector passer_angle, vector nearest_to_passer)
void	ctf_CheckStalemate ()
void	ctf_DelayedFlagSetup (entity this)
void	ctf_DelayedInit (entity this)
void	ctf_EventLog (string mode, int flagteam, entity actor)
void	ctf_FakeTimeLimit (entity e, float t)
bool	ctf_FlagBase_Customize (entity this, entity client)
void	ctf_FlagcarrierWaypoints (entity player)
void	ctf_FlagDamage (entity this, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force)
void	ctf_FlagSetup (int teamnum, entity flag)
void	ctf_FlagThink (entity this)
void	ctf_Handle_Capture (entity flag, entity toucher, int capturetype)
void	ctf_Handle_Drop (entity flag, entity player, int droptype)
void	ctf_Handle_Pickup (entity flag, entity player, int pickuptype)
void	ctf_Handle_Retrieve (entity flag, entity player)
void	ctf_Handle_Return (entity flag, entity player)
void	ctf_Handle_Throw (entity player, entity receiver, int droptype)
bool	ctf_Immediate_Return_Allowed (entity flag, entity toucher)
void	ctf_Initialize ()
void	ctf_RemovePlayer (entity player)
void	ctf_Reset (entity this)
void	ctf_RespawnFlag (entity flag)
bool	ctf_Return_Customize (entity this, entity client)
void	ctf_ScoreRules (int teams)
void	ctf_SpawnTeam (string teamname, int teamcolor)
bool	ctf_Stalemate_Customize (entity this, entity client)
void	havocbot_ctf_calculate_middlepoint ()
entity	havocbot_ctf_find_enemy_flag (entity bot)
entity	havocbot_ctf_find_flag (entity bot)
bool	havocbot_ctf_is_basewaypoint (entity item)
void	havocbot_ctf_reset_role (entity this)
int	havocbot_ctf_teamcount (entity bot, vector org, float tc_radius)
void	havocbot_goalrating_ctf_droppedflags (entity this, float ratingscale, vector org, float df_radius)
void	havocbot_goalrating_ctf_enemybase (entity this, float ratingscale)
void	havocbot_goalrating_ctf_enemyflag (entity this, float ratingscale)
void	havocbot_goalrating_ctf_ourbase (entity this, float ratingscale)
void	havocbot_goalrating_ctf_ourstolenflag (entity this, float ratingscale)
void	havocbot_role_ctf_carrier (entity this)
void	havocbot_role_ctf_defense (entity this)
void	havocbot_role_ctf_escort (entity this)
void	havocbot_role_ctf_middle (entity this)
void	havocbot_role_ctf_offense (entity this)
void	havocbot_role_ctf_retriever (entity this)
void	havocbot_role_ctf_setrole (entity bot, int role)
	MUTATOR_HOOKFUNCTION (ctf, PlayerPreThink)
	MUTATOR_HOOKFUNCTION (ctf, Damage_Calculate)
	MUTATOR_HOOKFUNCTION (ctf, PlayerDies)
	MUTATOR_HOOKFUNCTION (ctf, GiveFragsForKill)
	MUTATOR_HOOKFUNCTION (ctf, MakePlayerObserver)
	MUTATOR_HOOKFUNCTION (ctf, ClientDisconnect)
	MUTATOR_HOOKFUNCTION (ctf, ClientConnect)
	MUTATOR_HOOKFUNCTION (ctf, GetPressedKeys)
	MUTATOR_HOOKFUNCTION (ctf, PortalTeleport)
	MUTATOR_HOOKFUNCTION (ctf, PlayerUseKey)
	MUTATOR_HOOKFUNCTION (ctf, HelpMePing)
	MUTATOR_HOOKFUNCTION (ctf, VehicleEnter)
	MUTATOR_HOOKFUNCTION (ctf, VehicleExit)
	MUTATOR_HOOKFUNCTION (ctf, AbortSpeedrun)
	MUTATOR_HOOKFUNCTION (ctf, MatchEnd)
	MUTATOR_HOOKFUNCTION (ctf, HavocBot_ChooseRole)
	MUTATOR_HOOKFUNCTION (ctf, TeamBalance_CheckAllowedTeams)
	MUTATOR_HOOKFUNCTION (ctf, GetRecords)
	MUTATOR_HOOKFUNCTION (ctf, SV_ParseClientCommand)
	MUTATOR_HOOKFUNCTION (ctf, DropSpecialItems)
	MUTATOR_HOOKFUNCTION (ctf, LogDeath_AppendItemCodes)
void	nades_GiveBonus (entity player, float score)
	spawnfunc (item_flag_team1)
	spawnfunc (item_flag_team2)
	spawnfunc (item_flag_team3)
	spawnfunc (item_flag_team4)
	spawnfunc (item_flag_neutral)
	spawnfunc (ctf_team)
	spawnfunc (team_CTF_redflag)
	spawnfunc (team_CTF_blueflag)
	spawnfunc (info_player_team1)
	spawnfunc (team_CTF_redplayer)
	spawnfunc (team_CTF_redspawn)
	spawnfunc (info_player_team2)
	spawnfunc (team_CTF_blueplayer)
	spawnfunc (team_CTF_bluespawn)
	spawnfunc (team_CTF_neutralflag)
	spawnfunc (team_neutralobelisk)
	spawnfunc (team_redplayer)
	spawnfunc (team_blueplayer)
	spawnfunc (team_ctl_redlolly)
	spawnfunc (team_CTL_redlolly)
	spawnfunc (team_ctl_bluelolly)
	spawnfunc (team_CTL_bluelolly)
void	superspec_msg (string _center_title, string _con_title, entity _to, string _msg, float _spamlevel)
bool	superspec_Spectate (entity this, entity targ)

Variables
bool	autocvar_g_ctf_allow_monster_touch
bool	autocvar_g_ctf_allow_vehicle_carry
bool	autocvar_g_ctf_allow_vehicle_touch
float	autocvar_g_ctf_drop_velocity_side
float	autocvar_g_ctf_drop_velocity_up
float	autocvar_g_ctf_dropped_capture_delay
float	autocvar_g_ctf_dropped_capture_radius
bool	autocvar_g_ctf_dynamiclights
float	autocvar_g_ctf_flag_collect_delay
float	autocvar_g_ctf_flag_damageforcescale
bool	autocvar_g_ctf_flag_dropped_floatinwater
bool	autocvar_g_ctf_flag_dropped_waypoint
bool	autocvar_g_ctf_flag_glowtrails
int	autocvar_g_ctf_flag_health
bool	autocvar_g_ctf_flag_return
float	autocvar_g_ctf_flag_return_carried_radius
bool	autocvar_g_ctf_flag_return_carrying
float	autocvar_g_ctf_flag_return_damage
float	autocvar_g_ctf_flag_return_damage_delay
float	autocvar_g_ctf_flag_return_dropped
float	autocvar_g_ctf_flag_return_time
bool	autocvar_g_ctf_flag_return_when_unreachable
bool	autocvar_g_ctf_flag_waypoint = true
float	autocvar_g_ctf_flag_waypoint_maxdistance
float	autocvar_g_ctf_flagcarrier_auto_helpme_damage
float	autocvar_g_ctf_flagcarrier_auto_helpme_time
float	autocvar_g_ctf_flagcarrier_damagefactor
float	autocvar_g_ctf_flagcarrier_forcefactor
float	autocvar_g_ctf_flagcarrier_selfdamagefactor
float	autocvar_g_ctf_flagcarrier_selfforcefactor
bool	autocvar_g_ctf_fullbrightflags
bool	autocvar_g_ctf_ignore_frags
bool	autocvar_g_ctf_oneflag_reverse
bool	autocvar_g_ctf_pass
float	autocvar_g_ctf_pass_arc
float	autocvar_g_ctf_pass_arc_max
float	autocvar_g_ctf_pass_directional_max
float	autocvar_g_ctf_pass_directional_min
float	autocvar_g_ctf_pass_radius
bool	autocvar_g_ctf_pass_request
float	autocvar_g_ctf_pass_timelimit
float	autocvar_g_ctf_pass_turnrate
float	autocvar_g_ctf_pass_velocity
float	autocvar_g_ctf_pass_wait
bool	autocvar_g_ctf_portalteleport
bool	autocvar_g_ctf_reverse
int	autocvar_g_ctf_score_capture
int	autocvar_g_ctf_score_capture_assist
bool	autocvar_g_ctf_score_ignore_fields
int	autocvar_g_ctf_score_kill
int	autocvar_g_ctf_score_penalty_drop
int	autocvar_g_ctf_score_penalty_returned
int	autocvar_g_ctf_score_pickup_base
int	autocvar_g_ctf_score_pickup_dropped_early
int	autocvar_g_ctf_score_pickup_dropped_late
int	autocvar_g_ctf_score_return
float	autocvar_g_ctf_shield_force
float	autocvar_g_ctf_shield_max_ratio
int	autocvar_g_ctf_shield_min_negscore
bool	autocvar_g_ctf_stalemate
int	autocvar_g_ctf_stalemate_endcondition
float	autocvar_g_ctf_stalemate_time
bool	autocvar_g_ctf_throw
float	autocvar_g_ctf_throw_angle_max
float	autocvar_g_ctf_throw_angle_min
int	autocvar_g_ctf_throw_punish_count
float	autocvar_g_ctf_throw_punish_delay
float	autocvar_g_ctf_throw_punish_time
float	autocvar_g_ctf_throw_strengthmultiplier
float	autocvar_g_ctf_throw_velocity_forward
float	autocvar_g_ctf_throw_velocity_up
float	last_respawn
bool	pushable

Macro Definition Documentation

X

#define X	(		s,
			b
	)

Value:

if(flag.s == "") flag.s = b; \
        precache_sound(flag.s);

Referenced by ctf_FlagSetup().

Function Documentation

ctf_CalculatePassVelocity()

void ctf_CalculatePassVelocity	(	entity	flag,
		vector	to,
		vector	from,
		float	turnrate
	)

Definition at line 186 of file sv_ctf.qc.

References autocvar_g_ctf_pass_arc, autocvar_g_ctf_pass_arc_max, autocvar_g_ctf_pass_turnrate, autocvar_g_ctf_pass_velocity, eZ, FLAG_PASS_ARC_OFFSET_Z, min(), MOVE_NOMONSTERS, normalize(), tanh(), to, trace_endpos, trace_fraction, vector(), vlen(), and WarpZone_TraceLine().

Referenced by ctf_FlagThink(), and ctf_Handle_Throw().

{
    float current_distance = vlen((('1 0 0' * to.x) + ('0 1 0' * to.y)) - (('1 0 0' * from.x) + ('0 1 0' * from.y))); // for the sake of this check, exclude Z axis
    float initial_height = min(autocvar_g_ctf_pass_arc_max, (flag.pass_distance * tanh(autocvar_g_ctf_pass_arc)));
    float current_height = (initial_height * min(1, (current_distance / flag.pass_distance)));
    //print("current_height = ", ftos(current_height), ", initial_height = ", ftos(initial_height), ".\n");

    vector targpos;
    if(current_height) // make sure we can actually do this arcing path
    {
        targpos = (to + ('0 0 1' * current_height));
        WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
        if(trace_fraction < 1)
        {
            //print("normal arc line failed, trying to find new pos...");
            WarpZone_TraceLine(to, targpos, MOVE_NOMONSTERS, flag);
            targpos = (trace_endpos + eZ * FLAG_PASS_ARC_OFFSET_Z);
            WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
            if(trace_fraction < 1) { targpos = to; /* print(" ^1FAILURE^7, reverting to original direction.\n"); */ }
            /*else { print(" ^3SUCCESS^7, using new arc line.\n"); } */
        }
    }
    else { targpos = to; }

    //flag.angles = normalize(('0 1 0' * to_y) - ('0 1 0' * from_y));

    vector desired_direction = normalize(targpos - from);
    if(turnrate) { flag.velocity = (normalize(normalize(flag.velocity) + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); }
    else { flag.velocity = (desired_direction * autocvar_g_ctf_pass_velocity); }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CaptureRecord()

void ctf_CaptureRecord	(	entity	flag,
		entity	player
	)

Definition at line 111 of file sv_ctf.qc.

References APP_TEAM_NUM, ctf_captimerecord, ctf_oneflag, db_get(), db_put(), ftos(), GetMapname(), NULL, race_setTime(), ServerProgsDB, strcat(), time, TIME_ENCODE, and write_recordmarker().

Referenced by ctf_Handle_Capture().

{
    float cap_record = ctf_captimerecord;
    float cap_time = (time - flag.ctf_pickuptime);
    string refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));

    // notify about shit
    if(ctf_oneflag)
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_CTF_CAPTURE_NEUTRAL, player.netname);
    else if(!ctf_captimerecord)
        Send_Notification(NOTIF_ALL, NULL, MSG_CHOICE, APP_TEAM_NUM(flag.team, CHOICE_CTF_CAPTURE_TIME), player.netname, TIME_ENCODE(cap_time));
    else if(cap_time < cap_record)
        Send_Notification(NOTIF_ALL, NULL, MSG_CHOICE, APP_TEAM_NUM(flag.team, CHOICE_CTF_CAPTURE_BROKEN), player.netname, refername, TIME_ENCODE(cap_time), TIME_ENCODE(cap_record));
    else
        Send_Notification(NOTIF_ALL, NULL, MSG_CHOICE, APP_TEAM_NUM(flag.team, CHOICE_CTF_CAPTURE_UNBROKEN), player.netname, refername, TIME_ENCODE(cap_time), TIME_ENCODE(cap_record));

    // write that shit in the database
    if(!ctf_oneflag) // but not in 1-flag mode
    if((!ctf_captimerecord) || (cap_time < cap_record))
    {
        ctf_captimerecord = cap_time;
        db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
        db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
        write_recordmarker(player, flag.ctf_pickuptime, cap_time);
    }

    if(autocvar_g_ctf_leaderboard && !ctf_oneflag)
        race_setTime(GetMapname(), TIME_ENCODE(cap_time), player.crypto_idfp, player.netname, player, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CaptureShield_CheckStatus()

bool ctf_CaptureShield_CheckStatus

(

entity

p

)

Definition at line 251 of file sv_ctf.qc.

References ctf_captureshield_max_ratio, ctf_captureshield_min_negscore, DIFF_TEAM, FOREACH_CLIENT, GameRules_scoring_add, IS_PLAYER, and s2.

Referenced by ctf_CaptureShield_Update().

{
    int s, s2, s3, s4, se, se2, se3, se4, sr, ser;
    int players_worseeq, players_total;

    if(ctf_captureshield_max_ratio <= 0)
        return false;

    s  = GameRules_scoring_add(p, CTF_CAPS, 0);
    s2 = GameRules_scoring_add(p, CTF_PICKUPS, 0);
    s3 = GameRules_scoring_add(p, CTF_RETURNS, 0);
    s4 = GameRules_scoring_add(p, CTF_FCKILLS, 0);

    sr = ((s - s2) + (s3 + s4));

    if(sr >= -ctf_captureshield_min_negscore)
        return false;

    players_total = players_worseeq = 0;
    FOREACH_CLIENT(IS_PLAYER(it), {
        if(DIFF_TEAM(it, p))
            continue;
        se  = GameRules_scoring_add(it, CTF_CAPS, 0);
        se2 = GameRules_scoring_add(it, CTF_PICKUPS, 0);
        se3 = GameRules_scoring_add(it, CTF_RETURNS, 0);
        se4 = GameRules_scoring_add(it, CTF_FCKILLS, 0);

        ser = ((se - se2) + (se3 + se4));

        if(ser <= sr)
            ++players_worseeq;
        ++players_total;
    });

    // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
    // use this rule here

    if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
        return false;

    return true;
}

Here is the caller graph for this function:

ctf_CaptureShield_Customize()

bool ctf_CaptureShield_Customize	(	entity	this,
		entity	client
	)

Definition at line 304 of file sv_ctf.qc.

References CTF_SAMETEAM.

Referenced by ctf_CaptureShield_Spawn().

{
    if(!client.ctf_captureshielded) { return false; }
    if(CTF_SAMETEAM(this, client)) { return false; }

    return true;
}

Here is the caller graph for this function:

ctf_CaptureShield_Spawn()

void ctf_CaptureShield_Spawn

(

entity

flag

)

Definition at line 324 of file sv_ctf.qc.

References ctf_CaptureShield_Customize(), ctf_CaptureShield_Touch(), EF_ADDITIVE, entity(), MOVETYPE_NOCLIP, set_movetype(), setmodel, setorigin(), and SOLID_TRIGGER.

Referenced by ctf_DelayedFlagSetup().

{
    entity shield = new(ctf_captureshield);

    shield.enemy = flag;
    shield.team = flag.team;
    settouch(shield, ctf_CaptureShield_Touch);
    setcefc(shield, ctf_CaptureShield_Customize);
    shield.effects = EF_ADDITIVE;
    set_movetype(shield, MOVETYPE_NOCLIP);
    shield.solid = SOLID_TRIGGER;
    shield.avelocity = '7 0 11';
    shield.scale = 0.5;

    setorigin(shield, flag.origin);
    setmodel(shield, MDL_CTF_SHIELD);
    setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CaptureShield_Touch()

void ctf_CaptureShield_Touch	(	entity	this,
		entity	toucher
	)

Definition at line 312 of file sv_ctf.qc.

References absmax, absmin, ctf_captureshield_force, CTF_SAMETEAM, Damage(), DMG_NOWEP, IS_REAL_CLIENT, normalize(), and vector().

Referenced by ctf_CaptureShield_Spawn().

{
    if(!toucher.ctf_captureshielded) { return; }
    if(CTF_SAMETEAM(this, toucher)) { return; }

    vector mymid = (this.absmin + this.absmax) * 0.5;
    vector theirmid = (toucher.absmin + toucher.absmax) * 0.5;

    Damage(toucher, this, this, 0, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, mymid, normalize(theirmid - mymid) * ctf_captureshield_force);
    if(IS_REAL_CLIENT(toucher)) { Send_Notification(NOTIF_ONE, toucher, MSG_CENTER, CENTER_CTF_CAPTURESHIELD_SHIELDED); }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CaptureShield_Update()

void ctf_CaptureShield_Update	(	entity	player,
		bool	wanted_status
	)

Definition at line 294 of file sv_ctf.qc.

References ctf_CaptureShield_CheckStatus().

Referenced by ctf_FlagThink(), ctf_Handle_Return(), and ctf_Handle_Throw().

{
    bool updated_status = ctf_CaptureShield_CheckStatus(player);
    if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
    {
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((updated_status) ? CENTER_CTF_CAPTURESHIELD_SHIELDED : CENTER_CTF_CAPTURESHIELD_FREE));
        player.ctf_captureshielded = updated_status;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CheckFlagReturn()

void ctf_CheckFlagReturn	(	entity	flag,
		int	returntype
	)

Definition at line 792 of file sv_ctf.qc.

References _sound, APP_NUM, ATTEN_NONE, autocvar_g_ctf_flag_return_time, CH_TRIGGER, ctf_captimerecord, ctf_EventLog(), ctf_RespawnFlag(), FLAG_DROPPED, FLAG_PASSING, GetResource(), NULL, RES_HEALTH, RETURN_DAMAGE, RETURN_DROPPED, RETURN_NEEDKILL, RETURN_SPEEDRUN, RETURN_TIMEOUT, time, TIME_ENCODE, and VOL_BASE.

Referenced by ctf_FlagDamage(), and ctf_FlagThink().

{
    if((flag.ctf_status == FLAG_DROPPED) || (flag.ctf_status == FLAG_PASSING))
    {
        if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, GetResource(flag, RES_HEALTH)); }

        if((GetResource(flag, RES_HEALTH) <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
        {
            switch(returntype)
            {
                case RETURN_DROPPED:
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_FLAGRETURN_DROPPED)); break;
                case RETURN_DAMAGE:
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_FLAGRETURN_DAMAGED)); break;
                case RETURN_SPEEDRUN:
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_FLAGRETURN_SPEEDRUN), TIME_ENCODE(ctf_captimerecord)); break;
                case RETURN_NEEDKILL:
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_FLAGRETURN_NEEDKILL)); break;
                default:
                case RETURN_TIMEOUT:
                    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_FLAGRETURN_TIMEOUT)); break;
            }
            _sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTEN_NONE);
            ctf_EventLog("returned", flag.team, NULL);
            flag.enemy = NULL;
            ctf_RespawnFlag(flag);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CheckPassDirection()

bool ctf_CheckPassDirection	(	vector	head_center,
		vector	passer_center,
		vector	passer_angle,
		vector	nearest_to_passer
	)

Definition at line 217 of file sv_ctf.qc.

References autocvar_g_ctf_pass_directional_max, autocvar_g_ctf_pass_directional_min, autocvar_g_ctf_pass_radius, makevectors, min(), normalize(), RAD2DEG, v_forward, vector(), and vlen().

Referenced by MUTATOR_HOOKFUNCTION().

{
    if(autocvar_g_ctf_pass_directional_max || autocvar_g_ctf_pass_directional_min)
    {
        // directional tracing only
        float spreadlimit;
        makevectors(passer_angle);

        // find the closest point on the enemy to the center of the attack
        float h; // hypotenuse, which is the distance between attacker to head
        float a; // adjacent side, which is the distance between attacker and the point on w_shotdir that is closest to head.origin

        h = vlen(head_center - passer_center);
        a = h * (normalize(head_center - passer_center) * v_forward);

        vector nearest_on_line = (passer_center + a * v_forward);
        float distance_from_line = vlen(nearest_to_passer - nearest_on_line);

        spreadlimit = (autocvar_g_ctf_pass_radius ? min(1, (vlen(passer_center - nearest_on_line) / autocvar_g_ctf_pass_radius)) : 1);
        spreadlimit = (autocvar_g_ctf_pass_directional_min * (1 - spreadlimit) + autocvar_g_ctf_pass_directional_max * spreadlimit);

        if(spreadlimit && (distance_from_line <= spreadlimit) && ((vlen(normalize(head_center - passer_center) - v_forward) * RAD2DEG) <= 90))
            { return true; }
        else
            { return false; }
    }
    else { return true; }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_CheckStalemate()

void ctf_CheckStalemate

(

)

Definition at line 836 of file sv_ctf.qc.

References autocvar_g_ctf_stalemate, autocvar_g_ctf_stalemate_endcondition, autocvar_g_ctf_stalemate_time, ctf_oneflag, ctf_stalemate, ctf_Stalemate_Customize(), ctf_worldflaglist, entity(), FLAG_BASE, FLAG_WAYPOINT_OFFSET, FOREACH_CLIENT, IS_PLAYER, IS_REAL_CLIENT, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, time, WPCOLOR_ENEMYFC, wpforenemy_announced, and wps_enemyflagcarrier.

Referenced by ctf_FlagThink(), and ctf_RespawnFlag().

{
    // declarations
    int stale_flags = 0, stale_red_flags = 0, stale_blue_flags = 0, stale_yellow_flags = 0, stale_pink_flags = 0, stale_neutral_flags = 0;
    entity tmp_entity;

    entity ctf_staleflaglist = NULL; // reset the list, we need to build the list each time this function runs

    // build list of stale flags
    for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
    {
        if(autocvar_g_ctf_stalemate)
        if(tmp_entity.ctf_status != FLAG_BASE)
        if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_stalemate_time || !tmp_entity.team) // instant stalemate in oneflag
        {
            tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
            ctf_staleflaglist = tmp_entity;

            switch(tmp_entity.team)
            {
                case NUM_TEAM_1: ++stale_red_flags; break;
                case NUM_TEAM_2: ++stale_blue_flags; break;
                case NUM_TEAM_3: ++stale_yellow_flags; break;
                case NUM_TEAM_4: ++stale_pink_flags; break;
                default: ++stale_neutral_flags; break;
            }
        }
    }

    if(ctf_oneflag)
        stale_flags = (stale_neutral_flags >= 1);
    else
        stale_flags = (stale_red_flags >= 1) + (stale_blue_flags >= 1) + (stale_yellow_flags >= 1) + (stale_pink_flags >= 1);

    if(ctf_oneflag && stale_flags == 1)
        ctf_stalemate = true;
    else if(stale_flags >= 2)
        ctf_stalemate = true;
    else if(stale_flags == 0 && autocvar_g_ctf_stalemate_endcondition == 2)
        { ctf_stalemate = false; wpforenemy_announced = false; }
    else if(stale_flags < 2 && autocvar_g_ctf_stalemate_endcondition == 1)
        { ctf_stalemate = false; wpforenemy_announced = false; }

    // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
    if(ctf_stalemate)
    {
        for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
        {
            if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
            {
                entity wp = WaypointSprite_Spawn(((ctf_oneflag) ? WP_FlagCarrier : WP_FlagCarrierEnemy), 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, NULL, 0, tmp_entity.owner, wps_enemyflagcarrier, true, RADARICON_FLAG);
                wp.colormod = WPCOLOR_ENEMYFC(tmp_entity.owner.team);
                setcefc(tmp_entity.owner.wps_enemyflagcarrier, ctf_Stalemate_Customize);
            }
        }

        if (!wpforenemy_announced)
        {
            FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), { Send_Notification(NOTIF_ONE, it, MSG_CENTER, ((it.flagcarried) ? CENTER_CTF_STALEMATE_CARRIER : CENTER_CTF_STALEMATE_OTHER)); });

            wpforenemy_announced = true;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_DelayedFlagSetup()

void ctf_DelayedFlagSetup

(

entity

this

)

Definition at line 1240 of file sv_ctf.qc.

References autocvar_g_ctf_flag_waypoint, autocvar_g_ctf_flag_waypoint_maxdistance, colormapPaletteColor, ctf_CaptureShield_Spawn(), ctf_FlagBase_Customize(), entity(), FLAG_WAYPOINT_OFFSET, navigation_dynamicgoal_init(), NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, origin, team, Team_ColorRGB(), waypoint_spawnforitem_force(), and wps_flagbase.

Referenced by ctf_FlagSetup().

{
    // bot waypoints
    waypoint_spawnforitem_force(this, this.origin);
    navigation_dynamicgoal_init(this, true);

    // waypointsprites
    entity basename;
    switch (this.team)
    {
        case NUM_TEAM_1: basename = WP_FlagBaseRed; break;
        case NUM_TEAM_2: basename = WP_FlagBaseBlue; break;
        case NUM_TEAM_3: basename = WP_FlagBaseYellow; break;
        case NUM_TEAM_4: basename = WP_FlagBasePink; break;
        default: basename = WP_FlagBaseNeutral; break;
    }

    if(autocvar_g_ctf_flag_waypoint)
    {
        entity wp = WaypointSprite_SpawnFixed(basename, this.origin + FLAG_WAYPOINT_OFFSET, this, wps_flagbase, RADARICON_FLAG);
        wp.colormod = ((this.team) ? Team_ColorRGB(this.team) : '1 1 1');
        wp.fade_rate = autocvar_g_ctf_flag_waypoint_maxdistance;
        WaypointSprite_UpdateTeamRadar(this.wps_flagbase, RADARICON_FLAG, ((this.team) ? colormapPaletteColor(this.team - 1, false) : '1 1 1'));
        setcefc(wp, ctf_FlagBase_Customize);
    }

    // captureshield setup
    ctf_CaptureShield_Spawn(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_DelayedInit()

void ctf_DelayedInit

(

entity

this

)

Definition at line 2772 of file sv_ctf.qc.

References BIT, BITSET_ASSIGN, classname, ctf_oneflag, ctf_ScoreRules(), ctf_SpawnTeam(), ctf_teams, ctf_worldflaglist, entity(), find(), havocbot_ctf_calculate_middlepoint(), LOG_TRACE, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, and NumTeams().

Referenced by ctf_Initialize().

{
    ctf_teams = 0;

    entity tmp_entity;
    for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
    {
        //if(tmp_entity.team == NUM_TEAM_3) { ctf_teams = max(3, ctf_teams); }
        //if(tmp_entity.team == NUM_TEAM_4) { ctf_teams = max(4, ctf_teams); }

        switch(tmp_entity.team)
        {
            case NUM_TEAM_1: BITSET_ASSIGN(ctf_teams, BIT(0)); break;
            case NUM_TEAM_2: BITSET_ASSIGN(ctf_teams, BIT(1)); break;
            case NUM_TEAM_3: BITSET_ASSIGN(ctf_teams, BIT(2)); break;
            case NUM_TEAM_4: BITSET_ASSIGN(ctf_teams, BIT(3)); break;
        }
        if(tmp_entity.team == 0) { ctf_oneflag = true; }
    }

    havocbot_ctf_calculate_middlepoint();

    if(NumTeams(ctf_teams) < 2) // somehow, there's not enough flags!
    {
        ctf_teams = 0; // so set the default red and blue teams
        BITSET_ASSIGN(ctf_teams, BIT(0));
        BITSET_ASSIGN(ctf_teams, BIT(1));
    }

    //ctf_teams = bound(2, ctf_teams, 4);

    // if no teams are found, spawn defaults
    if(find(NULL, classname, "ctf_team") == NULL)
    {
        LOG_TRACE("No \"ctf_team\" entities found on this map, creating them anyway.");
        if(ctf_teams & BIT(0))
            ctf_SpawnTeam("Red", NUM_TEAM_1);
        if(ctf_teams & BIT(1))
            ctf_SpawnTeam("Blue", NUM_TEAM_2);
        if(ctf_teams & BIT(2))
            ctf_SpawnTeam("Yellow", NUM_TEAM_3);
        if(ctf_teams & BIT(3))
            ctf_SpawnTeam("Pink", NUM_TEAM_4);
    }

    ctf_ScoreRules(ctf_teams);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_EventLog()

void ctf_EventLog	(	string	mode,
		int	flagteam,
		entity	actor
	)

Definition at line 104 of file sv_ctf.qc.

References autocvar_sv_eventlog, ftos(), GameLogEcho(), and NULL.

Referenced by ctf_CheckFlagReturn(), ctf_Handle_Capture(), ctf_Handle_Drop(), ctf_Handle_Pickup(), ctf_Handle_Retrieve(), ctf_Handle_Return(), and ctf_Handle_Throw().

{
    if(autocvar_sv_eventlog)
        GameLogEcho(sprintf(":ctf:%s:%d:%d:%s", mode, flagteam, actor.team, ((actor != NULL) ? ftos(actor.playerid) : "")));
        //GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != NULL) ? (strcat(":", ftos(actor.playerid))) : "")));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FakeTimeLimit()

void ctf_FakeTimeLimit	(	entity	e,
		float	t
	)

Definition at line 93 of file sv_ctf.qc.

References msg_entity, MSG_ONE, WriteByte(), and WriteCoord().

Referenced by ctf_Handle_Capture(), ctf_Handle_Pickup(), and ctf_RespawnFlag().

{
    msg_entity = e;
    WriteByte(MSG_ONE, 3); // svc_updatestat
    WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
    if(t < 0)
        WriteCoord(MSG_ONE, autocvar_timelimit);
    else
        WriteCoord(MSG_ONE, (t + 1) / 60);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FlagBase_Customize()

bool ctf_FlagBase_Customize	(	entity	this,
		entity	client
	)

Definition at line 1228 of file sv_ctf.qc.

References CTF_SAMETEAM, entity(), and owner.

Referenced by ctf_DelayedFlagSetup().

{
    entity e = WaypointSprite_getviewentity(client);
    entity wp_owner = this.owner;
    entity flag = e.flagcarried;
    if(flag && CTF_SAMETEAM(e, flag))
        return false;
    if(flag && (flag.cnt || wp_owner.cnt) && wp_owner.cnt != flag.cnt)
        return false;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FlagcarrierWaypoints()

void ctf_FlagcarrierWaypoints

(

entity

player

)

Definition at line 157 of file sv_ctf.qc.

References autocvar_g_balance_armor_blockpercent, ctf_oneflag, ctf_Return_Customize(), CTF_SAMETEAM, ctf_stalemate, ctf_Stalemate_Customize(), entity(), FLAG_WAYPOINT_OFFSET, GetResource(), IS_REAL_CLIENT, NULL, RES_HEALTH, start_armorvalue, start_health, WPCOLOR_ENEMYFC, WPCOLOR_FLAGCARRIER, wps_enemyflagcarrier, wps_flagcarrier, and wps_flagreturn.

Referenced by ctf_Handle_Pickup(), and ctf_Handle_Retrieve().

{
    WaypointSprite_Spawn(WP_FlagCarrier, 0, 0, player, FLAG_WAYPOINT_OFFSET, NULL, player.team, player, wps_flagcarrier, true, RADARICON_FLAG);
    WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, 2 * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id).x);
    WaypointSprite_UpdateHealth(player.wps_flagcarrier, healtharmor_maxdamage(GetResource(player, RES_HEALTH), GetResource(player, RES_ARMOR), autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id).x);
    WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));

    if(player.flagcarried && CTF_SAMETEAM(player, player.flagcarried))
    {
        if(!player.wps_enemyflagcarrier)
        {
            entity wp = WaypointSprite_Spawn(((ctf_oneflag) ? WP_FlagCarrier : WP_FlagCarrierEnemy), 0, 0, player, FLAG_WAYPOINT_OFFSET, NULL, 0, player, wps_enemyflagcarrier, true, RADARICON_FLAG);
            wp.colormod = WPCOLOR_ENEMYFC(player.team);
            setcefc(wp, ctf_Stalemate_Customize);

            if(IS_REAL_CLIENT(player) && !ctf_stalemate)
                Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PICKUP_VISIBLE);
        }

        if(!player.wps_flagreturn)
        {
            entity owp = WaypointSprite_SpawnFixed(WP_FlagReturn, player.flagcarried.ctf_spawnorigin + FLAG_WAYPOINT_OFFSET, player, wps_flagreturn, RADARICON_FLAG);
            owp.colormod = '0 0.8 0.8';
            //WaypointSprite_UpdateTeamRadar(player.wps_flagreturn, RADARICON_FLAG, ((player.team) ? colormapPaletteColor(player.team - 1, false) : '1 1 1'));
            setcefc(owp, ctf_Return_Customize);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FlagDamage()

void ctf_FlagDamage	(	entity	this,
		entity	inflictor,
		entity	attacker,
		float	damage,
		int	deathtype,
		.entity	weaponentity,
		vector	hitloc,
		vector	force
	)

Definition at line 901 of file sv_ctf.qc.

References autocvar_g_ctf_flag_return_damage, autocvar_g_ctf_flag_return_damage_delay, ctf_CheckFlagReturn(), ctf_flagdamaged_byworld, ITEM_DAMAGE_NEEDKILL, RES_HEALTH, RETURN_DAMAGE, RETURN_NEEDKILL, SetResourceExplicit(), and TakeResource().

Referenced by ctf_FlagSetup().

{
    if(ITEM_DAMAGE_NEEDKILL(deathtype))
    {
        if(autocvar_g_ctf_flag_return_damage_delay)
            this.ctf_flagdamaged_byworld = true;
        else
        {
            SetResourceExplicit(this, RES_HEALTH, 0);
            ctf_CheckFlagReturn(this, RETURN_NEEDKILL);
        }
        return;
    }
    if(autocvar_g_ctf_flag_return_damage)
    {
        // reduce health and check if it should be returned
        TakeResource(this, RES_HEALTH, damage);
        ctf_CheckFlagReturn(this, RETURN_DAMAGE);
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FlagSetup()

void ctf_FlagSetup	(	int	teamnum,
		entity	flag
	)

Definition at line 1272 of file sv_ctf.qc.

References autocvar_g_ctf_dynamiclights, autocvar_g_ctf_flag_damageforcescale, autocvar_g_ctf_flag_glowtrails, autocvar_g_ctf_flag_health, autocvar_g_ctf_flag_return_damage, autocvar_g_ctf_flag_return_when_unreachable, autocvar_g_ctf_fullbrightflags, autocvar_g_ctf_score_ignore_fields, ctf_DelayedFlagSetup(), CTF_FLAG, ctf_FlagDamage(), ctf_FlagThink(), ctf_FlagTouch(), ctf_Reset(), ctf_worldflaglist, cvar(), cvar_string(), DAMAGE_NO, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, droptofloor, EF_BLUE, EF_DIMLIGHT, EF_FULLBRIGHT, EF_LOWPRECISION, EF_RED, EFFECT_CAP(), EFFECT_FLAG_TOUCH(), EFFECT_PASS(), FL_ITEM, FL_NOTARGET, FLAG_BASE, FLAG_SCALE, FLAG_SPAWN_OFFSET, FLAG_THINKRATE, g_damagedbycontents, g_items, IL_PUSH(), InitializeEntity(), Flag::m_maxs, Flag::m_mins, MOVETYPE_NONE, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, RES_HEALTH, set_movetype(), setorigin(), SetResourceExplicit(), setthink, SND, snd_flag_capture, snd_flag_dropped, snd_flag_pass, snd_flag_respawn, snd_flag_returned, snd_flag_taken, snd_flag_touch, SOLID_TRIGGER, Static_Team_ColorName_Lower, strzone(), Team_ColorCode(), Team_ColorName_Upper, TELEPORT_NORMAL, time, and X.

Referenced by spawnfunc().

{
    // main setup
    flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
    ctf_worldflaglist = flag;

    setattachment(flag, NULL, "");

    flag.netname = strzone(sprintf("%s%s^7 flag", Team_ColorCode(teamnum), Team_ColorName_Upper(teamnum)));
    flag.team = teamnum;
    flag.classname = "item_flag_team";
    flag.target = "###item###"; // for finding the nearest item using findnearest
    flag.flags = FL_ITEM | FL_NOTARGET;
    IL_PUSH(g_items, flag);
    flag.solid = SOLID_TRIGGER;
    flag.takedamage = DAMAGE_NO;
    flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
    flag.max_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
    SetResourceExplicit(flag, RES_HEALTH, flag.max_health);
    flag.event_damage = ctf_FlagDamage;
    flag.pushable = true;
    flag.teleportable = TELEPORT_NORMAL;
    flag.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_PLAYERCLIP;
    flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
    flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
    if(flag.damagedbycontents)
        IL_PUSH(g_damagedbycontents, flag);
    flag.velocity = '0 0 0';
    flag.mangle = flag.angles;
    flag.reset = ctf_Reset;
    settouch(flag, ctf_FlagTouch);
    setthink(flag, ctf_FlagThink);
    flag.nextthink = time + FLAG_THINKRATE;
    flag.ctf_status = FLAG_BASE;

    // crudely force them all to 0
    if(autocvar_g_ctf_score_ignore_fields)
        flag.cnt = flag.score_assist = flag.score_team_capture = flag.score_capture = flag.score_drop = flag.score_pickup = flag.score_return = 0;

    string teamname = Static_Team_ColorName_Lower(teamnum);
    // appearence
    if(!flag.scale)             { flag.scale = FLAG_SCALE; }
    if(flag.skin == 0)          { flag.skin = cvar(sprintf("g_ctf_flag_%s_skin", teamname)); }
    if(flag.model == "")        { flag.model = cvar_string(sprintf("g_ctf_flag_%s_model", teamname)); }
    if (flag.toucheffect == "") { flag.toucheffect = EFFECT_FLAG_TOUCH(teamnum).eent_eff_name; }
    if (flag.passeffect == "")  { flag.passeffect = EFFECT_PASS(teamnum).eent_eff_name; }
    if (flag.capeffect == "")   { flag.capeffect = EFFECT_CAP(teamnum).eent_eff_name; }

    // sounds
#define X(s,b) \
        if(flag.s == "") flag.s = b; \
        precache_sound(flag.s);

    X(snd_flag_taken,       strzone(SND(CTF_TAKEN(teamnum))))
    X(snd_flag_returned,    strzone(SND(CTF_RETURNED(teamnum))))
    X(snd_flag_capture,     strzone(SND(CTF_CAPTURE(teamnum))))
    X(snd_flag_dropped,     strzone(SND(CTF_DROPPED(teamnum))))
    X(snd_flag_respawn,     strzone(SND(CTF_RESPAWN)))
    X(snd_flag_touch,       strzone(SND(CTF_TOUCH)))
    X(snd_flag_pass,        strzone(SND(CTF_PASS)))
#undef X

    // precache
    precache_model(flag.model);

    // appearence
    _setmodel(flag, flag.model); // precision set below
    setsize(flag, CTF_FLAG.m_mins * flag.scale, CTF_FLAG.m_maxs * flag.scale);
    flag.m_mins = flag.mins; // store these for squash checks
    flag.m_maxs = flag.maxs;
    setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));

    if(autocvar_g_ctf_flag_glowtrails)
    {
        switch(teamnum)
        {
            case NUM_TEAM_1: flag.glow_color = 251; break;
            case NUM_TEAM_2: flag.glow_color = 210; break;
            case NUM_TEAM_3: flag.glow_color = 110; break;
            case NUM_TEAM_4: flag.glow_color = 145; break;
            default:         flag.glow_color = 254; break;
        }
        flag.glow_size = 25;
        flag.glow_trail = 1;
    }

    flag.effects |= EF_LOWPRECISION;
    if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
    if(autocvar_g_ctf_dynamiclights)
    {
        switch(teamnum)
        {
            case NUM_TEAM_1: flag.effects |= EF_RED; break;
            case NUM_TEAM_2: flag.effects |= EF_BLUE; break;
            case NUM_TEAM_3: flag.effects |= EF_DIMLIGHT; break;
            case NUM_TEAM_4: flag.effects |= EF_RED; break;
            default:         flag.effects |= EF_DIMLIGHT; break;
        }
    }

    // flag placement
    if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
    {
        flag.dropped_origin = flag.origin;
        flag.noalign = true;
        set_movetype(flag, MOVETYPE_NONE);
    }
    else // drop to floor, automatically find a platform and set that as spawn origin
    {
        flag.noalign = false;
        droptofloor(flag);
        set_movetype(flag, MOVETYPE_NONE);
    }

    InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_FlagThink()

void ctf_FlagThink

(

entity

this

)

Definition at line 923 of file sv_ctf.qc.

References _sound, absmax, absmin, angles, ATTEN_NORM, autocvar_g_ctf_allow_monster_touch, autocvar_g_ctf_allow_vehicle_touch, autocvar_g_ctf_dropped_capture_delay, autocvar_g_ctf_dropped_capture_radius, autocvar_g_ctf_flag_collect_delay, autocvar_g_ctf_flag_dropped_floatinwater, autocvar_g_ctf_flag_return, autocvar_g_ctf_flag_return_carried_radius, autocvar_g_ctf_flag_return_carrying, autocvar_g_ctf_flag_return_damage_delay, autocvar_g_ctf_flag_return_dropped, autocvar_g_ctf_flag_return_time, autocvar_g_ctf_pass_radius, autocvar_g_ctf_pass_timelimit, autocvar_g_ctf_stalemate, CAPTURE_DROPPED, CAPTURE_NORMAL, CH_TRIGGER, CONTENT_WATER, CS(), ctf_CalculatePassVelocity(), ctf_captimerecord, ctf_CaptureShield_Update(), ctf_CheckFlagReturn(), ctf_CheckStalemate(), CTF_DIFFTEAM, ctf_droptime, ctf_flagdamaged_byworld, ctf_Handle_Capture(), ctf_Handle_Drop(), ctf_Handle_Pickup(), ctf_Handle_Retrieve(), ctf_Handle_Return(), ctf_Handle_Throw(), ctf_Immediate_Return_Allowed(), ctf_oneflag, ctf_pickuptime, CTF_SAMETEAM, ctf_spawnorigin, ctf_status, ctf_worldflaglist, DIFF_TEAM, DPCONTENTS_MONSTERCLIP, DPCONTENTS_PLAYERCLIP, DROP_PASS, DROP_THROW, entity(), eZ, FLAG_BASE, FLAG_CARRY, FLAG_DROPPED, FLAG_FLOAT_OFFSET_Z, FLAG_PASSING, FLAG_THINKRATE, FLAG_TOUCHRATE, FOREACH_CLIENT, ImpulseCommands(), IS_DEAD, IS_MONSTER, IS_PLAYER, IS_VEHICLE, ITEM_TOUCH_NEEDKILL, LOG_TRACE, max_health, maxs, METHOD, mins, move_movetype, MOVE_NOMONSTERS, MOVETYPE_FLY, MOVETYPE_TOSS, nextthink, noalign, NULL, origin, owner, pass_target, PICKUP_BASE, PICKUP_DROPPED, RES_HEALTH, RETURN_DROPPED, RETURN_NEEDKILL, RETURN_SPEEDRUN, RETURN_TIMEOUT, set_movetype(), SetResourceExplicit(), speedrunning, TakeResource(), team, time, trace_dphitcontents, trace_ent, trace_fraction, trace_startsolid, vdist, vector(), velocity, VOL_BASE, WarpZone_RefSys_TransformOrigin(), WarpZone_TraceLine(), WPFE_THINKRATE, and wpforenemy_nextthink.

Referenced by ctf_FlagSetup().

{
    // declarations
    entity tmp_entity;

    this.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.

    // captureshield
    if(this == ctf_worldflaglist) // only for the first flag
        FOREACH_CLIENT(true, { ctf_CaptureShield_Update(it, 1); }); // release shield only

    // sanity checks
    if(this.mins != this.m_mins || this.maxs != this.m_maxs) { // reset the flag boundaries in case it got squished
        LOG_TRACE("wtf the flag got squashed?");
        tracebox(this.origin, this.m_mins, this.m_maxs, this.origin, MOVE_NOMONSTERS, this);
        if(!trace_startsolid || this.noalign) // can we resize it without getting stuck?
            setsize(this, this.m_mins, this.m_maxs);
    }

    // main think method
    switch(this.ctf_status)
    {
        case FLAG_BASE:
        {
            if(autocvar_g_ctf_dropped_capture_radius)
            {
                for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
                    if(tmp_entity.ctf_status == FLAG_DROPPED)
                    if(vdist(this.origin - tmp_entity.origin, <, autocvar_g_ctf_dropped_capture_radius))
                    if(time > tmp_entity.ctf_droptime + autocvar_g_ctf_dropped_capture_delay)
                        ctf_Handle_Capture(this, tmp_entity, CAPTURE_DROPPED);
            }
            return;
        }

        case FLAG_DROPPED:
        {
            this.angles = '0 0 0'; // reset flag angles in case warpzones adjust it

            if(autocvar_g_ctf_flag_dropped_floatinwater)
            {
                vector midpoint = ((this.absmin + this.absmax) * 0.5);
                if(pointcontents(midpoint) == CONTENT_WATER)
                {
                    this.velocity = this.velocity * 0.5;

                    if (pointcontents(midpoint + eZ * FLAG_FLOAT_OFFSET_Z) == CONTENT_WATER)
                        { this.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
                    else
                        { set_movetype(this, MOVETYPE_FLY); }
                }
                else if(this.move_movetype == MOVETYPE_FLY) { set_movetype(this, MOVETYPE_TOSS); }
            }
            if(autocvar_g_ctf_flag_return_dropped)
            {
                if((vdist(this.origin - this.ctf_spawnorigin, <=, autocvar_g_ctf_flag_return_dropped)) || (autocvar_g_ctf_flag_return_dropped == -1))
                {
                    SetResourceExplicit(this, RES_HEALTH, 0);
                    ctf_CheckFlagReturn(this, RETURN_DROPPED);
                    return;
                }
            }
            if(this.ctf_flagdamaged_byworld)
            {
                TakeResource(this, RES_HEALTH, (this.max_health / autocvar_g_ctf_flag_return_damage_delay) * FLAG_THINKRATE);
                ctf_CheckFlagReturn(this, RETURN_NEEDKILL);
                return;
            }
            else if(autocvar_g_ctf_flag_return_time)
            {
                TakeResource(this, RES_HEALTH, (this.max_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
                ctf_CheckFlagReturn(this, RETURN_TIMEOUT);
                return;
            }
            return;
        }

        case FLAG_CARRY:
        {
            if(this.speedrunning && ctf_captimerecord && (time >= this.ctf_pickuptime + ctf_captimerecord))
            {
                SetResourceExplicit(this, RES_HEALTH, 0);
                ctf_CheckFlagReturn(this, RETURN_SPEEDRUN);

                CS(this.owner).impulse = CHIMPULSE_SPEEDRUN.impulse; // move the player back to the waypoint they set
                ImpulseCommands(this.owner);
            }
            if(autocvar_g_ctf_stalemate)
            {
                if(time >= wpforenemy_nextthink)
                {
                    ctf_CheckStalemate();
                    wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
                }
            }
            if(CTF_SAMETEAM(this, this.owner) && this.team)
            {
                if(autocvar_g_ctf_flag_return) // drop the flag if reverse status has changed
                    ctf_Handle_Throw(this.owner, NULL, DROP_THROW);
                else if(vdist(this.owner.origin - this.ctf_spawnorigin, <=, autocvar_g_ctf_flag_return_carried_radius))
                    ctf_Handle_Return(this, this.owner);
            }
            return;
        }

        case FLAG_PASSING:
        {
            vector targ_origin = ((this.pass_target.absmin + this.pass_target.absmax) * 0.5);
            targ_origin = WarpZone_RefSys_TransformOrigin(this.pass_target, this, targ_origin); // origin of target as seen by the flag (us)
            WarpZone_TraceLine(this.origin, targ_origin, MOVE_NOMONSTERS, this);

            if((this.pass_target == NULL)
                || (IS_DEAD(this.pass_target))
                || (this.pass_target.flagcarried)
                || (vdist(this.origin - targ_origin, >, autocvar_g_ctf_pass_radius))
                || ((trace_fraction < 1) && (trace_ent != this.pass_target))
                || (time > this.ctf_droptime + autocvar_g_ctf_pass_timelimit))
            {
                // give up, pass failed
                ctf_Handle_Drop(this, NULL, DROP_PASS);
            }
            else
            {
                // still a viable target, go for it
                ctf_CalculatePassVelocity(this, targ_origin, this.origin, true);
            }
            return;
        }

        default: // this should never happen
        {
            LOG_TRACE("ctf_FlagThink(): Flag exists with no status?");
            return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Capture()

void ctf_Handle_Capture	(	entity	flag,
		entity	toucher,
		int	capturetype
	)

Definition at line 561 of file sv_ctf.qc.

References _sound, APP_NUM, ATTEN_NONE, autocvar_g_ctf_flag_collect_delay, autocvar_g_ctf_score_capture, autocvar_g_ctf_score_capture_assist, CAPTURE_DROPPED, CAPTURE_NORMAL, CH_TRIGGER, ctf_CaptureRecord(), CTF_DIFFTEAM, ctf_EventLog(), ctf_FakeTimeLimit(), ctf_oneflag, ctf_RespawnFlag(), ctf_worldflaglist, DIFF_TEAM, entity(), floor(), GameRules_scoring_add, GameRules_scoring_add_team, max(), nades_GiveBonus(), NULL, SAME_TEAM, time, TIME_ENCODE, and VOL_BASE.

Referenced by ctf_FlagThink().

{
    entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
    entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
    entity player_team_flag = NULL, tmp_entity;
    float old_time, new_time;

    if(!player) { return; } // without someone to give the reward to, we can't possibly cap
    if(CTF_DIFFTEAM(player, flag)) { return; }
    if((flag.cnt || enemy_flag.cnt) && flag.cnt != enemy_flag.cnt) { return; } // this should catch some edge cases (capturing grouped flag at ungrouped flag disallowed etc)

    if (toucher.goalentity == flag.bot_basewaypoint)
        toucher.goalentity_lock_timeout = 0;

    if(ctf_oneflag)
    for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
    if(SAME_TEAM(tmp_entity, player))
    {
        player_team_flag = tmp_entity;
        break;
    }

    nades_GiveBonus(player, autocvar_g_nades_bonus_score_high );

    player.throw_prevtime = time;
    player.throw_count = 0;

    // messages and sounds
    Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_NUM(enemy_flag.team, CENTER_CTF_CAPTURE));
    ctf_CaptureRecord(enemy_flag, player);
    _sound(player, CH_TRIGGER, ((ctf_oneflag) ? player_team_flag.snd_flag_capture : ((DIFF_TEAM(player, flag)) ? enemy_flag.snd_flag_capture : flag.snd_flag_capture)), VOL_BASE, ATTEN_NONE);

    switch(capturetype)
    {
        case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
        case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
        default: break;
    }

    // scoring
    float pscore = 0;
    if(enemy_flag.score_capture || flag.score_capture)
        pscore = floor((max(1, enemy_flag.score_capture) + max(1, flag.score_capture)) * 0.5);
    GameRules_scoring_add_team(player, SCORE, ((pscore) ? pscore : autocvar_g_ctf_score_capture));
    float capscore = 0;
    if(enemy_flag.score_team_capture || flag.score_team_capture)
        capscore = floor((max(1, enemy_flag.score_team_capture) + max(1, flag.score_team_capture)) * 0.5);
    GameRules_scoring_add_team(player, CTF_CAPS, ((capscore) ? capscore : 1));

    old_time = GameRules_scoring_add(player, CTF_CAPTIME, 0);
    new_time = TIME_ENCODE(time - enemy_flag.ctf_pickuptime);
    if(!old_time || new_time < old_time)
        GameRules_scoring_add(player, CTF_CAPTIME, new_time - old_time);

    // effects
    Send_Effect_(flag.capeffect, flag.origin, '0 0 0', 1);
#if 0
    shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
#endif

    // other
    if(capturetype == CAPTURE_NORMAL)
    {
        WaypointSprite_Kill(player.wps_flagcarrier);
        if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }

        if((enemy_flag.ctf_dropper) && (player != enemy_flag.ctf_dropper))
            { GameRules_scoring_add_team(enemy_flag.ctf_dropper, SCORE, ((enemy_flag.score_assist) ? enemy_flag.score_assist : autocvar_g_ctf_score_capture_assist)); }
    }

    flag.enemy = toucher;

    // reset the flag
    player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
    ctf_RespawnFlag(enemy_flag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Drop()

void ctf_Handle_Drop	(	entity	flag,
		entity	player,
		int	droptype
	)

Definition at line 348 of file sv_ctf.qc.

References _sound, APP_NUM, ATTEN_NONE, autocvar_g_ctf_flag_dropped_waypoint, autocvar_g_ctf_flag_health, autocvar_g_ctf_flag_return_damage, autocvar_g_ctf_flag_return_time, autocvar_g_ctf_pass_wait, autocvar_g_ctf_score_penalty_drop, CH_TRIGGER, ctf_EventLog(), DAMAGE_YES, DROP_PASS, entity(), FLAG_DROPPED, FLAG_WAYPOINT_OFFSET, GameRules_scoring_add, GameRules_scoring_add_team, GetResource(), MOVETYPE_TOSS, NULL, RES_HEALTH, set_movetype(), SetResourceExplicit(), time, VOL_BASE, WPCOLOR_DROPPEDFLAG, and wps_flagdropped.

Referenced by ctf_FlagThink(), and ctf_Handle_Throw().

{
    // declarations
    player = (player ? player : flag.pass_sender);

    // main
    set_movetype(flag, MOVETYPE_TOSS);
    flag.takedamage = DAMAGE_YES;
    flag.angles = '0 0 0';
    SetResourceExplicit(flag, RES_HEALTH, flag.max_health);
    flag.ctf_droptime = time;
    flag.ctf_dropper = player;
    flag.ctf_status = FLAG_DROPPED;

    // messages and sounds
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_LOST), player.netname);
    _sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTEN_NONE);
    ctf_EventLog("dropped", player.team, player);

    // scoring
    GameRules_scoring_add_team(player, SCORE, -((flag.score_drop) ? flag.score_drop : autocvar_g_ctf_score_penalty_drop));
    GameRules_scoring_add(player, CTF_DROPS, 1);

    // waypoints
    if(autocvar_g_ctf_flag_dropped_waypoint) {
        entity wp = WaypointSprite_Spawn(WP_FlagDropped, 0, 0, flag, FLAG_WAYPOINT_OFFSET, NULL, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, true, RADARICON_FLAG);
        wp.colormod = WPCOLOR_DROPPEDFLAG(flag.team);
    }

    if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
    {
        WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_health);
        WaypointSprite_UpdateHealth(flag.wps_flagdropped, GetResource(flag, RES_HEALTH));
    }

    player.throw_antispam = time + autocvar_g_ctf_pass_wait;

    if(droptype == DROP_PASS)
    {
        flag.pass_distance = 0;
        flag.pass_sender = NULL;
        flag.pass_target = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Pickup()

void ctf_Handle_Pickup	(	entity	flag,
		entity	player,
		int	pickuptype
	)

Definition at line 681 of file sv_ctf.qc.

References _sound, APP_NUM, APP_TEAM_NUM, ATTEN_NONE, autocvar_g_ctf_flag_return_time, autocvar_g_ctf_score_pickup_base, autocvar_g_ctf_score_pickup_dropped_early, autocvar_g_ctf_score_pickup_dropped_late, bound(), CH_TRIGGER, ctf_captimerecord, CTF_DIFFTEAM, ctf_EventLog(), ctf_FakeTimeLimit(), ctf_FlagcarrierWaypoints(), CTF_SAMETEAM, ctf_stalemate, DAMAGE_NO, DIFF_TEAM, FLAG_CARRY, FLAG_CARRY_OFFSET, floor(), FOREACH_CLIENT, ftos(), GameRules_scoring_add, GameRules_scoring_add_team, GameRules_scoring_vip(), IS_PLAYER, LOG_TRACE, MOVETYPE_NONE, nades_GiveBonus(), NULL, PICKUP_BASE, PICKUP_DROPPED, RES_HEALTH, SAME_TEAM, set_movetype(), setorigin(), SetResourceExplicit(), SOLID_NOT, Team_ColorCode(), time, VEHICLE_FLAG_OFFSET, VEHICLE_FLAG_SCALE, and VOL_BASE.

Referenced by ctf_FlagThink().

{
    // declarations
    float pickup_dropped_score; // used to calculate dropped pickup score

    // attach the flag to the player
    flag.owner = player;
    player.flagcarried = flag;
    GameRules_scoring_vip(player, true);
    if(player.vehicle)
    {
        setattachment(flag, player.vehicle, "");
        setorigin(flag, VEHICLE_FLAG_OFFSET);
        flag.scale = VEHICLE_FLAG_SCALE;
    }
    else
    {
        setattachment(flag, player, "");
        setorigin(flag, FLAG_CARRY_OFFSET);
    }

    // flag setup
    set_movetype(flag, MOVETYPE_NONE);
    flag.takedamage = DAMAGE_NO;
    flag.solid = SOLID_NOT;
    flag.angles = '0 0 0';
    flag.ctf_status = FLAG_CARRY;

    switch(pickuptype)
    {
        case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
        case PICKUP_DROPPED: SetResourceExplicit(flag, RES_HEALTH, flag.max_health); break; // reset health/return timelimit
        default: break;
    }

    // messages and sounds
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(flag.team, INFO_CTF_PICKUP), player.netname);
    if(ctf_stalemate)
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_STALEMATE_CARRIER);
    if(!flag.team)
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PICKUP_NEUTRAL);
    else if(CTF_DIFFTEAM(player, flag))
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_NUM(flag.team, CENTER_CTF_PICKUP));
    else
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((SAME_TEAM(player, flag)) ? CENTER_CTF_PICKUP_RETURN : CENTER_CTF_PICKUP_RETURN_ENEMY), Team_ColorCode(flag.team));

    Send_Notification(NOTIF_TEAM_EXCEPT, player, MSG_CHOICE, APP_NUM(flag.team, CHOICE_CTF_PICKUP_TEAM), Team_ColorCode(player.team), player.netname);

    if(!flag.team)
        FOREACH_CLIENT(IS_PLAYER(it) && it != player && DIFF_TEAM(it, player), { Send_Notification(NOTIF_ONE, it, MSG_CHOICE, CHOICE_CTF_PICKUP_ENEMY_NEUTRAL, Team_ColorCode(player.team), player.netname); });

    if(flag.team)
        FOREACH_CLIENT(IS_PLAYER(it) && it != player, {
            if(CTF_SAMETEAM(flag, it))
            {
                if(SAME_TEAM(player, it))
                    Send_Notification(NOTIF_ONE, it, MSG_CHOICE, APP_TEAM_NUM(flag.team, CHOICE_CTF_PICKUP_TEAM), Team_ColorCode(player.team), player.netname);
                else
                    Send_Notification(NOTIF_ONE, it, MSG_CHOICE, ((SAME_TEAM(flag, player)) ? CHOICE_CTF_PICKUP_ENEMY_TEAM : CHOICE_CTF_PICKUP_ENEMY), Team_ColorCode(player.team), player.netname);
            }
        });

    _sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTEN_NONE);

    // scoring
    GameRules_scoring_add(player, CTF_PICKUPS, 1);
    nades_GiveBonus(player, autocvar_g_nades_bonus_score_minor);
    switch(pickuptype)
    {
        case PICKUP_BASE:
        {
            GameRules_scoring_add_team(player, SCORE, ((flag.score_pickup) ? flag.score_pickup : autocvar_g_ctf_score_pickup_base));
            ctf_EventLog("steal", flag.team, player);
            break;
        }

        case PICKUP_DROPPED:
        {
            pickup_dropped_score = (autocvar_g_ctf_flag_return_time ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_return_time) - time) / autocvar_g_ctf_flag_return_time, 1) : 1);
            pickup_dropped_score = floor((autocvar_g_ctf_score_pickup_dropped_late * (1 - pickup_dropped_score) + autocvar_g_ctf_score_pickup_dropped_early * pickup_dropped_score) + 0.5);
            LOG_TRACE("pickup_dropped_score is ", ftos(pickup_dropped_score));
            GameRules_scoring_add_team(player, SCORE, pickup_dropped_score);
            ctf_EventLog("pickup", flag.team, player);
            break;
        }

        default: break;
    }

    // speedrunning
    if(pickuptype == PICKUP_BASE)
    {
        flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
        if((player.speedrunning) && (ctf_captimerecord))
            ctf_FakeTimeLimit(player, time + ctf_captimerecord);
    }

    // effects
    Send_Effect_(flag.toucheffect, player.origin, '0 0 0', 1);

    // waypoints
    if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
    ctf_FlagcarrierWaypoints(player);
    WaypointSprite_Ping(player.wps_flagcarrier);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Retrieve()

void ctf_Handle_Retrieve	(	entity	flag,
		entity	player
	)

Definition at line 393 of file sv_ctf.qc.

References _sound, APP_NUM, ATTEN_NORM, autocvar_g_ctf_pass_wait, CH_TRIGGER, ctf_EventLog(), ctf_FlagcarrierWaypoints(), DAMAGE_NO, entity(), FLAG_CARRY, FLAG_CARRY_OFFSET, FOREACH_CLIENT, GameRules_scoring_vip(), IS_PLAYER, IS_REAL_CLIENT, MOVETYPE_NONE, NULL, SAME_TEAM, set_movetype(), setorigin(), SOLID_NOT, time, VEHICLE_FLAG_OFFSET, VEHICLE_FLAG_SCALE, and VOL_BASE.

Referenced by ctf_FlagThink().

{
    entity sender = flag.pass_sender;

    // transfer flag to player
    flag.owner = player;
    flag.owner.flagcarried = flag;
    GameRules_scoring_vip(player, true);

    // reset flag
    if(player.vehicle)
    {
        setattachment(flag, player.vehicle, "");
        setorigin(flag, VEHICLE_FLAG_OFFSET);
        flag.scale = VEHICLE_FLAG_SCALE;
    }
    else
    {
        setattachment(flag, player, "");
        setorigin(flag, FLAG_CARRY_OFFSET);
    }
    set_movetype(flag, MOVETYPE_NONE);
    flag.takedamage = DAMAGE_NO;
    flag.solid = SOLID_NOT;
    flag.angles = '0 0 0';
    flag.ctf_status = FLAG_CARRY;

    // messages and sounds
    _sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTEN_NORM);
    ctf_EventLog("receive", flag.team, player);

    FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), {
        if(it == sender)
            Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_NUM(flag.team, CENTER_CTF_PASS_SENT), player.netname);
        else if(it == player)
            Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_NUM(flag.team, CENTER_CTF_PASS_RECEIVED), sender.netname);
        else if(SAME_TEAM(it, sender))
            Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_NUM(flag.team, CENTER_CTF_PASS_OTHER), sender.netname, player.netname);
    });

    // create new waypoint
    ctf_FlagcarrierWaypoints(player);

    sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
    player.throw_antispam = sender.throw_antispam;

    flag.pass_distance = 0;
    flag.pass_sender = NULL;
    flag.pass_target = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Return()

void ctf_Handle_Return	(	entity	flag,
		entity	player
	)

Definition at line 638 of file sv_ctf.qc.

References _sound, APP_TEAM_NUM, ATTEN_NONE, autocvar_g_ctf_flag_collect_delay, autocvar_g_ctf_score_penalty_returned, autocvar_g_ctf_score_return, CH_TRIGGER, ctf_CaptureShield_Update(), ctf_EventLog(), ctf_RespawnFlag(), GameRules_scoring_add, GameRules_scoring_add_team, IS_MONSTER, IS_PLAYER, nades_GiveBonus(), NULL, ST_SCORE, TeamScore_AddToTeam(), time, and VOL_BASE.

Referenced by ctf_FlagThink().

{
    // messages and sounds
    if(IS_MONSTER(player))
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(flag.team, INFO_CTF_RETURN_MONSTER), player.monster_name);
    }
    else if(flag.team)
    {
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_NUM(flag.team, CENTER_CTF_RETURN));
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(flag.team, INFO_CTF_RETURN), player.netname);
    }
    _sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTEN_NONE);
    ctf_EventLog("return", flag.team, player);

    // scoring
    if(IS_PLAYER(player))
    {
        GameRules_scoring_add_team(player, SCORE, ((flag.score_return) ? flag.score_return : autocvar_g_ctf_score_return)); // reward for return
        GameRules_scoring_add(player, CTF_RETURNS, 1); // add to count of returns

        nades_GiveBonus(player,autocvar_g_nades_bonus_score_medium);
    }

    TeamScore_AddToTeam(flag.team, ST_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the team who was last carrying it

    if(flag.ctf_dropper)
    {
        GameRules_scoring_add(flag.ctf_dropper, SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the player who dropped the flag
        ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
        flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
    }

    // other
    if(player.flagcarried == flag)
        WaypointSprite_Kill(player.wps_flagcarrier);

    flag.enemy = player;

    // reset the flag
    ctf_RespawnFlag(flag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Handle_Throw()

void ctf_Handle_Throw	(	entity	player,
		entity	receiver,
		int	droptype
	)

Definition at line 444 of file sv_ctf.qc.

References _sound, ATTEN_NORM, autocvar_g_ctf_drop_velocity_side, autocvar_g_ctf_drop_velocity_up, autocvar_g_ctf_throw_angle_max, autocvar_g_ctf_throw_angle_min, autocvar_g_ctf_throw_strengthmultiplier, autocvar_g_ctf_throw_velocity_forward, autocvar_g_ctf_throw_velocity_up, bound(), CH_TRIGGER, crandom, ctf_CalculatePassVelocity(), ctf_CaptureShield_Update(), ctf_EventLog(), ctf_Handle_Drop(), ctf_RespawnFlag(), DAMAGE_NO, DROP_NORMAL, DROP_PASS, DROP_RESET, DROP_THROW, entity(), FL_ITEM, FL_NOTARGET, FLAG_DROP_OFFSET, FLAG_PASSING, GameRules_scoring_vip(), makevectors, MOVE_NOMONSTERS, MOVETYPE_FLY, nades_GiveBonus(), navigation_dynamicgoal_set(), NULL, set_movetype(), setorigin(), SOLID_TRIGGER, time, trace_endpos, v_forward, vector(), vlen(), VOL_BASE, W_CalculateProjectileVelocity(), WarpZone_RefSys_AddInverse(), WarpZone_RefSys_Copy(), WarpZone_RefSys_TransformOrigin(), and WarpZone_TrailParticles().

Referenced by ctf_FlagThink(), ctf_RemovePlayer(), ctf_Reset(), and MUTATOR_HOOKFUNCTION().

{
    entity flag = player.flagcarried;
    vector targ_origin, flag_velocity;

    if(!flag) { return; }
    if((droptype == DROP_PASS) && !receiver) { return; }

    if(flag.speedrunning)
    {
        // ensure old waypoints are removed before resetting the flag
        WaypointSprite_Kill(player.wps_flagcarrier);

        if(player.wps_enemyflagcarrier)
            WaypointSprite_Kill(player.wps_enemyflagcarrier);

        if(player.wps_flagreturn)
            WaypointSprite_Kill(player.wps_flagreturn);
        ctf_RespawnFlag(flag);
        return;
    }

    // reset the flag
    setattachment(flag, NULL, "");
    tracebox(player.origin - FLAG_DROP_OFFSET, flag.m_mins, flag.m_maxs, player.origin + FLAG_DROP_OFFSET, MOVE_NOMONSTERS, flag);
    setorigin(flag, trace_endpos);
    flag.owner.flagcarried = NULL;
    GameRules_scoring_vip(flag.owner, false);
    flag.owner = NULL;
    flag.solid = SOLID_TRIGGER;
    flag.ctf_dropper = player;
    flag.ctf_droptime = time;

    flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS

    switch(droptype)
    {
        case DROP_PASS:
        {
            // warpzone support:
            // for the examples, we assume player -> wz1 -> ... -> wzn -> receiver
            // findradius has already put wzn ... wz1 into receiver's warpzone parameters!
            WarpZone_RefSys_Copy(flag, receiver);
            WarpZone_RefSys_AddInverse(flag, receiver); // wz1^-1 ... wzn^-1 receiver
            targ_origin = WarpZone_RefSys_TransformOrigin(receiver, flag, (0.5 * (receiver.absmin + receiver.absmax))); // this is target origin as seen by the flag

            flag.pass_distance = vlen((('1 0 0' * targ_origin.x) + ('0 1 0' * targ_origin.y)) - (('1 0 0' *  player.origin.x) + ('0 1 0' *  player.origin.y))); // for the sake of this check, exclude Z axis
            ctf_CalculatePassVelocity(flag, targ_origin, player.origin, false);

            // main
            set_movetype(flag, MOVETYPE_FLY);
            flag.takedamage = DAMAGE_NO;
            flag.pass_sender = player;
            flag.pass_target = receiver;
            flag.ctf_status = FLAG_PASSING;

            // other
            _sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTEN_NORM);
            WarpZone_TrailParticles(NULL, _particleeffectnum(flag.passeffect), player.origin, targ_origin);
            ctf_EventLog("pass", flag.team, player);
            break;
        }

        case DROP_THROW:
        {
            makevectors((player.v_angle.y * '0 1 0') + (bound(autocvar_g_ctf_throw_angle_min, player.v_angle.x, autocvar_g_ctf_throw_angle_max) * '1 0 0'));

            flag_velocity = (('0 0 1' * autocvar_g_ctf_throw_velocity_up) + ((v_forward * autocvar_g_ctf_throw_velocity_forward) * ((StatusEffects_active(STATUSEFFECT_Strength, player)) ? autocvar_g_ctf_throw_strengthmultiplier : 1)));
            flag.velocity = W_CalculateProjectileVelocity(player, player.velocity, flag_velocity, false);
            ctf_Handle_Drop(flag, player, droptype);
            navigation_dynamicgoal_set(flag, player);
            break;
        }

        case DROP_RESET:
        {
            flag.velocity = '0 0 0'; // do nothing
            break;
        }

        default:
        case DROP_NORMAL:
        {
            flag.velocity = W_CalculateProjectileVelocity(player, player.velocity, (('0 0 1' * autocvar_g_ctf_drop_velocity_up) + ((('0 1 0' * crandom()) + ('1 0 0' * crandom())) * autocvar_g_ctf_drop_velocity_side)), false);
            ctf_Handle_Drop(flag, player, droptype);
            navigation_dynamicgoal_set(flag, player);
            break;
        }
    }

    // kill old waypointsprite
    WaypointSprite_Ping(player.wps_flagcarrier);
    WaypointSprite_Kill(player.wps_flagcarrier);

    if(player.wps_enemyflagcarrier)
        WaypointSprite_Kill(player.wps_enemyflagcarrier);

    if(player.wps_flagreturn)
        WaypointSprite_Kill(player.wps_flagreturn);

    // captureshield
    ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Immediate_Return_Allowed()

bool ctf_Immediate_Return_Allowed	(	entity	flag,
		entity	toucher
	)

Definition at line 141 of file sv_ctf.qc.

References autocvar_g_ctf_flag_return, autocvar_g_ctf_flag_return_carrying, FOREACH_CLIENT, IS_PLAYER, and SAME_TEAM.

Referenced by ctf_FlagThink().

{
    int num_perteam = 0;
    FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(toucher, it), { ++num_perteam; });

    // automatically return if there's only 1 player on the team
    return ((autocvar_g_ctf_flag_return || num_perteam <= 1 || (autocvar_g_ctf_flag_return_carrying && toucher.flagcarried))
        && flag.team);
}

Here is the caller graph for this function:

ctf_Initialize()

void ctf_Initialize

(

)

Definition at line 2820 of file sv_ctf.qc.

References autocvar_g_ctf_shield_force, autocvar_g_ctf_shield_max_ratio, autocvar_g_ctf_shield_min_negscore, ctf_captimerecord, ctf_captureshield_force, ctf_captureshield_max_ratio, ctf_captureshield_min_negscore, ctf_DelayedInit(), CTF_FLAG, CTF_RECORD, db_get(), GetMapname(), InitializeEntity(), NEW, NULL, record_type, ServerProgsDB, stof(), and strcat().

Referenced by REGISTER_MUTATOR().

{
    CTF_FLAG = NEW(Flag);
    record_type = CTF_RECORD;
    ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));

    ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
    ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
    ctf_captureshield_force = autocvar_g_ctf_shield_force;

    InitializeEntity(NULL, ctf_DelayedInit, INITPRIO_GAMETYPE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_RemovePlayer()

void ctf_RemovePlayer

(

entity

player

)

Definition at line 2270 of file sv_ctf.qc.

References ctf_Handle_Throw(), ctf_worldflaglist, DROP_NORMAL, entity(), and NULL.

Referenced by MUTATOR_HOOKFUNCTION().

{
    if(player.flagcarried)
        { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }

    for(entity flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
    {
        if(flag.pass_sender == player) { flag.pass_sender = NULL; }
        if(flag.pass_target == player) { flag.pass_target = NULL; }
        if(flag.ctf_dropper == player) { flag.ctf_dropper = NULL; }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Reset()

void ctf_Reset

(

entity

this

)

Definition at line 1219 of file sv_ctf.qc.

References ctf_Handle_Throw(), ctf_RespawnFlag(), DROP_RESET, enemy, IS_PLAYER, NULL, and owner.

Referenced by ctf_FlagSetup().

{
    if(this.owner && IS_PLAYER(this.owner))
        ctf_Handle_Throw(this.owner, NULL, DROP_RESET);

    this.enemy = NULL;
    ctf_RespawnFlag(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_RespawnFlag()

void ctf_RespawnFlag

(

entity

flag

)

Definition at line 1163 of file sv_ctf.qc.

References backtrace, CONTENT_EMPTY, ctf_CheckStalemate(), ctf_FakeTimeLimit(), DAMAGE_NO, FL_ITEM, FL_NOTARGET, FLAG_BASE, FLAG_DROPPED, FLAG_SCALE, GameRules_scoring_vip(), MOVETYPE_NONE, navigation_dynamicgoal_unset(), NULL, RES_HEALTH, set_movetype(), setorigin(), SetResourceExplicit(), SOLID_TRIGGER, and time.

Referenced by ctf_CheckFlagReturn(), ctf_Handle_Capture(), ctf_Handle_Return(), ctf_Handle_Throw(), ctf_Reset(), MUTATOR_HOOKFUNCTION(), and REGISTER_MUTATOR().

{
    flag.watertype = CONTENT_EMPTY; // TODO: it is unclear why this workaround is needed, likely many other potential breakage points!!
    // check for flag respawn being called twice in a row
    if(flag.last_respawn > time - 0.5)
        { backtrace("flag respawn called twice quickly! please notify Samual about this..."); }

    flag.last_respawn = time;

    // reset the player (if there is one)
    if((flag.owner) && (flag.owner.flagcarried == flag))
    {
        WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
        WaypointSprite_Kill(flag.owner.wps_flagreturn);
        WaypointSprite_Kill(flag.wps_flagcarrier);

        flag.owner.flagcarried = NULL;
        GameRules_scoring_vip(flag.owner, false);

        if(flag.speedrunning)
            ctf_FakeTimeLimit(flag.owner, -1);
    }

    if((flag.owner) && (flag.owner.vehicle))
        flag.scale = FLAG_SCALE;

    if(flag.ctf_status == FLAG_DROPPED)
        { WaypointSprite_Kill(flag.wps_flagdropped); }

    // reset the flag
    setattachment(flag, NULL, "");
    setorigin(flag, flag.ctf_spawnorigin);

    //set_movetype(flag, ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS)); // would be desired, except maps that want floating flags have it set to fall!
    set_movetype(flag, MOVETYPE_NONE); // match the initial setup handling (flag doesn't move when spawned)
    flag.takedamage = DAMAGE_NO;
    SetResourceExplicit(flag, RES_HEALTH, flag.max_health);
    flag.solid = SOLID_TRIGGER;
    flag.velocity = '0 0 0';
    flag.angles = flag.mangle;
    flag.flags = FL_ITEM | FL_NOTARGET;

    flag.ctf_status = FLAG_BASE;
    flag.owner = NULL;
    flag.pass_distance = 0;
    flag.pass_sender = NULL;
    flag.pass_target = NULL;
    flag.ctf_dropper = NULL;
    flag.ctf_pickuptime = 0;
    flag.ctf_droptime = 0;
    flag.ctf_flagdamaged_byworld = false;
    navigation_dynamicgoal_unset(flag);

    ctf_CheckStalemate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Return_Customize()

bool ctf_Return_Customize	(	entity	this,
		entity	client
	)

Definition at line 151 of file sv_ctf.qc.

References boolean, and owner.

Referenced by ctf_FlagcarrierWaypoints().

{
    // only to the carrier
    return boolean(client == this.owner);
}

Here is the caller graph for this function:

ctf_ScoreRules()

void ctf_ScoreRules

(

int

teams

)

Definition at line 2749 of file sv_ctf.qc.

References GameRules_scoring, SFL_LOWER_IS_BETTER, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_SECONDARY, SFL_TIME, and ST_CTF_CAPS.

Referenced by ctf_DelayedInit().

{
    GameRules_scoring(teams, SFL_SORT_PRIO_PRIMARY, 0, {
        field_team(ST_CTF_CAPS, "caps", SFL_SORT_PRIO_PRIMARY);
        field(SP_CTF_CAPS, "caps", SFL_SORT_PRIO_SECONDARY);
        field(SP_CTF_CAPTIME, "captime", SFL_LOWER_IS_BETTER | SFL_TIME);
        field(SP_CTF_PICKUPS, "pickups", 0);
        field(SP_CTF_FCKILLS, "fckills", 0);
        field(SP_CTF_RETURNS, "returns", 0);
        field(SP_CTF_DROPS, "drops", SFL_LOWER_IS_BETTER);
    });
}

Here is the caller graph for this function:

ctf_SpawnTeam()

void ctf_SpawnTeam	(	string	teamname,
		int	teamcolor
	)

Definition at line 2763 of file sv_ctf.qc.

References cnt, entity(), netname, new_pure, and team.

Referenced by ctf_DelayedInit().

{
    entity this = new_pure(ctf_team);
    this.netname = teamname;
    this.cnt = teamcolor - 1;
    this.spawnfunc_checked = true;
    this.team = teamcolor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctf_Stalemate_Customize()

bool ctf_Stalemate_Customize	(	entity	this,
		entity	client
	)

Definition at line 822 of file sv_ctf.qc.

References entity(), IS_PLAYER, owner, and SAME_TEAM.

Referenced by ctf_CheckStalemate(), and ctf_FlagcarrierWaypoints().

{
    // make spectators see what the player would see
    entity e = WaypointSprite_getviewentity(client);
    entity wp_owner = this.owner;

    // team waypoints
    //if(CTF_SAMETEAM(wp_owner.flagcarried, wp_owner)) { return false; }
    if(SAME_TEAM(wp_owner, e)) { return false; }
    if(!IS_PLAYER(e)) { return false; }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_calculate_middlepoint()

void havocbot_ctf_calculate_middlepoint

(

)

Definition at line 1396 of file sv_ctf.qc.

References ctf_worldflaglist, entity(), f1, f2, FLOAT_EPSILON, havocbot_middlepoint, havocbot_middlepoint_radius, havocbot_symmetry_axis_m, havocbot_symmetry_axis_q, havocbot_symmetry_origin_order, max(), vector(), and vlen().

Referenced by ctf_DelayedInit().

{
    entity f;
    vector s = '0 0 0';
    vector fo = '0 0 0';
    int n = 0;

    f = ctf_worldflaglist;
    while (f)
    {
        fo = f.origin;
        s = s + fo;
        f = f.ctf_worldflagnext;
        n++;
    }
    if(!n)
        return;

    havocbot_middlepoint = s / n;
    havocbot_middlepoint_radius = vlen(fo - havocbot_middlepoint);

    havocbot_symmetry_axis_m = 0;
    havocbot_symmetry_axis_q = 0;
    if(n == 2)
    {
        // for symmetrical editing of waypoints
        entity f1 = ctf_worldflaglist;
        entity f2 = f1.ctf_worldflagnext;
        float m = -(f1.origin.y - f2.origin.y) / (max(f1.origin.x - f2.origin.x, FLOAT_EPSILON));
        float q = havocbot_middlepoint.y - m * havocbot_middlepoint.x;
        havocbot_symmetry_axis_m = m;
        havocbot_symmetry_axis_q = q;
    }
    havocbot_symmetry_origin_order = n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_find_enemy_flag()

entity havocbot_ctf_find_enemy_flag

(

entity

bot

)

Definition at line 1446 of file sv_ctf.qc.

References CTF_DIFFTEAM, ctf_oneflag, ctf_worldflaglist, entity(), and NULL.

Referenced by havocbot_ctf_reset_role(), havocbot_goalrating_ctf_enemybase(), havocbot_role_ctf_escort(), havocbot_role_ctf_offense(), and havocbot_role_ctf_retriever().

{
    entity f;
    f = ctf_worldflaglist;
    while (f)
    {
        if(ctf_oneflag)
        {
            if(CTF_DIFFTEAM(bot, f))
            {
                if(f.team)
                {
                    if(bot.flagcarried)
                        return f;
                }
                else if(!bot.flagcarried)
                    return f;
            }
        }
        else if (CTF_DIFFTEAM(bot, f))
            return f;
        f = f.ctf_worldflagnext;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_find_flag()

entity havocbot_ctf_find_flag

(

entity

bot

)

Definition at line 1433 of file sv_ctf.qc.

References CTF_SAMETEAM, ctf_worldflaglist, entity(), and NULL.

Referenced by havocbot_ctf_reset_role(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), and havocbot_role_ctf_retriever().

{
    entity f;
    f = ctf_worldflaglist;
    while (f)
    {
        if (CTF_SAMETEAM(bot, f))
            return f;
        f = f.ctf_worldflagnext;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_is_basewaypoint()

bool havocbot_ctf_is_basewaypoint

(

entity

item

)

Definition at line 1702 of file sv_ctf.qc.

References ctf_worldflaglist, and entity().

Referenced by havocbot_role_ctf_carrier(), and havocbot_role_ctf_middle().

{
    if (item.classname != "waypoint")
        return false;

    entity head = ctf_worldflaglist;
    while (head)
    {
        if (item == head.bot_basewaypoint)
            return true;
        head = head.ctf_worldflagnext;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_reset_role()

void havocbot_ctf_reset_role

(

entity

this

)

Definition at line 1623 of file sv_ctf.qc.

References count, CS(), entity(), FLAG_BASE, flagcarried, FOREACH_CLIENT, havocbot_ctf_find_enemy_flag(), havocbot_ctf_find_flag(), HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_DEFENSE, HAVOCBOT_CTF_ROLE_MIDDLE, HAVOCBOT_CTF_ROLE_OFFENSE, HAVOCBOT_CTF_ROLE_RETRIEVER, havocbot_ctf_teamcount(), havocbot_middlepoint, havocbot_middlepoint_radius, havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, IS_PLAYER, jointime, random(), SAME_TEAM, and time.

Referenced by havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), and MUTATOR_HOOKFUNCTION().

{
    float cdefense, cmiddle, coffense;
    entity mf, ef;

    if(IS_DEAD(this))
        return;

    // Check ctf flags
    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    mf = havocbot_ctf_find_flag(this);
    ef = havocbot_ctf_find_enemy_flag(this);

    // Retrieve stolen flag
    if(mf.ctf_status!=FLAG_BASE)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
        return;
    }

    // If enemy flag is taken go to the middle to intercept pursuers
    if(ef.ctf_status!=FLAG_BASE)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);
        return;
    }

    // if there is no one else on the team switch to offense
    int count = 0;
    // don't check if this bot is a player since it isn't true when the bot is added to the server
    FOREACH_CLIENT(it != this && IS_PLAYER(it) && SAME_TEAM(it, this), { ++count; });

    if (count == 0)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_OFFENSE);
        return;
    }
    else if (time < CS(this).jointime + 1)
    {
        // if bots spawn all at once set good default roles
        if (count == 1)
        {
            havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_DEFENSE);
            return;
        }
        else if (count == 2)
        {
            havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);
            return;
        }
    }

    // Evaluate best position to take
    // Count mates on middle position
    cmiddle = havocbot_ctf_teamcount(this, havocbot_middlepoint, havocbot_middlepoint_radius * 0.5);

    // Count mates on defense position
    cdefense = havocbot_ctf_teamcount(this, mf.dropped_origin, havocbot_middlepoint_radius * 0.5);

    // Count mates on offense position
    coffense = havocbot_ctf_teamcount(this, ef.dropped_origin, havocbot_middlepoint_radius);

    if(cdefense<=coffense)
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_DEFENSE);
    else if(coffense<=cmiddle)
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_OFFENSE);
    else
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);

    // if bots spawn all at once assign them a more appropriated role after a while
    if (time < CS(this).jointime + 1 && count > 2)
        this.havocbot_role_timeout = time + 10 + random() * 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_ctf_teamcount()

int havocbot_ctf_teamcount	(	entity	bot,
		vector	org,
		float	tc_radius
	)

Definition at line 1472 of file sv_ctf.qc.

References CTF_SAMETEAM, ctf_worldflaglist, DIFF_TEAM, entity(), FOREACH_CLIENT, IS_DEAD, IS_PLAYER, navigation_routerating(), teamplay, and vdist.

Referenced by havocbot_ctf_reset_role().

{
    if (!teamplay)
        return 0;

    int c = 0;

    FOREACH_CLIENT(IS_PLAYER(it), {
        if(DIFF_TEAM(it, bot) || IS_DEAD(it) || it == bot)
            continue;

        if(vdist(it.origin - org, <, tc_radius))
            ++c;
    });

    return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_goalrating_ctf_droppedflags()

void havocbot_goalrating_ctf_droppedflags	(	entity	this,
		float	ratingscale,
		vector	org,
		float	df_radius
	)

Definition at line 1600 of file sv_ctf.qc.

References ctf_worldflaglist, entity(), FLAG_BASE, navigation_routerating(), NULL, and vdist.

Referenced by havocbot_role_ctf_defense(), havocbot_role_ctf_middle(), and havocbot_role_ctf_retriever().

{
    entity head;
    head = ctf_worldflaglist;
    while (head)
    {
        // flag is out in the field
        if(head.ctf_status != FLAG_BASE)
        if(head.tag_entity==NULL)   // dropped
        {
            if(df_radius)
            {
                if(vdist(org - head.origin, <, df_radius))
                    navigation_routerating(this, head, ratingscale, 10000);
            }
            else
                navigation_routerating(this, head, ratingscale, 10000);
        }

        head = head.ctf_worldflagnext;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_goalrating_ctf_enemybase()

void havocbot_goalrating_ctf_enemybase	(	entity	this,
		float	ratingscale
	)

Definition at line 1567 of file sv_ctf.qc.

References entity(), havocbot_ctf_find_enemy_flag(), and navigation_routerating().

Referenced by havocbot_role_ctf_carrier(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), and havocbot_role_ctf_retriever().

{
    // disabled because we always spawn waypoints for flags with waypoint_spawnforitem_force
    /*
    if (!bot_waypoints_for_items)
    {
        havocbot_goalrating_ctf_enemyflag(this, ratingscale);
        return;
    }
    */
    entity head;

    head = havocbot_ctf_find_enemy_flag(this);

    if (!head)
        return;

    navigation_routerating(this, head.bot_basewaypoint, ratingscale, 10000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_goalrating_ctf_enemyflag()

void havocbot_goalrating_ctf_enemyflag	(	entity	this,
		float	ratingscale
	)

Definition at line 1531 of file sv_ctf.qc.

References bound(), CTF_DIFFTEAM, ctf_oneflag, ctf_worldflaglist, entity(), FLAG_CARRY, flagcarried, GetResource(), navigation_routerating(), and RES_HEALTH.

Referenced by havocbot_role_ctf_escort().

{
    entity head;
    head = ctf_worldflaglist;
    while (head)
    {
        if(ctf_oneflag)
        {
            if(CTF_DIFFTEAM(this, head))
            {
                if(head.team)
                {
                    if(this.flagcarried)
                        break;
                }
                else if(!this.flagcarried)
                    break;
            }
        }
        else if(CTF_DIFFTEAM(this, head))
            break;
        head = head.ctf_worldflagnext;
    }
    if (head)
    {
        if (head.ctf_status == FLAG_CARRY)
        {
            // adjust rating of our flag carrier depending on his health
            head = head.tag_entity;
            float f = bound(0, (GetResource(head, RES_HEALTH) + GetResource(head, RES_ARMOR)) / 100, 2) - 1;
            ratingscale += ratingscale * f * 0.1;
        }
        navigation_routerating(this, head, ratingscale, 10000);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_goalrating_ctf_ourbase()

void havocbot_goalrating_ctf_ourbase	(	entity	this,
		float	ratingscale
	)

Definition at line 1507 of file sv_ctf.qc.

References CTF_SAMETEAM, ctf_worldflaglist, entity(), flagcarried, and navigation_routerating().

Referenced by havocbot_role_ctf_carrier(), and havocbot_role_ctf_defense().

{
    entity head;
    head = ctf_worldflaglist;
    while (head)
    {
        if (CTF_SAMETEAM(this, head))
        {
            if (this.flagcarried)
            if ((this.flagcarried.cnt || head.cnt) && this.flagcarried.cnt != head.cnt)
            {
                head = head.ctf_worldflagnext; // skip base if it has a different group
                continue;
            }
            break;
        }
        head = head.ctf_worldflagnext;
    }
    if (!head)
        return;

    navigation_routerating(this, head.bot_basewaypoint, ratingscale, 10000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_goalrating_ctf_ourstolenflag()

void havocbot_goalrating_ctf_ourstolenflag	(	entity	this,
		float	ratingscale
	)

Definition at line 1587 of file sv_ctf.qc.

References entity(), FLAG_BASE, havocbot_ctf_find_flag(), and navigation_routerating().

Referenced by havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), and havocbot_role_ctf_retriever().

{
    entity mf;

    mf = havocbot_ctf_find_flag(this);

    if(mf.ctf_status == FLAG_BASE)
        return;

    if(mf.tag_entity)
        navigation_routerating(this, mf.tag_entity, ratingscale, 10000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_carrier()

void havocbot_role_ctf_carrier

(

entity

this

)

Definition at line 1717 of file sv_ctf.qc.

References bot_aimtarg, ctf_oneflag, Damage(), DMG_NOWEP, entity(), FLAG_BASE, flagcarried, goalentity, goalentity_lock_timeout, havocbot_cantfindflag, havocbot_ctf_find_flag(), havocbot_ctf_is_basewaypoint(), havocbot_ctf_reset_role(), havocbot_goalrating_ctf_enemybase(), havocbot_goalrating_ctf_ourbase(), havocbot_goalrating_items(), havocbot_middlepoint_radius, IS_DEAD, min(), navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), NULL, origin, time, vdist, and vector().

Referenced by havocbot_role_ctf_setrole().

{
    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried == NULL)
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (navigation_goalrating_timeout(this))
    {
        navigation_goalrating_start(this);

        // role: carrier
        entity mf = havocbot_ctf_find_flag(this);
        vector base_org = mf.dropped_origin;
        float base_rating = (mf.ctf_status == FLAG_BASE) ? 10000 : (vdist(this.origin - base_org, >, 100) ? 2000 : 1000);
        if(ctf_oneflag)
            havocbot_goalrating_ctf_enemybase(this, base_rating);
        else
            havocbot_goalrating_ctf_ourbase(this, base_rating);

        // start collecting items very close to the bot but only inside of own base radius
        if (vdist(this.origin - base_org, <, havocbot_middlepoint_radius))
            havocbot_goalrating_items(this, 15000, this.origin, min(500, havocbot_middlepoint_radius * 0.5));

        havocbot_goalrating_items(this, 10000, base_org, havocbot_middlepoint_radius * 0.5);

        navigation_goalrating_end(this);

        navigation_goalrating_timeout_set(this);

        entity goal = this.goalentity;
        if (havocbot_ctf_is_basewaypoint(goal) && vdist(goal.origin - this.origin, <, 100))
            this.goalentity_lock_timeout = time + ((this.bot_aimtarg) ? 2 : 3);

        if (goal)
            this.havocbot_cantfindflag = time + 10;
        else if (time > this.havocbot_cantfindflag)
        {
            // Can't navigate to my own base, suicide!
            // TODO: drop it and wander around
            Damage(this, this, this, 100000, DEATH_KILL.m_id, DMG_NOWEP, this.origin, '0 0 0');
            return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_defense()

void havocbot_role_ctf_defense

(

entity

this

)

Definition at line 2033 of file sv_ctf.qc.

References checkpvs(), DIFF_TEAM, entity(), FLAG_BASE, flagcarried, FOREACH_CLIENT, havocbot_ctf_find_flag(), havocbot_ctf_reset_role(), HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_RETRIEVER, havocbot_goalrating_ctf_droppedflags(), havocbot_goalrating_ctf_ourbase(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_goalrating_enemyplayers(), havocbot_goalrating_items(), havocbot_middlepoint_radius, havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, IS_PLAYER, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), NULL, origin, random(), time, vdist, vector(), and vlen().

Referenced by havocbot_role_ctf_setrole().

{
    entity mf;

    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    // If own flag was captured
    mf = havocbot_ctf_find_flag(this);
    if(mf.ctf_status!=FLAG_BASE)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
        return;
    }

    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + 30;

    if (time > this.havocbot_role_timeout)
    {
        havocbot_ctf_reset_role(this);
        return;
    }
    if (navigation_goalrating_timeout(this))
    {
        vector org = mf.dropped_origin;

        navigation_goalrating_start(this);

        // if enemies are closer to our base, go there
        entity closestplayer = NULL;
        float distance, bestdistance = 10000;
        FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it), {
            distance = vlen(org - it.origin);
            if(distance<bestdistance)
            {
                closestplayer = it;
                bestdistance = distance;
            }
        });

        // role: defense
        if(closestplayer)
        if(DIFF_TEAM(closestplayer, this))
        if(vdist(org - this.origin, >, 1000))
        if(checkpvs(this.origin,closestplayer)||random()<0.5)
            havocbot_goalrating_ctf_ourbase(this, 10000);

        havocbot_goalrating_ctf_ourstolenflag(this, 5000);
        havocbot_goalrating_ctf_droppedflags(this, 6000, org, havocbot_middlepoint_radius);
        havocbot_goalrating_enemyplayers(this, 25000, org, havocbot_middlepoint_radius);
        havocbot_goalrating_items(this, 25000, org, havocbot_middlepoint_radius);
        havocbot_goalrating_items(this, 18000, this.origin, 10000);

        navigation_goalrating_end(this);

        navigation_goalrating_timeout_set(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_escort()

void havocbot_role_ctf_escort

(

entity

this

)

Definition at line 1770 of file sv_ctf.qc.

References entity(), FLAG_BASE, FLAG_DROPPED, flagcarried, havocbot_ctf_find_enemy_flag(), havocbot_ctf_find_flag(), havocbot_ctf_reset_role(), HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_DEFENSE, havocbot_goalrating_ctf_enemyflag(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_goalrating_items(), havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_expire(), navigation_goalrating_timeout_set(), origin, random(), time, and vdist.

Referenced by havocbot_role_ctf_setrole().

{
    entity mf, ef;

    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    // If enemy flag is back on the base switch to previous role
    ef = havocbot_ctf_find_enemy_flag(this);
    if(ef.ctf_status==FLAG_BASE)
    {
        this.havocbot_role = this.havocbot_previous_role;
        this.havocbot_role_timeout = 0;
        return;
    }
    if (ef.ctf_status == FLAG_DROPPED)
    {
        navigation_goalrating_timeout_expire(this, 1);
        return;
    }

    // If the flag carrier reached the base switch to defense
    mf = havocbot_ctf_find_flag(this);
    if (mf.ctf_status != FLAG_BASE && vdist(ef.origin - mf.dropped_origin, <, 900))
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_DEFENSE);
        return;
    }

    // Set the role timeout if necessary
    if (!this.havocbot_role_timeout)
    {
        this.havocbot_role_timeout = time + random() * 30 + 60;
    }

    // If nothing happened just switch to previous role
    if (time > this.havocbot_role_timeout)
    {
        this.havocbot_role = this.havocbot_previous_role;
        this.havocbot_role_timeout = 0;
        return;
    }

    // Chase the flag carrier
    if (navigation_goalrating_timeout(this))
    {
        navigation_goalrating_start(this);

        // role: escort
        havocbot_goalrating_ctf_enemyflag(this, 10000);
        havocbot_goalrating_ctf_ourstolenflag(this, 6000);
        havocbot_goalrating_items(this, 21000, this.origin, 10000);

        navigation_goalrating_end(this);

        navigation_goalrating_timeout_set(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_middle()

void havocbot_role_ctf_middle

(

entity

this

)

Definition at line 1974 of file sv_ctf.qc.

References entity(), FLAG_BASE, flagcarried, goalentity, goalentity_lock_timeout, havocbot_ctf_find_flag(), havocbot_ctf_is_basewaypoint(), havocbot_ctf_reset_role(), HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_RETRIEVER, havocbot_goalrating_ctf_droppedflags(), havocbot_goalrating_ctf_enemybase(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_goalrating_enemyplayers(), havocbot_goalrating_items(), havocbot_middlepoint, havocbot_middlepoint_radius, havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), origin, time, vdist, and vector().

Referenced by havocbot_role_ctf_setrole().

{
    entity mf;

    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    mf = havocbot_ctf_find_flag(this);
    if(mf.ctf_status!=FLAG_BASE)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
        return;
    }

    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + 10;

    if (time > this.havocbot_role_timeout)
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (navigation_goalrating_timeout(this))
    {
        vector org;

        org = havocbot_middlepoint;
        org.z = this.origin.z;

        navigation_goalrating_start(this);

        // role: middle
        havocbot_goalrating_ctf_ourstolenflag(this, 8000);
        havocbot_goalrating_ctf_droppedflags(this, 9000, this.origin, 10000);
        havocbot_goalrating_enemyplayers(this, 25000, org, havocbot_middlepoint_radius * 0.5);
        havocbot_goalrating_items(this, 25000, org, havocbot_middlepoint_radius * 0.5);
        havocbot_goalrating_items(this, 18000, this.origin, 10000);
        havocbot_goalrating_ctf_enemybase(this, 3000);

        navigation_goalrating_end(this);

        entity goal = this.goalentity;
        if (havocbot_ctf_is_basewaypoint(goal) && vdist(goal.origin - this.origin, <, 100))
            this.goalentity_lock_timeout = time + 2;

        navigation_goalrating_timeout_set(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_offense()

void havocbot_role_ctf_offense

(

entity

this

)

Definition at line 1838 of file sv_ctf.qc.

References entity(), FLAG_BASE, flagcarried, havocbot_ctf_find_enemy_flag(), havocbot_ctf_find_flag(), havocbot_ctf_reset_role(), HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_ESCORT, HAVOCBOT_CTF_ROLE_RETRIEVER, havocbot_goalrating_ctf_enemybase(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_goalrating_items(), havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), origin, time, vdist, vector(), and vlen2.

Referenced by havocbot_role_ctf_setrole().

{
    entity mf, ef;
    vector pos;

    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    // Check flags
    mf = havocbot_ctf_find_flag(this);
    ef = havocbot_ctf_find_enemy_flag(this);

    // Own flag stolen
    if(mf.ctf_status!=FLAG_BASE)
    {
        if(mf.tag_entity)
            pos = mf.tag_entity.origin;
        else
            pos = mf.origin;

        // Try to get it if closer than the enemy base
        if(vlen2(this.origin-ef.dropped_origin)>vlen2(this.origin-pos))
        {
            havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
            return;
        }
    }

    // Escort flag carrier
    if(ef.ctf_status!=FLAG_BASE)
    {
        if(ef.tag_entity)
            pos = ef.tag_entity.origin;
        else
            pos = ef.origin;

        if(vdist(pos - mf.dropped_origin, >, 700))
        {
            havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_ESCORT);
            return;
        }
    }

    // Set the role timeout if necessary
    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + 120;

    if (time > this.havocbot_role_timeout)
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (navigation_goalrating_timeout(this))
    {
        navigation_goalrating_start(this);

        // role: offense
        havocbot_goalrating_ctf_ourstolenflag(this, 10000);
        havocbot_goalrating_ctf_enemybase(this, 10000);
        havocbot_goalrating_items(this, 22000, this.origin, 10000);

        navigation_goalrating_end(this);

        navigation_goalrating_timeout_set(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_retriever()

void havocbot_role_ctf_retriever

(

entity

this

)

Definition at line 1916 of file sv_ctf.qc.

References entity(), FLAG_BASE, flagcarried, havocbot_ctf_find_enemy_flag(), havocbot_ctf_find_flag(), havocbot_ctf_reset_role(), HAVOCBOT_CTF_ROLE_CARRIER, havocbot_goalrating_ctf_droppedflags(), havocbot_goalrating_ctf_enemybase(), havocbot_goalrating_ctf_ourstolenflag(), havocbot_goalrating_items(), havocbot_middlepoint_radius, havocbot_role_ctf_setrole(), havocbot_role_timeout, IS_DEAD, min(), navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_force(), navigation_goalrating_timeout_set(), origin, time, vdist, and vector().

Referenced by havocbot_role_ctf_setrole().

{
    entity mf;

    if(IS_DEAD(this))
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (this.flagcarried)
    {
        havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
        return;
    }

    // If flag is back on the base switch to previous role
    mf = havocbot_ctf_find_flag(this);
    if(mf.ctf_status==FLAG_BASE)
    {
        if (mf.enemy == this) // did this bot return the flag?
            navigation_goalrating_timeout_force(this);
        havocbot_ctf_reset_role(this);
        return;
    }

    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + 20;

    if (time > this.havocbot_role_timeout)
    {
        havocbot_ctf_reset_role(this);
        return;
    }

    if (navigation_goalrating_timeout(this))
    {
        const float RT_RADIUS = 10000;

        navigation_goalrating_start(this);

        // role: retriever
        havocbot_goalrating_ctf_ourstolenflag(this, 10000);
        havocbot_goalrating_ctf_droppedflags(this, 12000, this.origin, RT_RADIUS);
        havocbot_goalrating_ctf_enemybase(this, 8000);
        entity ef = havocbot_ctf_find_enemy_flag(this);
        vector enemy_base_org = ef.dropped_origin;
        // start collecting items very close to the bot but only inside of enemy base radius
        if (vdist(this.origin - enemy_base_org, <, havocbot_middlepoint_radius))
            havocbot_goalrating_items(this, 27000, this.origin, min(500, havocbot_middlepoint_radius * 0.5));
        havocbot_goalrating_items(this, 18000, this.origin, havocbot_middlepoint_radius);

        navigation_goalrating_end(this);

        navigation_goalrating_timeout_set(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

havocbot_role_ctf_setrole()

void havocbot_role_ctf_setrole	(	entity	bot,
		int	role
	)

Definition at line 2102 of file sv_ctf.qc.

References HAVOCBOT_CTF_ROLE_CARRIER, HAVOCBOT_CTF_ROLE_DEFENSE, HAVOCBOT_CTF_ROLE_ESCORT, HAVOCBOT_CTF_ROLE_MIDDLE, HAVOCBOT_CTF_ROLE_OFFENSE, HAVOCBOT_CTF_ROLE_RETRIEVER, havocbot_role_ctf_carrier(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), havocbot_role_ctf_retriever(), LOG_TRACE, navigation_goalrating_timeout_expire(), navigation_goalrating_timeout_force(), and time.

Referenced by havocbot_ctf_reset_role(), havocbot_role_ctf_defense(), havocbot_role_ctf_escort(), havocbot_role_ctf_middle(), havocbot_role_ctf_offense(), and havocbot_role_ctf_retriever().

{
    string s = "(null)";
    switch(role)
    {
        case HAVOCBOT_CTF_ROLE_CARRIER:
            s = "carrier";
            bot.havocbot_role = havocbot_role_ctf_carrier;
            bot.havocbot_role_timeout = 0;
            bot.havocbot_cantfindflag = time + 10;
            if (bot.havocbot_previous_role != bot.havocbot_role)
                navigation_goalrating_timeout_force(bot);
            break;
        case HAVOCBOT_CTF_ROLE_DEFENSE:
            s = "defense";
            bot.havocbot_role = havocbot_role_ctf_defense;
            bot.havocbot_role_timeout = 0;
            break;
        case HAVOCBOT_CTF_ROLE_MIDDLE:
            s = "middle";
            bot.havocbot_role = havocbot_role_ctf_middle;
            bot.havocbot_role_timeout = 0;
            break;
        case HAVOCBOT_CTF_ROLE_OFFENSE:
            s = "offense";
            bot.havocbot_role = havocbot_role_ctf_offense;
            bot.havocbot_role_timeout = 0;
            break;
        case HAVOCBOT_CTF_ROLE_RETRIEVER:
            s = "retriever";
            bot.havocbot_previous_role = bot.havocbot_role;
            bot.havocbot_role = havocbot_role_ctf_retriever;
            bot.havocbot_role_timeout = time + 10;
            if (bot.havocbot_previous_role != bot.havocbot_role)
                navigation_goalrating_timeout_expire(bot, 2);
            break;
        case HAVOCBOT_CTF_ROLE_ESCORT:
            s = "escort";
            bot.havocbot_previous_role = bot.havocbot_role;
            bot.havocbot_role = havocbot_role_ctf_escort;
            bot.havocbot_role_timeout = time + 30;
            if (bot.havocbot_previous_role != bot.havocbot_role)
                navigation_goalrating_timeout_expire(bot, 2);
            break;
    }
    LOG_TRACE(bot.netname, " switched to ", s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MUTATOR_HOOKFUNCTION() [1/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerPreThink
	)

Definition at line 2155 of file sv_ctf.qc.

References autocvar_g_balance_armor_blockpercent, ctf_stalemate, ctf_worldflaglist, entity(), FLAG_CARRY, FLAG_DROPPED, FLAG_PASSING, GetResource(), M_ARGV, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, and RES_HEALTH.

{
    entity player = M_ARGV(0, entity);

    int t = 0, t2 = 0, t3 = 0;
    bool b1 = false, b2 = false, b3 = false, b4 = false, b5 = false; // TODO: kill this, we WANT to show the other flags, somehow! (note: also means you don't see if you're FC)

    // initially clear items so they can be set as necessary later.
    STAT(OBJECTIVE_STATUS, player) &= ~(CTF_RED_FLAG_CARRYING       | CTF_RED_FLAG_TAKEN        | CTF_RED_FLAG_LOST
                           | CTF_BLUE_FLAG_CARRYING     | CTF_BLUE_FLAG_TAKEN       | CTF_BLUE_FLAG_LOST
                           | CTF_YELLOW_FLAG_CARRYING   | CTF_YELLOW_FLAG_TAKEN     | CTF_YELLOW_FLAG_LOST
                           | CTF_PINK_FLAG_CARRYING     | CTF_PINK_FLAG_TAKEN       | CTF_PINK_FLAG_LOST
                           | CTF_NEUTRAL_FLAG_CARRYING  | CTF_NEUTRAL_FLAG_TAKEN    | CTF_NEUTRAL_FLAG_LOST
                           | CTF_FLAG_NEUTRAL | CTF_SHIELDED | CTF_STALEMATE);

    // scan through all the flags and notify the client about them
    for(entity flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
    {
        if(flag.team == NUM_TEAM_1 && !b1) { b1 = true; t = CTF_RED_FLAG_CARRYING;      t2 = CTF_RED_FLAG_TAKEN;        t3 = CTF_RED_FLAG_LOST; }
        if(flag.team == NUM_TEAM_2 && !b2) { b2 = true; t = CTF_BLUE_FLAG_CARRYING;     t2 = CTF_BLUE_FLAG_TAKEN;       t3 = CTF_BLUE_FLAG_LOST; }
        if(flag.team == NUM_TEAM_3 && !b3) { b3 = true; t = CTF_YELLOW_FLAG_CARRYING;   t2 = CTF_YELLOW_FLAG_TAKEN;     t3 = CTF_YELLOW_FLAG_LOST; }
        if(flag.team == NUM_TEAM_4 && !b4) { b4 = true; t = CTF_PINK_FLAG_CARRYING;     t2 = CTF_PINK_FLAG_TAKEN;       t3 = CTF_PINK_FLAG_LOST; }
        if(flag.team == 0 && !b5)          { b5 = true; t = CTF_NEUTRAL_FLAG_CARRYING;  t2 = CTF_NEUTRAL_FLAG_TAKEN;    t3 = CTF_NEUTRAL_FLAG_LOST; STAT(OBJECTIVE_STATUS, player) |= CTF_FLAG_NEUTRAL; }

        switch(flag.ctf_status)
        {
            case FLAG_PASSING:
            case FLAG_CARRY:
            {
                if((flag.owner == player) || (flag.pass_sender == player))
                    STAT(OBJECTIVE_STATUS, player) |= t; // carrying: player is currently carrying the flag
                else
                    STAT(OBJECTIVE_STATUS, player) |= t2; // taken: someone else is carrying the flag
                break;
            }
            case FLAG_DROPPED:
            {
                STAT(OBJECTIVE_STATUS, player) |= t3; // lost: the flag is dropped somewhere on the map
                break;
            }
        }
    }

    // item for stopping players from capturing the flag too often
    if(player.ctf_captureshielded)
        STAT(OBJECTIVE_STATUS, player) |= CTF_SHIELDED;

    if(ctf_stalemate)
        STAT(OBJECTIVE_STATUS, player) |= CTF_STALEMATE;

    // update the health of the flag carrier waypointsprite
    if(player.wps_flagcarrier)
        WaypointSprite_UpdateHealth(player.wps_flagcarrier, healtharmor_maxdamage(GetResource(player, RES_HEALTH), GetResource(player, RES_ARMOR), autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id).x);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [2/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		Damage_Calculate
	)

Definition at line 2210 of file sv_ctf.qc.

References autocvar_g_balance_armor_blockpercent, autocvar_g_ctf_flagcarrier_auto_helpme_damage, autocvar_g_ctf_flagcarrier_auto_helpme_time, autocvar_g_ctf_flagcarrier_damagefactor, autocvar_g_ctf_flagcarrier_forcefactor, autocvar_g_ctf_flagcarrier_selfdamagefactor, autocvar_g_ctf_flagcarrier_selfforcefactor, CTF_DIFFTEAM, entity(), GetResource(), IS_DEAD, M_ARGV, RES_HEALTH, time, and vector().

{
    entity frag_attacker = M_ARGV(1, entity);
    entity frag_target = M_ARGV(2, entity);
    float frag_damage = M_ARGV(4, float);
    vector frag_force = M_ARGV(6, vector);

    if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
    {
        if(frag_target == frag_attacker) // damage done to yourself
        {
            frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
            frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
        }
        else // damage done to everyone else
        {
            frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
            frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
        }

        M_ARGV(4, float) = frag_damage;
        M_ARGV(6, vector) = frag_force;
    }
    else if(frag_target.flagcarried && !IS_DEAD(frag_target) && CTF_DIFFTEAM(frag_target, frag_attacker)) // if the target is a flagcarrier
    {
        if(autocvar_g_ctf_flagcarrier_auto_helpme_damage > healtharmor_maxdamage(GetResource(frag_target, RES_HEALTH), GetResource(frag_target, RES_ARMOR), autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id).x
            && time > frag_target.wps_helpme_time + autocvar_g_ctf_flagcarrier_auto_helpme_time)
        {
            frag_target.wps_helpme_time = time;
            WaypointSprite_HelpMePing(frag_target.wps_flagcarrier);
        }
        // todo: add notification for when flag carrier needs help?
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [3/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerDies
	)

Definition at line 2245 of file sv_ctf.qc.

References autocvar_g_ctf_score_kill, ctf_Handle_Throw(), DROP_NORMAL, entity(), GameRules_scoring_add, GameRules_scoring_add_team, IS_PLAYER, M_ARGV, NULL, and SAME_TEAM.

{
    entity frag_attacker = M_ARGV(1, entity);
    entity frag_target = M_ARGV(2, entity);

    if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)) && (frag_target.flagcarried))
    {
        GameRules_scoring_add_team(frag_attacker, SCORE, ((SAME_TEAM(frag_attacker, frag_target)) ? -autocvar_g_ctf_score_kill : autocvar_g_ctf_score_kill));
        GameRules_scoring_add(frag_attacker, CTF_FCKILLS, 1);
    }

    if(frag_target.flagcarried)
    {
        entity tmp_entity = frag_target.flagcarried;
        ctf_Handle_Throw(frag_target, NULL, DROP_NORMAL);
        tmp_entity.ctf_dropper = NULL;
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [4/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GiveFragsForKill
	)

Definition at line 2264 of file sv_ctf.qc.

References autocvar_g_ctf_ignore_frags, and M_ARGV.

{
    M_ARGV(2, float) = 0; // frag score
    return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
}

MUTATOR_HOOKFUNCTION() [5/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		MakePlayerObserver
	)

Definition at line 2283 of file sv_ctf.qc.

References ctf_RemovePlayer(), entity(), and M_ARGV.

{
    entity player = M_ARGV(0, entity);

    ctf_RemovePlayer(player);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [6/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		ClientDisconnect
	)

Definition at line 2290 of file sv_ctf.qc.

References ctf_RemovePlayer(), entity(), and M_ARGV.

{
    entity player = M_ARGV(0, entity);

    ctf_RemovePlayer(player);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [7/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		ClientConnect
	)

Definition at line 2297 of file sv_ctf.qc.

References entity(), M_ARGV, and race_SendAll().

{
    if(!autocvar_g_ctf_leaderboard)
        return;

    entity player = M_ARGV(0, entity);

    race_SendAll(player, true);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [8/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GetPressedKeys
	)

Definition at line 2307 of file sv_ctf.qc.

References entity(), M_ARGV, and race_checkAndWriteName().

{
    if(!autocvar_g_ctf_leaderboard)
        return;

    entity player = M_ARGV(0, entity);

    race_checkAndWriteName(player);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [9/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PortalTeleport
	)

Definition at line 2317 of file sv_ctf.qc.

References autocvar_g_ctf_portalteleport, ctf_Handle_Throw(), DROP_NORMAL, entity(), M_ARGV, and NULL.

{
    entity player = M_ARGV(0, entity);

    if(player.flagcarried)
    if(!autocvar_g_ctf_portalteleport)
        { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [10/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerUseKey
	)

Definition at line 2326 of file sv_ctf.qc.

References autocvar_g_ctf_allow_vehicle_touch, autocvar_g_ctf_pass, autocvar_g_ctf_pass_radius, autocvar_g_ctf_pass_request, autocvar_g_ctf_pass_wait, autocvar_g_ctf_throw, autocvar_g_ctf_throw_punish_count, autocvar_g_ctf_throw_punish_delay, autocvar_g_ctf_throw_punish_time, CENTER_OR_VIEWOFS, ctf_CheckPassDirection(), ctf_Handle_Throw(), DROP_PASS, DROP_THROW, entity(), IS_BOT_CLIENT, IS_DEAD, IS_PLAYER, M_ARGV, MUTATOR_RETURNVALUE, NULL, rint(), SAME_TEAM, time, vector(), vlen2, WarpZone_FindRadius(), and WarpZone_UnTransformOrigin().

{
    if(MUTATOR_RETURNVALUE || game_stopped) return;

    entity player = M_ARGV(0, entity);

    if((time > player.throw_antispam) && !IS_DEAD(player) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
    {
        // pass the flag to a team mate
        if(autocvar_g_ctf_pass)
        {
            entity head, closest_target = NULL;
            head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, true);

            while(head) // find the closest acceptable target to pass to
            {
                if(IS_PLAYER(head) && !IS_DEAD(head))
                if(head != player && SAME_TEAM(head, player))
                if(!head.speedrunning && !head.vehicle)
                {
                    // if it's a player, use the view origin as reference (stolen from RadiusDamage functions in damage.qc)
                    vector head_center = WarpZone_UnTransformOrigin(head, CENTER_OR_VIEWOFS(head));
                    vector passer_center = CENTER_OR_VIEWOFS(player);

                    if(ctf_CheckPassDirection(head_center, passer_center, player.v_angle, head.WarpZone_findradius_nearest))
                    {
                        if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
                        {
                            if(IS_BOT_CLIENT(head))
                            {
                                Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
                                ctf_Handle_Throw(head, player, DROP_PASS);
                            }
                            else
                            {
                                Send_Notification(NOTIF_ONE, head, MSG_CENTER, CENTER_CTF_PASS_REQUESTED, player.netname);
                                Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
                            }
                            player.throw_antispam = time + autocvar_g_ctf_pass_wait;
                            return true;
                        }
                        else if(player.flagcarried && !head.flagcarried)
                        {
                            if(closest_target)
                            {
                                vector closest_target_center = WarpZone_UnTransformOrigin(closest_target, CENTER_OR_VIEWOFS(closest_target));
                                if(vlen2(passer_center - head_center) < vlen2(passer_center - closest_target_center))
                                    { closest_target = head; }
                            }
                            else { closest_target = head; }
                        }
                    }
                }
                head = head.chain;
            }

            if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return true; }
        }

        // throw the flag in front of you
        if(autocvar_g_ctf_throw && player.flagcarried)
        {
            if(player.throw_count == -1)
            {
                if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_delay)
                {
                    player.throw_prevtime = time;
                    player.throw_count = 1;
                    ctf_Handle_Throw(player, NULL, DROP_THROW);
                    return true;
                }
                else
                {
                    Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_FLAG_THROW_PUNISH, rint((player.throw_prevtime + autocvar_g_ctf_throw_punish_delay) - time));
                    return false;
                }
            }
            else
            {
                if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_time) { player.throw_count = 1; }
                else { player.throw_count += 1; }
                if(player.throw_count >= autocvar_g_ctf_throw_punish_count) { player.throw_count = -1; }

                player.throw_prevtime = time;
                ctf_Handle_Throw(player, NULL, DROP_THROW);
                return true;
            }
        }
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [11/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		HelpMePing
	)

Definition at line 2417 of file sv_ctf.qc.

References entity(), FLAG_WAYPOINT_OFFSET, M_ARGV, NULL, time, and wps_helpme.

{
    entity player = M_ARGV(0, entity);

    if(player.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
    {
        player.wps_helpme_time = time;
        WaypointSprite_HelpMePing(player.wps_flagcarrier);
    }
    else // create a normal help me waypointsprite
    {
        WaypointSprite_Spawn(WP_Helpme, waypointsprite_deployed_lifetime, waypointsprite_limitedrange, player, FLAG_WAYPOINT_OFFSET, NULL, player.team, player, wps_helpme, false, RADARICON_HELPME);
        WaypointSprite_Ping(player.wps_helpme);
    }

    return true;
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [12/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		VehicleEnter
	)

Definition at line 2435 of file sv_ctf.qc.

References autocvar_g_ctf_allow_vehicle_carry, autocvar_g_ctf_allow_vehicle_touch, ctf_Handle_Throw(), DROP_NORMAL, entity(), M_ARGV, NULL, setorigin(), VEHICLE_FLAG_OFFSET, and VEHICLE_FLAG_SCALE.

{
    entity player = M_ARGV(0, entity);
    entity veh = M_ARGV(1, entity);

    if(player.flagcarried)
    {
        if(!autocvar_g_ctf_allow_vehicle_carry && !autocvar_g_ctf_allow_vehicle_touch)
        {
            ctf_Handle_Throw(player, NULL, DROP_NORMAL);
        }
        else
        {
            player.flagcarried.nodrawtoclient = player; // hide the flag from the driver
            setattachment(player.flagcarried, veh, "");
            setorigin(player.flagcarried, VEHICLE_FLAG_OFFSET);
            player.flagcarried.scale = VEHICLE_FLAG_SCALE;
            //player.flagcarried.angles = '0 0 0';
        }
        return true;
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [13/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		VehicleExit
	)

Definition at line 2458 of file sv_ctf.qc.

References entity(), FLAG_CARRY_OFFSET, FLAG_SCALE, M_ARGV, NULL, and setorigin().

{
    entity player = M_ARGV(0, entity);

    if(player.flagcarried)
    {
        setattachment(player.flagcarried, player, "");
        setorigin(player.flagcarried, FLAG_CARRY_OFFSET);
        player.flagcarried.scale = FLAG_SCALE;
        player.flagcarried.angles = '0 0 0';
        player.flagcarried.nodrawtoclient = NULL;
        return true;
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [14/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		AbortSpeedrun
	)

Definition at line 2473 of file sv_ctf.qc.

References APP_NUM, ctf_RespawnFlag(), entity(), M_ARGV, and NULL.

{
    entity player = M_ARGV(0, entity);

    if(player.flagcarried)
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(player.flagcarried.team, INFO_CTF_FLAGRETURN_ABORTRUN));
        ctf_RespawnFlag(player.flagcarried);
        return true;
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [15/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		MatchEnd
	)

Definition at line 2485 of file sv_ctf.qc.

References ctf_worldflaglist, DAMAGE_NO, entity(), FLAG_BASE, FLAG_CARRY, FLAG_DROPPED, FLAG_PASSING, MOVETYPE_NONE, set_movetype(), and SOLID_NOT.

{
    entity flag; // temporary entity for the search method

    for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
    {
        switch(flag.ctf_status)
        {
            case FLAG_DROPPED:
            case FLAG_PASSING:
            {
                // lock the flag, game is over
                set_movetype(flag, MOVETYPE_NONE);
                flag.takedamage = DAMAGE_NO;
                flag.solid = SOLID_NOT;
                flag.nextthink = false; // stop thinking

                //dprint("stopping the ", flag.netname, " from moving.\n");
                break;
            }

            default:
            case FLAG_BASE:
            case FLAG_CARRY:
            {
                // do nothing for these flags
                break;
            }
        }
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [16/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		HavocBot_ChooseRole
	)

Definition at line 2517 of file sv_ctf.qc.

References entity(), havocbot_ctf_reset_role(), and M_ARGV.

{
    entity bot = M_ARGV(0, entity);

    havocbot_ctf_reset_role(bot);
    return true;
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [17/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		TeamBalance_CheckAllowedTeams
	)

Definition at line 2525 of file sv_ctf.qc.

References M_ARGV.

{
    M_ARGV(1, string) = "ctf_team";
}

MUTATOR_HOOKFUNCTION() [18/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GetRecords
	)

Definition at line 2530 of file sv_ctf.qc.

References db_get(), entity(), ftos_decimals(), M_ARGV, MapInfo_count, MapInfo_Get_ByID(), MapInfo_Map_bspname, ServerProgsDB, stof(), strcat(), superspec_msg(), and superspec_Spectate().

{
    int record_page = M_ARGV(0, int);
    string ret_string = M_ARGV(1, string);

    for(int i = record_page * 200; i < MapInfo_count && i < record_page * 200 + 200; ++i)
    {
        if (MapInfo_Get_ByID(i))
        {
            float r = stof(db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/time")));

            if(!r)
                continue;

            // TODO: uid2name
            string h = db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/netname"));
            ret_string = strcat(ret_string, strpad(32, MapInfo_Map_bspname), " ", strpad(-6, ftos_decimals(r, 2)), " ", h, "\n");
        }
    }

    M_ARGV(1, string) = ret_string;
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [19/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		SV_ParseClientCommand
	)

Definition at line 2555 of file sv_ctf.qc.

References argv(), BIT, cmd_argc, cmd_name, ctf_teams, cvar(), entity(), FOREACH_CLIENT, g_ctf, IS_PLAYER, M_ARGV, MUTATOR_RETURNVALUE, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, and superspec_msg().

{
    entity player = M_ARGV(0, entity);
    string cmd_name = M_ARGV(1, string);
    int cmd_argc = M_ARGV(2, int);

    if(IS_PLAYER(player) || MUTATOR_RETURNVALUE || !cvar("g_superspectate")) { return false; }

    if(cmd_name == "followfc")
    {
        if(!g_ctf)
            return true;

        int _team = 0;
        bool found = false;

        if(cmd_argc == 2)
        {
            switch(argv(1))
            {
                case "red":    if(ctf_teams & BIT(0)) _team = NUM_TEAM_1; break;
                case "blue":   if(ctf_teams & BIT(1)) _team = NUM_TEAM_2; break;
                case "yellow": if(ctf_teams & BIT(2)) _team = NUM_TEAM_3; break;
                case "pink":   if(ctf_teams & BIT(3)) _team = NUM_TEAM_4; break;
            }
        }

        FOREACH_CLIENT(IS_PLAYER(it), {
            if(it.flagcarried && (it.team == _team || _team == 0))
            {
                found = true;
                if(_team == 0 && IS_SPEC(player) && player.enemy == it)
                    continue; // already spectating this fc, try another
                return superspec_Spectate(player, it);
            }
        });

        if(!found)
            superspec_msg("", "", player, "No active flag carrier\n", 1);
        return true;
    }
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [20/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		DropSpecialItems
	)

Definition at line 2598 of file sv_ctf.qc.

References ctf_Handle_Throw(), DROP_THROW, entity(), M_ARGV, and NULL.

{
    entity frag_target = M_ARGV(0, entity);

    if(frag_target.flagcarried)
        ctf_Handle_Throw(frag_target, NULL, DROP_THROW);
}

Here is the call graph for this function:

MUTATOR_HOOKFUNCTION() [21/21]

MUTATOR_HOOKFUNCTION	(	ctf	,
		LogDeath_AppendItemCodes
	)

Definition at line 2606 of file sv_ctf.qc.

References entity(), M_ARGV, and strcat().

{
    entity player = M_ARGV(0, entity);
    if(player.flagcarried)
        M_ARGV(1, string) = strcat(M_ARGV(1, string), "F"); // item codes
}

Here is the call graph for this function:

nades_GiveBonus()

void nades_GiveBonus	(	entity	player,
		float	score
	)

Referenced by ctf_Handle_Capture(), ctf_Handle_Pickup(), ctf_Handle_Return(), and ctf_Handle_Throw().

Here is the caller graph for this function:

spawnfunc() [1/22]

spawnfunc

(

item_flag_team1

)

Definition at line 2629 of file sv_ctf.qc.

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_1.

Referenced by spawnfunc().

{
    if(!g_ctf) { delete(this); return; }

    ctf_FlagSetup(NUM_TEAM_1, this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

spawnfunc() [2/22]

spawnfunc

(

item_flag_team2

)

Definition at line 2647 of file sv_ctf.qc.

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_2.

{
    if(!g_ctf) { delete(this); return; }

    ctf_FlagSetup(NUM_TEAM_2, this);
}

Here is the call graph for this function:

spawnfunc() [3/22]

spawnfunc

(

item_flag_team3

)

Definition at line 2665 of file sv_ctf.qc.

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_3.

{
    if(!g_ctf) { delete(this); return; }

    ctf_FlagSetup(NUM_TEAM_3, this);
}

Here is the call graph for this function:

spawnfunc() [4/22]

spawnfunc

(

item_flag_team4

)

Definition at line 2683 of file sv_ctf.qc.

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_4.

{
    if(!g_ctf) { delete(this); return; }

    ctf_FlagSetup(NUM_TEAM_4, this);
}

Here is the call graph for this function:

spawnfunc() [5/22]

spawnfunc

(

item_flag_neutral

)

Definition at line 2701 of file sv_ctf.qc.

References ctf_FlagSetup(), cvar(), and g_ctf.

{
    if(!g_ctf) { delete(this); return; }
    if(!cvar("g_ctf_oneflag")) { delete(this); return; }

    ctf_FlagSetup(0, this);
}

Here is the call graph for this function:

spawnfunc() [6/22]

spawnfunc

(

ctf_team

)

Definition at line 2715 of file sv_ctf.qc.

References cnt, g_ctf, and team.

{
    if(!g_ctf) { delete(this); return; }

    this.team = this.cnt + 1;
}

spawnfunc() [7/22]

spawnfunc

(

team_CTF_redflag

)

Definition at line 2723 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [8/22]

spawnfunc

(

team_CTF_blueflag

)

Definition at line 2724 of file sv_ctf.qc.

References spawnfunc().

{ spawnfunc_item_flag_team2(this);    }

Here is the call graph for this function:

spawnfunc() [9/22]

spawnfunc

(

info_player_team1

)

Definition at line 175 of file spawnpoints.qc.

References NUM_TEAM_1, and team.

{
    this.team = NUM_TEAM_1; // red
    spawnfunc_info_player_deathmatch(this);
}

spawnfunc() [10/22]

spawnfunc

(

team_CTF_redplayer

)

Definition at line 2726 of file sv_ctf.qc.

{ spawnfunc_info_player_team1(this);  }

spawnfunc() [11/22]

spawnfunc

(

team_CTF_redspawn

)

Definition at line 2727 of file sv_ctf.qc.

References spawnfunc().

{ spawnfunc_info_player_team1(this);  }

Here is the call graph for this function:

spawnfunc() [12/22]

spawnfunc

(

info_player_team2

)

Definition at line 185 of file spawnpoints.qc.

References NUM_TEAM_2, and team.

{
    this.team = NUM_TEAM_2; // blue
    spawnfunc_info_player_deathmatch(this);
}

spawnfunc() [13/22]

spawnfunc

(

team_CTF_blueplayer

)

Definition at line 2729 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [14/22]

spawnfunc

(

team_CTF_bluespawn

)

Definition at line 2730 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [15/22]

spawnfunc

(

team_CTF_neutralflag

)

Definition at line 2732 of file sv_ctf.qc.

{ spawnfunc_item_flag_neutral(this);  }

spawnfunc() [16/22]

spawnfunc

(

team_neutralobelisk

)

Definition at line 2733 of file sv_ctf.qc.

{ spawnfunc_item_flag_neutral(this);  }

spawnfunc() [17/22]

spawnfunc

(

team_redplayer

)

Definition at line 2736 of file sv_ctf.qc.

{ spawnfunc_info_player_team1(this);  }

spawnfunc() [18/22]

spawnfunc

(

team_blueplayer

)

Definition at line 2737 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [19/22]

spawnfunc

(

team_ctl_redlolly

)

Definition at line 2738 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [20/22]

spawnfunc

(

team_CTL_redlolly

)

Definition at line 2739 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [21/22]

spawnfunc

(

team_ctl_bluelolly

)

Definition at line 2740 of file sv_ctf.qc.

{ spawnfunc_item_flag_team2(this);    }

spawnfunc() [22/22]

spawnfunc

(

team_CTL_bluelolly

)

Definition at line 2741 of file sv_ctf.qc.

{ spawnfunc_item_flag_team2(this);    }

superspec_msg()

void superspec_msg	(	string	_center_title,
		string	_con_title,
		entity	_to,
		string	_msg,
		float	_spamlevel
	)

Definition at line 68 of file sv_superspec.qc.

References centerprint(), sprint(), and strcat().

Referenced by MUTATOR_HOOKFUNCTION().

{
    sprint(_to, strcat(_con_title, _msg));

    if(_to.superspec_flags & SSF_SILENT)
        return;

    if(_spamlevel > 1)
        if (!(_to.superspec_flags & SSF_VERBOSE))
            return;

    centerprint(_to, strcat(_center_title, _msg));
}

Here is the call graph for this function:

Here is the caller graph for this function:

superspec_Spectate()

bool superspec_Spectate	(	entity	this,
		entity	targ
	)

Definition at line 28 of file sv_superspec.qc.

References Spectate(), and TRANSMUTE().

Referenced by MUTATOR_HOOKFUNCTION().

{
    if(Spectate(this, targ) == 1)
        TRANSMUTE(Spectator, this);

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

autocvar_g_ctf_allow_monster_touch

bool autocvar_g_ctf_allow_monster_touch

Definition at line 22 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_allow_vehicle_carry

bool autocvar_g_ctf_allow_vehicle_carry

Definition at line 20 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_allow_vehicle_touch

bool autocvar_g_ctf_allow_vehicle_touch

Definition at line 21 of file sv_ctf.qc.

Referenced by ctf_FlagThink(), and MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_drop_velocity_side

float autocvar_g_ctf_drop_velocity_side

Definition at line 33 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_drop_velocity_up

float autocvar_g_ctf_drop_velocity_up

Definition at line 32 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_dropped_capture_delay

float autocvar_g_ctf_dropped_capture_delay

Definition at line 90 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_dropped_capture_radius

float autocvar_g_ctf_dropped_capture_radius

Definition at line 91 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_dynamiclights

bool autocvar_g_ctf_dynamiclights

Definition at line 47 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_flag_collect_delay

float autocvar_g_ctf_flag_collect_delay

Definition at line 48 of file sv_ctf.qc.

Referenced by ctf_FlagThink(), ctf_Handle_Capture(), and ctf_Handle_Return().

autocvar_g_ctf_flag_damageforcescale

float autocvar_g_ctf_flag_damageforcescale

Definition at line 49 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_flag_dropped_floatinwater

bool autocvar_g_ctf_flag_dropped_floatinwater

Definition at line 51 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_flag_dropped_waypoint

bool autocvar_g_ctf_flag_dropped_waypoint

Definition at line 50 of file sv_ctf.qc.

Referenced by ctf_Handle_Drop().

autocvar_g_ctf_flag_glowtrails

bool autocvar_g_ctf_flag_glowtrails

Definition at line 52 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_flag_health

int autocvar_g_ctf_flag_health

Definition at line 53 of file sv_ctf.qc.

Referenced by ctf_FlagSetup(), and ctf_Handle_Drop().

autocvar_g_ctf_flag_return

bool autocvar_g_ctf_flag_return

Definition at line 54 of file sv_ctf.qc.

Referenced by ctf_FlagThink(), and ctf_Immediate_Return_Allowed().

autocvar_g_ctf_flag_return_carried_radius

float autocvar_g_ctf_flag_return_carried_radius

Definition at line 56 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_flag_return_carrying

bool autocvar_g_ctf_flag_return_carrying

Definition at line 55 of file sv_ctf.qc.

Referenced by ctf_FlagThink(), and ctf_Immediate_Return_Allowed().

autocvar_g_ctf_flag_return_damage

float autocvar_g_ctf_flag_return_damage

Definition at line 59 of file sv_ctf.qc.

Referenced by ctf_FlagDamage(), ctf_FlagSetup(), and ctf_Handle_Drop().

autocvar_g_ctf_flag_return_damage_delay

float autocvar_g_ctf_flag_return_damage_delay

Definition at line 60 of file sv_ctf.qc.

Referenced by ctf_FlagDamage(), and ctf_FlagThink().

autocvar_g_ctf_flag_return_dropped

float autocvar_g_ctf_flag_return_dropped

Definition at line 61 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_flag_return_time

float autocvar_g_ctf_flag_return_time

Definition at line 57 of file sv_ctf.qc.

Referenced by ctf_CheckFlagReturn(), ctf_FlagThink(), ctf_Handle_Drop(), and ctf_Handle_Pickup().

autocvar_g_ctf_flag_return_when_unreachable

bool autocvar_g_ctf_flag_return_when_unreachable

Definition at line 58 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_flag_waypoint

bool autocvar_g_ctf_flag_waypoint = true

Definition at line 62 of file sv_ctf.qc.

Referenced by ctf_DelayedFlagSetup().

autocvar_g_ctf_flag_waypoint_maxdistance

float autocvar_g_ctf_flag_waypoint_maxdistance

Definition at line 63 of file sv_ctf.qc.

Referenced by ctf_DelayedFlagSetup().

autocvar_g_ctf_flagcarrier_auto_helpme_damage

float autocvar_g_ctf_flagcarrier_auto_helpme_damage

Definition at line 64 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_flagcarrier_auto_helpme_time

float autocvar_g_ctf_flagcarrier_auto_helpme_time

Definition at line 65 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_flagcarrier_damagefactor

float autocvar_g_ctf_flagcarrier_damagefactor

Definition at line 68 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_flagcarrier_forcefactor

float autocvar_g_ctf_flagcarrier_forcefactor

Definition at line 69 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_flagcarrier_selfdamagefactor

float autocvar_g_ctf_flagcarrier_selfdamagefactor

Definition at line 66 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_flagcarrier_selfforcefactor

float autocvar_g_ctf_flagcarrier_selfforcefactor

Definition at line 67 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_fullbrightflags

bool autocvar_g_ctf_fullbrightflags

Definition at line 71 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_ignore_frags

bool autocvar_g_ctf_ignore_frags

Definition at line 72 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_oneflag_reverse

bool autocvar_g_ctf_oneflag_reverse

Definition at line 34 of file sv_ctf.qc.

autocvar_g_ctf_pass

bool autocvar_g_ctf_pass

Definition at line 36 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_pass_arc

float autocvar_g_ctf_pass_arc

Definition at line 37 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_arc_max

float autocvar_g_ctf_pass_arc_max

Definition at line 38 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_directional_max

float autocvar_g_ctf_pass_directional_max

Definition at line 39 of file sv_ctf.qc.

Referenced by ctf_CheckPassDirection().

autocvar_g_ctf_pass_directional_min

float autocvar_g_ctf_pass_directional_min

Definition at line 40 of file sv_ctf.qc.

Referenced by ctf_CheckPassDirection().

autocvar_g_ctf_pass_radius

float autocvar_g_ctf_pass_radius

Definition at line 41 of file sv_ctf.qc.

Referenced by ctf_CheckPassDirection(), ctf_FlagThink(), and MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_pass_request

bool autocvar_g_ctf_pass_request

Definition at line 43 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_pass_timelimit

float autocvar_g_ctf_pass_timelimit

Definition at line 45 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_pass_turnrate

float autocvar_g_ctf_pass_turnrate

Definition at line 44 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_velocity

float autocvar_g_ctf_pass_velocity

Definition at line 46 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_wait

float autocvar_g_ctf_pass_wait

Definition at line 42 of file sv_ctf.qc.

Referenced by ctf_Handle_Drop(), ctf_Handle_Retrieve(), and MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_portalteleport

bool autocvar_g_ctf_portalteleport

Definition at line 35 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_reverse

bool autocvar_g_ctf_reverse

Definition at line 89 of file sv_ctf.qc.

autocvar_g_ctf_score_capture

int autocvar_g_ctf_score_capture

Definition at line 74 of file sv_ctf.qc.

Referenced by ctf_Handle_Capture().

autocvar_g_ctf_score_capture_assist

int autocvar_g_ctf_score_capture_assist

Definition at line 75 of file sv_ctf.qc.

Referenced by ctf_Handle_Capture().

autocvar_g_ctf_score_ignore_fields

bool autocvar_g_ctf_score_ignore_fields

Definition at line 73 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_score_kill

int autocvar_g_ctf_score_kill

Definition at line 76 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_score_penalty_drop

int autocvar_g_ctf_score_penalty_drop

Definition at line 77 of file sv_ctf.qc.

Referenced by ctf_Handle_Drop().

autocvar_g_ctf_score_penalty_returned

int autocvar_g_ctf_score_penalty_returned

Definition at line 78 of file sv_ctf.qc.

Referenced by ctf_Handle_Return().

autocvar_g_ctf_score_pickup_base

int autocvar_g_ctf_score_pickup_base

Definition at line 79 of file sv_ctf.qc.

Referenced by ctf_Handle_Pickup().

autocvar_g_ctf_score_pickup_dropped_early

int autocvar_g_ctf_score_pickup_dropped_early

Definition at line 80 of file sv_ctf.qc.

Referenced by ctf_Handle_Pickup().

autocvar_g_ctf_score_pickup_dropped_late

int autocvar_g_ctf_score_pickup_dropped_late

Definition at line 81 of file sv_ctf.qc.

Referenced by ctf_Handle_Pickup().

autocvar_g_ctf_score_return

int autocvar_g_ctf_score_return

Definition at line 82 of file sv_ctf.qc.

Referenced by ctf_Handle_Return().

autocvar_g_ctf_shield_force

float autocvar_g_ctf_shield_force

Definition at line 83 of file sv_ctf.qc.

Referenced by ctf_Initialize().

autocvar_g_ctf_shield_max_ratio

float autocvar_g_ctf_shield_max_ratio

Definition at line 84 of file sv_ctf.qc.

Referenced by ctf_Initialize().

autocvar_g_ctf_shield_min_negscore

int autocvar_g_ctf_shield_min_negscore

Definition at line 85 of file sv_ctf.qc.

Referenced by ctf_Initialize().

autocvar_g_ctf_stalemate

bool autocvar_g_ctf_stalemate

Definition at line 86 of file sv_ctf.qc.

Referenced by ctf_CheckStalemate(), and ctf_FlagThink().

autocvar_g_ctf_stalemate_endcondition

int autocvar_g_ctf_stalemate_endcondition

Definition at line 87 of file sv_ctf.qc.

Referenced by ctf_CheckStalemate().

autocvar_g_ctf_stalemate_time

float autocvar_g_ctf_stalemate_time

Definition at line 88 of file sv_ctf.qc.

Referenced by ctf_CheckStalemate().

autocvar_g_ctf_throw

bool autocvar_g_ctf_throw

Definition at line 23 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_throw_angle_max

float autocvar_g_ctf_throw_angle_max

Definition at line 24 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_throw_angle_min

float autocvar_g_ctf_throw_angle_min

Definition at line 25 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_throw_punish_count

int autocvar_g_ctf_throw_punish_count

Definition at line 26 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_throw_punish_delay

float autocvar_g_ctf_throw_punish_delay

Definition at line 27 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_throw_punish_time

float autocvar_g_ctf_throw_punish_time

Definition at line 28 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_throw_strengthmultiplier

float autocvar_g_ctf_throw_strengthmultiplier

Definition at line 29 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_throw_velocity_forward

float autocvar_g_ctf_throw_velocity_forward

Definition at line 30 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

autocvar_g_ctf_throw_velocity_up

float autocvar_g_ctf_throw_velocity_up

Definition at line 31 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

last_respawn

float last_respawn

Definition at line 1162 of file sv_ctf.qc.

pushable

bool pushable

Definition at line 1270 of file sv_ctf.qc.