sv_ctf.qc File Reference

#include "sv_ctf.qh"
#include <common/checkextension.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:

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

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)
	if (frag_attacker.flagcarried)
else	if (frag_target.flagcarried &&!IS_DEAD(frag_target) &&CTF_DIFFTEAM(frag_target, frag_attacker))
	MUTATOR_HOOKFUNCTION (ctf, AbortSpeedrun)
	MUTATOR_HOOKFUNCTION (ctf, ClientConnect)
	MUTATOR_HOOKFUNCTION (ctf, ClientDisconnect)
	MUTATOR_HOOKFUNCTION (ctf, DropSpecialItems)
	MUTATOR_HOOKFUNCTION (ctf, GetPressedKeys)
	MUTATOR_HOOKFUNCTION (ctf, GetRecords)
	MUTATOR_HOOKFUNCTION (ctf, GiveFragsForKill)
	MUTATOR_HOOKFUNCTION (ctf, HavocBot_ChooseRole)
	MUTATOR_HOOKFUNCTION (ctf, HelpMePing)
	MUTATOR_HOOKFUNCTION (ctf, LogDeath_AppendItemCodes)
	MUTATOR_HOOKFUNCTION (ctf, MakePlayerObserver)
	MUTATOR_HOOKFUNCTION (ctf, MatchEnd)
	MUTATOR_HOOKFUNCTION (ctf, PlayerDies)
	MUTATOR_HOOKFUNCTION (ctf, PlayerPreThink)
	MUTATOR_HOOKFUNCTION (ctf, PlayerUseKey)
	MUTATOR_HOOKFUNCTION (ctf, PortalTeleport)
	MUTATOR_HOOKFUNCTION (ctf, SV_ParseClientCommand)
	MUTATOR_HOOKFUNCTION (ctf, TeamBalance_CheckAllowedTeams)
	MUTATOR_HOOKFUNCTION (ctf, VehicleEnter)
	MUTATOR_HOOKFUNCTION (ctf, VehicleExit)
void	nades_GiveBonus (entity player, float score)
	spawnfunc (ctf_team)
	spawnfunc (info_player_team1)
	spawnfunc (info_player_team2)
	spawnfunc (item_flag_neutral)
	spawnfunc (item_flag_team1)
	spawnfunc (item_flag_team2)
	spawnfunc (item_flag_team3)
	spawnfunc (item_flag_team4)
	spawnfunc (team_blueplayer)
	spawnfunc (team_CTF_blueflag)
	spawnfunc (team_CTF_blueplayer)
	spawnfunc (team_CTF_bluespawn)
	spawnfunc (team_CTF_neutralflag)
	spawnfunc (team_CTF_redflag)
	spawnfunc (team_CTF_redplayer)
	spawnfunc (team_CTF_redspawn)
	spawnfunc (team_CTL_bluelolly)
	spawnfunc (team_ctl_bluelolly)
	spawnfunc (team_CTL_redlolly)
	spawnfunc (team_ctl_redlolly)
	spawnfunc (team_neutralobelisk)
	spawnfunc (team_redplayer)
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
float	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_stay
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	frag_damage = M_ARGV(4, float)
vector	frag_force = M_ARGV(6, vector)
entity	frag_target = M_ARGV(2, entity)
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 201 of file sv_ctf.qc.

{
    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); }
}

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

Referenced by ctf_FlagThink(), and ctf_Handle_Throw().

ctf_CaptureRecord()

void ctf_CaptureRecord	(	entity	flag,
		entity	player )

Definition at line 113 of file sv_ctf.qc.

{
    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);
}

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

Referenced by ctf_Handle_Capture().

ctf_CaptureShield_CheckStatus()

bool ctf_CaptureShield_CheckStatus

(

entity

p

)

Definition at line 266 of file sv_ctf.qc.

{
    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;
}

References ctf_captureshield_max_ratio, ctf_captureshield_min_negscore, DIFF_TEAM, entity(), FOREACH_CLIENT, GameRules_scoring_add, IS_PLAYER, and s2.

Referenced by ctf_CaptureShield_Update().

ctf_CaptureShield_Customize()

bool ctf_CaptureShield_Customize	(	entity	this,
		entity	client )

Definition at line 319 of file sv_ctf.qc.

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

References CTF_SAMETEAM, and entity().

Referenced by ctf_CaptureShield_Spawn().

ctf_CaptureShield_Spawn()

void ctf_CaptureShield_Spawn

(

entity

flag

)

Definition at line 339 of file sv_ctf.qc.

{
    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);
}

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

Referenced by ctf_DelayedFlagSetup().

ctf_CaptureShield_Touch()

void ctf_CaptureShield_Touch	(	entity	this,
		entity	toucher )

Definition at line 327 of file sv_ctf.qc.

{
    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); }
}

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

Referenced by ctf_CaptureShield_Spawn().

ctf_CaptureShield_Update()

void ctf_CaptureShield_Update	(	entity	player,
		bool	wanted_status )

Definition at line 309 of file sv_ctf.qc.

{
    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;
    }
}

References ctf_CaptureShield_CheckStatus(), entity(), and Send_Notification().

Referenced by ctf_Handle_Return(), and ctf_Handle_Throw().

ctf_CheckFlagReturn()

void ctf_CheckFlagReturn	(	entity	flag,
		int	returntype )

Definition at line 851 of file sv_ctf.qc.

{
    if((flag.ctf_status == FLAG_DROPPED) || (flag.ctf_status == FLAG_PASSING))
    {
        if (flag.wps_flagdropped
        && (autocvar_g_ctf_flag_return_time > 0 || autocvar_g_ctf_flag_return_damage))
        {
            WaypointSprite_UpdateHealth(flag.wps_flagdropped, GetResource(flag, RES_HEALTH));
        }
 
        if((GetResource(flag, RES_HEALTH) <= 0)
            || (autocvar_g_ctf_flag_return_time > 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);
        }
    }
}

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

Referenced by ctf_FlagDamage(), and ctf_FlagThink().

ctf_CheckPassDirection()

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

Definition at line 232 of file sv_ctf.qc.

{
    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; }
}

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().

ctf_CheckStalemate()

void ctf_CheckStalemate

(

)

Definition at line 902 of file sv_ctf.qc.

{
    // 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 ctf_staleflaglist = NULL; // reset the list, we need to build the list each time this function runs
 
    // build list of stale flags
    IL_EACH(g_flags, true,
    {
        if(autocvar_g_ctf_stalemate)
        if(it.ctf_status != FLAG_BASE)
        if(time >= it.ctf_pickuptime + autocvar_g_ctf_stalemate_time || !it.team) // instant stalemate in oneflag
        {
            it.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
            ctf_staleflaglist = it;
 
            switch(it.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(entity tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
        {
            if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
            {
                entity base_wp = WP_FlagCarrier;
                if (!ctf_oneflag)
                {
                    switch (tmp_entity.owner.team)
                    {
                        case NUM_TEAM_1: base_wp = WP_FlagCarrierEnemyRed; break;
                        case NUM_TEAM_2: base_wp = WP_FlagCarrierEnemyBlue; break;
                        case NUM_TEAM_3: base_wp = WP_FlagCarrierEnemyYellow; break;
                        case NUM_TEAM_4: base_wp = WP_FlagCarrierEnemyPink; break;
                        default: base_wp = WP_FlagCarrierEnemyNeutral; break;
                    }
                }
                entity wp = WaypointSprite_Spawn(base_wp, 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;
        }
    }
}

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

Referenced by ctf_FlagThink(), and ctf_RespawnFlag().

ctf_DelayedFlagSetup()

void ctf_DelayedFlagSetup

(

entity

this

)

Definition at line 1318 of file sv_ctf.qc.

{
    // 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);
}

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, setcefc, team, Team_ColorRGB(), waypoint_spawnforitem_force(), WaypointSprite_SpawnFixed(), WaypointSprite_UpdateTeamRadar(), and wps_flagbase.

Referenced by ctf_FlagSetup().

ctf_DelayedInit()

void ctf_DelayedInit

(

entity

this

)

Definition at line 2878 of file sv_ctf.qc.

{
    ctf_teams = 0;
 
    IL_EACH(g_flags, true,
    {
        //if(it.team == NUM_TEAM_3) { ctf_teams = max(3, ctf_teams); }
        //if(it.team == NUM_TEAM_4) { ctf_teams = max(4, ctf_teams); }
 
        switch(it.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(it.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);
}

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

Referenced by ctf_Initialize().

ctf_EventLog()

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

Definition at line 106 of file sv_ctf.qc.

{
    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))) : "")));
}

References autocvar_sv_eventlog, entity(), 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().

ctf_FakeTimeLimit()

void ctf_FakeTimeLimit	(	entity	e,
		float	t )

Definition at line 95 of file sv_ctf.qc.

{
    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);
}

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

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

ctf_FlagBase_Customize()

bool ctf_FlagBase_Customize	(	entity	this,
		entity	client )

Definition at line 1306 of file sv_ctf.qc.

{
    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;
}

References CTF_SAMETEAM, entity(), owner, and WaypointSprite_getviewentity().

Referenced by ctf_DelayedFlagSetup().

ctf_FlagcarrierWaypoints()

void ctf_FlagcarrierWaypoints

(

entity

player

)

Definition at line 159 of file sv_ctf.qc.

{
    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 base_wp = WP_FlagCarrier;
            if (!ctf_oneflag)
            {
                switch (player.team)
                {
                    case NUM_TEAM_1: base_wp = WP_FlagCarrierEnemyRed; break;
                    case NUM_TEAM_2: base_wp = WP_FlagCarrierEnemyBlue; break;
                    case NUM_TEAM_3: base_wp = WP_FlagCarrierEnemyYellow; break;
                    case NUM_TEAM_4: base_wp = WP_FlagCarrierEnemyPink; break;
                    default: base_wp = WP_FlagCarrierEnemyNeutral; break;
                }
            }
            entity wp = WaypointSprite_Spawn(base_wp, 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);
        }
    }
}

References autocvar_g_balance_armor_blockpercent, ctf_oneflag, ctf_Return_Customize(), CTF_SAMETEAM, ctf_stalemate, ctf_Stalemate_Customize(), entity(), FLAG_WAYPOINT_OFFSET, GetResource(), healtharmor_maxdamage(), IS_REAL_CLIENT, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, RES_ARMOR, Send_Notification(), setcefc, start_armorvalue, start_health, WaypointSprite_Spawn(), WaypointSprite_SpawnFixed(), WaypointSprite_UpdateHealth(), WaypointSprite_UpdateMaxHealth(), WaypointSprite_UpdateTeamRadar(), WPCOLOR_ENEMYFC, WPCOLOR_FLAGCARRIER, wps_enemyflagcarrier, wps_flagcarrier, and wps_flagreturn.

Referenced by ctf_Handle_Pickup(), and ctf_Handle_Retrieve().

ctf_FlagDamage()

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

Definition at line 978 of file sv_ctf.qc.

{
    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;
    }
}

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

Referenced by ctf_FlagSetup().

ctf_FlagSetup()

void ctf_FlagSetup	(	int	teamnum,
		entity	flag )

Definition at line 1350 of file sv_ctf.qc.

{
    // main setup
    IL_PUSH(g_flags, 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 > 0) ? 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 = false; // can be damaged by contents only when dropped
 
    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;
 
    // set correct team colors
    flag.glowmod = Team_ColorRGB(teamnum);
    flag.colormap = (teamnum) ? (teamnum - 1) * 0x11 : 0x00;
    flag.colormap |= BIT(10); // RENDER_COLORMAPPED
 
    // 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, vrint(CTF_FLAG.m_mins * flag.scale), vrint(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_QC_DelayedInit(flag);
        set_movetype(flag, MOVETYPE_NONE);
    }
 
    InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
}

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, BIT, ctf_DelayedFlagSetup(), CTF_FLAG, ctf_FlagDamage(), ctf_FlagThink(), ctf_FlagTouch(), ctf_Reset(), cvar(), cvar_string(), DAMAGE_NO, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, DropToFloor_QC_DelayedInit(), EF_BLUE, EF_DIMLIGHT, EF_FULLBRIGHT, EF_LOWPRECISION, EF_RED, EFFECT_CAP(), EFFECT_FLAG_TOUCH(), EFFECT_PASS(), entity(), FL_ITEM, FL_NOTARGET, FLAG_BASE, FLAG_SCALE, FLAG_SPAWN_OFFSET, FLAG_THINKRATE, g_flags, g_items, IL_PUSH(), InitializeEntity(), INITPRIO_SETLOCATION, MOVETYPE_NONE, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, set_movetype(), SetResourceExplicit(), setthink, settouch, 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, Team_ColorRGB(), TELEPORT_NORMAL, time, vrint(), and X.

Referenced by spawnfunc(), spawnfunc(), spawnfunc(), spawnfunc(), and spawnfunc().

ctf_FlagThink()

void ctf_FlagThink

(

entity

this

)

Definition at line 1000 of file sv_ctf.qc.

{
    this.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
 
    // sanity checks
    if(this.mins != this.m_mins || this.maxs != this.m_maxs) { // reset the flag boundaries in case it got squished
        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)
            {
                IL_EACH(g_flags, true,
                {
                    if(it.ctf_status == FLAG_DROPPED)
                    if(vdist(this.origin - it.origin, <, autocvar_g_ctf_dropped_capture_radius))
                    if((this.noalign || it.ctf_landtime) && time > ((this.noalign) ? it.ctf_droptime : it.ctf_landtime) + autocvar_g_ctf_dropped_capture_delay)
                        ctf_Handle_Capture(this, it, CAPTURE_DROPPED);
                });
            }
            return;
        }
 
        case FLAG_DROPPED:
        {
            this.angles = '0 0 0'; // reset flag angles in case warpzones adjust it
            if(IS_ONGROUND(this) && !this.ctf_landtime)
                this.ctf_landtime = time; // landtime is reset when thrown, and we don't want to restart the timer if the flag is pushed
 
            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 > 0)
            {
                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;
        }
    }
}

References absmax, absmin, angles, autocvar_g_ctf_dropped_capture_delay, autocvar_g_ctf_dropped_capture_radius, autocvar_g_ctf_flag_dropped_floatinwater, autocvar_g_ctf_flag_return, autocvar_g_ctf_flag_return_carried_radius, 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, CONTENT_WATER, CS(), ctf_CalculatePassVelocity(), ctf_captimerecord, ctf_CheckFlagReturn(), ctf_CheckStalemate(), ctf_droptime, ctf_flagdamaged_byworld, ctf_Handle_Capture(), ctf_Handle_Drop(), ctf_Handle_Return(), ctf_Handle_Throw(), ctf_landtime, ctf_pickuptime, CTF_SAMETEAM, ctf_spawnorigin, ctf_status, DROP_PASS, DROP_THROW, entity(), eZ, FLAG_BASE, FLAG_CARRY, FLAG_DROPPED, FLAG_FLOAT_OFFSET_Z, FLAG_PASSING, FLAG_THINKRATE, g_flags, IL_EACH, ImpulseCommands(), IS_DEAD, IS_ONGROUND, LOG_TRACE, m_maxs, m_mins, max_health, maxs, mins, move_movetype, MOVE_NOMONSTERS, MOVETYPE_FLY, MOVETYPE_TOSS, nextthink, noalign, NULL, origin, owner, pass_target, RETURN_DROPPED, RETURN_NEEDKILL, RETURN_SPEEDRUN, RETURN_TIMEOUT, set_movetype(), SetResourceExplicit(), speedrunning, TakeResource(), team, time, trace_ent, trace_fraction, trace_startsolid, vdist, vector, velocity, WarpZone_RefSys_TransformOrigin(), WarpZone_TraceLine(), WPFE_THINKRATE, and wpforenemy_nextthink.

Referenced by ctf_FlagSetup().

ctf_Handle_Capture()

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

Definition at line 604 of file sv_ctf.qc.

{
    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)
    {
        IL_EACH(g_flags, SAME_TEAM(it, player),
        {
            player_team_flag = it;
            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);
}

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

Referenced by ctf_FlagThink().

ctf_Handle_Drop()

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

Definition at line 363 of file sv_ctf.qc.

{
    // declarations
    player = (player ? player : flag.pass_sender);
 
    // main
    set_movetype(flag, MOVETYPE_TOSS);
    flag.takedamage = DAMAGE_YES;
    flag.angles = '0 0 0';
 
    flag.max_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health > 0) ? autocvar_g_ctf_flag_health : 100);
    SetResourceExplicit(flag, RES_HEALTH, flag.max_health);
 
    flag.ctf_droptime = time;
    flag.ctf_landtime = 0;
    flag.ctf_dropper = player;
    flag.ctf_status = FLAG_DROPPED;
 
    flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
    if(flag.damagedbycontents)
        IL_PUSH(g_damagedbycontents, flag);
 
    // 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 base_wp;
        switch (flag.team)
        {
            case NUM_TEAM_1: base_wp = WP_FlagDroppedRed; break;
            case NUM_TEAM_2: base_wp = WP_FlagDroppedBlue; break;
            case NUM_TEAM_3: base_wp = WP_FlagDroppedYellow; break;
            case NUM_TEAM_4: base_wp = WP_FlagDroppedPink; break;
            default: base_wp = WP_FlagDroppedNeutral; break;
        }
        int wp_team = ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team);
        entity wp = WaypointSprite_Spawn(base_wp, 0, 0, flag, FLAG_WAYPOINT_OFFSET, NULL,
            wp_team, flag, wps_flagdropped, true, RADARICON_FLAG);
        wp.colormod = WPCOLOR_DROPPEDFLAG(flag.team);
    }
 
    if(autocvar_g_ctf_flag_return_time > 0 || autocvar_g_ctf_flag_return_damage)
    {
        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;
    }
}

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_flag_return_when_unreachable, 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, g_damagedbycontents, GameRules_scoring_add, GameRules_scoring_add_team, GetResource(), IL_PUSH(), MOVETYPE_TOSS, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, Send_Notification(), set_movetype(), SetResourceExplicit(), time, VOL_BASE, WaypointSprite_Spawn(), WaypointSprite_UpdateHealth(), WaypointSprite_UpdateMaxHealth(), WPCOLOR_DROPPEDFLAG, and wps_flagdropped.

Referenced by ctf_FlagThink(), and ctf_Handle_Throw().

ctf_Handle_Pickup()

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

Definition at line 725 of file sv_ctf.qc.

{
    // declarations
    float pickup_dropped_score; // used to calculate dropped pickup score
 
    if(autocvar_g_ctf_flag_stay && pickuptype == PICKUP_BASE)
    {
        entity newflag = spawn();
        copyentity_qc(flag, newflag);
        newflag.classname = "phantomflag"; // identifier for other code
        IL_PUSH(g_moveables, newflag); // cleared by copyentity_qc
        IL_PUSH(g_flags, newflag);
        // uncomment for "ghostly" phantom flag appearance (may look bad)
        //newflag.effects |= EF_ADDITIVE;
        flag = newflag;
    }
 
    // attach the flag to the player
    flag.owner = player;
    player.flagcarried = flag;
    GameRules_scoring_vip(player, true);
    flag.solid = SOLID_NOT; // before setorigin to prevent area grid linking
    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.angles = '0 0 0';
    flag.ctf_status = FLAG_CARRY;
 
    flag.damagedbycontents = false;
    if(IL_CONTAINS(g_damagedbycontents, flag))
        IL_REMOVE(g_damagedbycontents, flag);
 
    StatusEffects_removeall(flag, STATUSEFFECT_REMOVE_CLEAR);
 
    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))
                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);
            else if(DIFF_TEAM(player, it))
                Send_Notification(NOTIF_ONE, it, MSG_CHOICE, APP_NUM(flag.team, CHOICE_CTF_PICKUP_ENEMY_OTHER), 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 > 0 ? 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);
}

References _sound, APP_NUM, APP_TEAM_NUM, ATTEN_NONE, autocvar_g_ctf_flag_return_time, autocvar_g_ctf_flag_stay, autocvar_g_ctf_score_pickup_base, autocvar_g_ctf_score_pickup_dropped_early, autocvar_g_ctf_score_pickup_dropped_late, autocvar_g_nades_bonus_score_minor, bound(), CH_TRIGGER, copyentity_qc(), ctf_captimerecord, CTF_DIFFTEAM, ctf_EventLog(), ctf_FakeTimeLimit(), ctf_FlagcarrierWaypoints(), CTF_SAMETEAM, ctf_stalemate, DAMAGE_NO, DIFF_TEAM, entity(), FLAG_CARRY, FLAG_CARRY_OFFSET, floor(), FOREACH_CLIENT, ftos(), g_damagedbycontents, g_flags, g_moveables, GameRules_scoring_add, GameRules_scoring_add_team, GameRules_scoring_vip, IL_CONTAINS(), IL_PUSH(), IL_REMOVE(), IS_PLAYER, LOG_TRACE, MOVETYPE_NONE, nades_GiveBonus(), NULL, PICKUP_BASE, PICKUP_DROPPED, SAME_TEAM, Send_Effect_(), Send_Notification(), set_movetype(), SetResourceExplicit(), SOLID_NOT, spawn, STATUSEFFECT_REMOVE_CLEAR, StatusEffects_removeall(), Team_ColorCode(), time, VEHICLE_FLAG_OFFSET, VEHICLE_FLAG_SCALE, VOL_BASE, WaypointSprite_Kill(), and WaypointSprite_Ping().

ctf_Handle_Retrieve()

void ctf_Handle_Retrieve	(	entity	flag,
		entity	player )

Definition at line 427 of file sv_ctf.qc.

{
    entity sender = flag.pass_sender;
 
    // transfer flag to player
    flag.owner = player;
    flag.owner.flagcarried = flag;
    GameRules_scoring_vip(player, true);
 
    // reset flag
    flag.solid = SOLID_NOT; // before setorigin to prevent area grid linking
    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.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;
}

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, Send_Notification(), set_movetype(), SOLID_NOT, time, VEHICLE_FLAG_OFFSET, VEHICLE_FLAG_SCALE, and VOL_BASE.

ctf_Handle_Return()

void ctf_Handle_Return	(	entity	flag,
		entity	player )

Definition at line 682 of file sv_ctf.qc.

{
    // messages and sounds
    if(IS_MONSTER(player))
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(flag.team, INFO_CTF_RETURN_MONSTER), player.m_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);
}

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

Referenced by ctf_FlagThink().

ctf_Handle_Throw()

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

Definition at line 478 of file sv_ctf.qc.

{
    entity flag = player.flagcarried;
    vector targ_origin, flag_velocity;
 
    if(!flag) { return; }
    if((droptype == DROP_PASS) && !receiver) { return; }
 
    if(flag.speedrunning || flag.classname == "phantomflag")
    {
        // 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 + vec3(0, 0, player.mins.z - flag.m_mins.z), // same bbox floor height as player
             flag.m_mins, flag.m_maxs, player.origin + FLAG_DROP_OFFSET, MOVE_NOMONSTERS, flag);
    flag.solid = SOLID_TRIGGER; // before setorigin to ensure area grid linking
    setorigin(flag, trace_endpos);
    if (trace_startsolid && !nudgeoutofsolid_OrFallback(flag)) // TODO: trace_allsolid would perform better but isn't 100% reliable yet
    {
        // the flag's bbox doesn't fit but we can assume the player's current bbox does
        tracebox(player.origin, player.mins, player.maxs, player.origin + FLAG_DROP_OFFSET, MOVE_NOMONSTERS, flag);
        flag.origin = trace_endpos;
        setsize(flag, player.mins, player.maxs); // this allows physics to move the flag somewhere its think func can resize it
    }
    flag.owner.flagcarried = NULL;
    GameRules_scoring_vip(flag.owner, false);
    flag.owner = NULL;
    flag.ctf_dropper = player;
    flag.ctf_droptime = time;
    flag.ctf_landtime = 0;
 
    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
}

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, navigation_dynamicgoal_set(), NULL, set_movetype(), SOLID_TRIGGER, StatusEffects_active(), time, trace_endpos, trace_startsolid, v_forward, vec3, vector, vlen(), VOL_BASE, W_CalculateProjectileVelocity(), WarpZone_RefSys_AddInverse(), WarpZone_RefSys_Copy(), WarpZone_RefSys_TransformOrigin(), WarpZone_TrailParticles(), WaypointSprite_Kill(), and WaypointSprite_Ping().

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

ctf_Immediate_Return_Allowed()

bool ctf_Immediate_Return_Allowed	(	entity	flag,
		entity	toucher )

Definition at line 143 of file sv_ctf.qc.

{
    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);
}

References autocvar_g_ctf_flag_return, autocvar_g_ctf_flag_return_carrying, entity(), FOREACH_CLIENT, IS_PLAYER, SAME_TEAM, and toucher.

ctf_Initialize()

void ctf_Initialize

(

)

Definition at line 2925 of file sv_ctf.qc.

{
    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);
}

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(), INITPRIO_GAMETYPE, NEW, NULL, record_type, ServerProgsDB, stof(), and strcat().

Referenced by REGISTER_MUTATOR().

ctf_RemovePlayer()

void ctf_RemovePlayer

(

entity

player

)

Definition at line 2378 of file sv_ctf.qc.

{
    if(player.flagcarried)
        { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }
 
    IL_EACH(g_flags, true,
    {
        if(it.pass_sender == player) { it.pass_sender = NULL; }
        if(it.pass_target == player) { it.pass_target = NULL; }
        if(it.ctf_dropper == player) { it.ctf_dropper = NULL; }
    });
}

References ctf_Handle_Throw(), DROP_NORMAL, entity(), g_flags, IL_EACH, and NULL.

Referenced by MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

ctf_Reset()

void ctf_Reset

(

entity

this

)

Definition at line 1297 of file sv_ctf.qc.

{
    if(this.owner && IS_PLAYER(this.owner))
        ctf_Handle_Throw(this.owner, NULL, DROP_RESET);
 
    this.enemy = NULL;
    ctf_RespawnFlag(this);
}

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

Referenced by ctf_FlagSetup().

ctf_RespawnFlag()

void ctf_RespawnFlag

(

entity

flag

)

Definition at line 1236 of file sv_ctf.qc.

{
    flag.watertype = CONTENT_EMPTY; // TODO: it is unclear why this workaround is needed, likely many other potential breakage points!!
 
    // 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, "");
    flag.solid = SOLID_TRIGGER; // before setorigin to ensure area grid linking
    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.velocity = '0 0 0';
    flag.angles = flag.mangle;
    flag.flags = FL_ITEM | FL_NOTARGET;
 
    flag.damagedbycontents = false;
    if(IL_CONTAINS(g_damagedbycontents, flag))
        IL_REMOVE(g_damagedbycontents, flag);
 
    StatusEffects_removeall(flag, STATUSEFFECT_REMOVE_CLEAR);
 
    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_landtime = 0;
    flag.ctf_flagdamaged_byworld = false;
    navigation_dynamicgoal_unset(flag);
 
    ctf_CheckStalemate();
 
    if(flag.classname == "phantomflag")
        delete(flag);
}

References CONTENT_EMPTY, ctf_CheckStalemate(), ctf_FakeTimeLimit(), DAMAGE_NO, entity(), FL_ITEM, FL_NOTARGET, FLAG_BASE, FLAG_DROPPED, FLAG_SCALE, g_damagedbycontents, GameRules_scoring_vip, IL_CONTAINS(), IL_REMOVE(), MOVETYPE_NONE, navigation_dynamicgoal_unset(), NULL, set_movetype(), SetResourceExplicit(), SOLID_TRIGGER, STATUSEFFECT_REMOVE_CLEAR, StatusEffects_removeall(), and WaypointSprite_Kill().

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

ctf_Return_Customize()

bool ctf_Return_Customize	(	entity	this,
		entity	client )

Definition at line 153 of file sv_ctf.qc.

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

References boolean, entity(), and owner.

Referenced by ctf_FlagcarrierWaypoints().

ctf_ScoreRules()

void ctf_ScoreRules

(

int

teams

)

Definition at line 2855 of file sv_ctf.qc.

{
    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);
    });
}

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

Referenced by ctf_DelayedInit().

ctf_SpawnTeam()

void ctf_SpawnTeam	(	string	teamname,
		int	teamcolor )

Definition at line 2869 of file sv_ctf.qc.

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

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

Referenced by ctf_DelayedInit().

ctf_Stalemate_Customize()

bool ctf_Stalemate_Customize	(	entity	this,
		entity	client )

Definition at line 886 of file sv_ctf.qc.

{
    // 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) || !IS_PLAYER(e))
        return false;
    if(IS_INVISIBLE(wp_owner))
        return false; // hide the waypointsprite if the owner is invisible
 
    return true;
}

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

Referenced by ctf_CheckStalemate(), and ctf_FlagcarrierWaypoints().

havocbot_ctf_calculate_middlepoint()

void havocbot_ctf_calculate_middlepoint

(

)

Definition at line 1479 of file sv_ctf.qc.

{
    vector s = '0 0 0';
    vector fo = '0 0 0';
    int n = 0;
 
    entity f1 = NULL, f2 = NULL;
 
    IL_EACH(g_flags, it.classname != "phantomflag",
    {
        // save base flags incase symmetry is checked
        if(!f1 && it.team == NUM_TEAM_1)
            f1 = it;
        else if(!f2 && it.team == NUM_TEAM_2)
            f2 = it;
        fo = it.origin;
        s += fo;
        ++n;
    });
    if(!n)
        return;
 
    // TODO: Consider changing this back to `s / n` after https://github.com/graphitemaster/gmqcc/issues/210.
    havocbot_middlepoint = s * (1 / 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
        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;
}

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

Referenced by ctf_DelayedInit().

havocbot_ctf_find_enemy_flag()

entity havocbot_ctf_find_enemy_flag

(

entity

bot

)

Definition at line 1528 of file sv_ctf.qc.

{
    IL_EACH(g_flags, true,
    {
        if(ctf_oneflag)
        {
            if(CTF_DIFFTEAM(bot, it))
            {
                if(it.team)
                {
                    if(bot.flagcarried)
                        return it;
                }
                else if(!bot.flagcarried)
                    return it;
            }
        }
        else if (CTF_DIFFTEAM(bot, it))
            return it;
    });
    return NULL;
}

References CTF_DIFFTEAM, ctf_oneflag, entity(), g_flags, IL_EACH, 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().

havocbot_ctf_find_flag()

entity havocbot_ctf_find_flag

(

entity

bot

)

Definition at line 1519 of file sv_ctf.qc.

{
    IL_EACH(g_flags, CTF_SAMETEAM(bot, it),
    {
        return it;
    });
    return NULL;
}

References CTF_SAMETEAM, entity(), g_flags, IL_EACH, 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().

havocbot_ctf_is_basewaypoint()

bool havocbot_ctf_is_basewaypoint

(

entity

item

)

Definition at line 1780 of file sv_ctf.qc.

{
    if (item.classname != "waypoint")
        return false;
 
    IL_EACH(g_flags, item == it.bot_basewaypoint,
    {
        return true;
    });
    return false;
}

References entity(), g_flags, and IL_EACH.

Referenced by havocbot_role_ctf_carrier(), and havocbot_role_ctf_middle().

havocbot_ctf_reset_role()

void havocbot_ctf_reset_role

(

entity

this

)

Definition at line 1701 of file sv_ctf.qc.

{
    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;
}

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().

havocbot_ctf_teamcount()

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

Definition at line 1551 of file sv_ctf.qc.

{
    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;
}

References DIFF_TEAM, entity(), FOREACH_CLIENT, IS_DEAD, IS_PLAYER, org, teamplay, vdist, and vector.

Referenced by havocbot_ctf_reset_role().

havocbot_goalrating_ctf_droppedflags()

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

Definition at line 1682 of file sv_ctf.qc.

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

References entity(), FLAG_BASE, g_flags, IL_EACH, navigation_routerating(), NULL, org, vdist, and vector.

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

havocbot_goalrating_ctf_enemybase()

void havocbot_goalrating_ctf_enemybase	(	entity	this,
		float	ratingscale )

Definition at line 1649 of file sv_ctf.qc.

{
    // 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);
}

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().

havocbot_goalrating_ctf_enemyflag()

void havocbot_goalrating_ctf_enemyflag	(	entity	this,
		float	ratingscale )

Definition at line 1605 of file sv_ctf.qc.

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

References bound(), CTF_DIFFTEAM, ctf_oneflag, entity(), FLAG_CARRY, flagcarried, g_flags, GetResource(), IL_EACH, navigation_routerating(), NULL, and RES_ARMOR.

Referenced by havocbot_role_ctf_escort().

havocbot_goalrating_ctf_ourbase()

void havocbot_goalrating_ctf_ourbase	(	entity	this,
		float	ratingscale )

Definition at line 1586 of file sv_ctf.qc.

{
    entity chosen = NULL;
    IL_EACH(g_flags, CTF_SAMETEAM(this, it),
    {
        if(this.flagcarried)
        if((this.flagcarried.cnt || it.cnt) && this.flagcarried.cnt != it.cnt)
        {
            // skip base if it has a different group
            continue;
        }
 
        chosen = it;
        break;
    });
 
    navigation_routerating(this, chosen.bot_basewaypoint, ratingscale, 10000);
}

References CTF_SAMETEAM, entity(), flagcarried, g_flags, IL_EACH, navigation_routerating(), and NULL.

Referenced by havocbot_role_ctf_carrier(), and havocbot_role_ctf_defense().

havocbot_goalrating_ctf_ourstolenflag()

void havocbot_goalrating_ctf_ourstolenflag	(	entity	this,
		float	ratingscale )

Definition at line 1669 of file sv_ctf.qc.

{
    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);
}

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().

havocbot_role_ctf_carrier()

void havocbot_role_ctf_carrier

(

entity

this

)

Definition at line 1792 of file sv_ctf.qc.

{
    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.enemy) ? 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;
        }
    }
}

References ctf_oneflag, Damage(), DMG_NOWEP, enemy, 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().

havocbot_role_ctf_defense()

void havocbot_role_ctf_defense

(

entity

this

)

Definition at line 2108 of file sv_ctf.qc.

{
    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);
    }
}

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, org, origin, random(), time, vdist, vector, and vlen().

Referenced by havocbot_role_ctf_setrole().

havocbot_role_ctf_escort()

void havocbot_role_ctf_escort

(

entity

this

)

Definition at line 1845 of file sv_ctf.qc.

{
    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);
    }
}

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().

havocbot_role_ctf_middle()

void havocbot_role_ctf_middle

(

entity

this

)

Definition at line 2049 of file sv_ctf.qc.

{
    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);
    }
}

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(), org, origin, time, vdist, and vector.

Referenced by havocbot_role_ctf_setrole().

havocbot_role_ctf_offense()

void havocbot_role_ctf_offense

(

entity

this

)

Definition at line 1913 of file sv_ctf.qc.

{
    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);
    }
}

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().

havocbot_role_ctf_retriever()

void havocbot_role_ctf_retriever

(

entity

this

)

Definition at line 1991 of file sv_ctf.qc.

{
    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);
    }
}

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().

havocbot_role_ctf_setrole()

void havocbot_role_ctf_setrole	(	entity	bot,
		int	role )

Definition at line 2177 of file sv_ctf.qc.

{
    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);
}

References entity(), 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().

if() [1/2]

if

(

frag_attacker.

flagcarried

)

Definition at line 2325 of file sv_ctf.qc.

    {
        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;
    }

References autocvar_g_ctf_flagcarrier_damagefactor, autocvar_g_ctf_flagcarrier_forcefactor, autocvar_g_ctf_flagcarrier_selfdamagefactor, autocvar_g_ctf_flagcarrier_selfforcefactor, frag_damage, frag_force, frag_target, M_ARGV, and vector.

Referenced by bot_removefromlargestteam(), botframe_showwaypointlinks(), findnearest(), GameCommand(), HUD_ItemsTime(), NadeOffhand::offhand_think(), and trigger_race_checkpoint_verify().

if() [2/2]

else if

(

frag_target.flagcarried &&!

IS_DEADfrag_target) &&CTF_DIFFTEAM(frag_target, frag_attacker

)

Definition at line 2341 of file sv_ctf.qc.

    {
        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?
    }

References autocvar_g_balance_armor_blockpercent, autocvar_g_ctf_flagcarrier_auto_helpme_damage, autocvar_g_ctf_flagcarrier_auto_helpme_time, frag_target, GetResource(), healtharmor_maxdamage(), IS_DEAD, RES_ARMOR, time, and WaypointSprite_HelpMePing().

MUTATOR_HOOKFUNCTION() [1/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		AbortSpeedrun	)

Definition at line 2581 of file sv_ctf.qc.

{
    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;
    }
}

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

MUTATOR_HOOKFUNCTION() [2/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		ClientConnect	)

Definition at line 2405 of file sv_ctf.qc.

{
    if(!autocvar_g_ctf_leaderboard)
        return;
 
    entity player = M_ARGV(0, entity);
 
    race_SendAll(player, true);
}

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

MUTATOR_HOOKFUNCTION() [3/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		ClientDisconnect	)

Definition at line 2398 of file sv_ctf.qc.

{
    entity player = M_ARGV(0, entity);
 
    ctf_RemovePlayer(player);
}

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

MUTATOR_HOOKFUNCTION() [4/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		DropSpecialItems	)

Definition at line 2704 of file sv_ctf.qc.

{
    entity frag_target = M_ARGV(0, entity);
 
    if(frag_target.flagcarried)
        ctf_Handle_Throw(frag_target, NULL, DROP_THROW);
}

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

MUTATOR_HOOKFUNCTION() [5/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GetPressedKeys	)

Definition at line 2415 of file sv_ctf.qc.

{
    if(!autocvar_g_ctf_leaderboard)
        return;
 
    entity player = M_ARGV(0, entity);
 
    race_checkAndWriteName(player);
}

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

MUTATOR_HOOKFUNCTION() [6/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GetRecords	)

Definition at line 2636 of file sv_ctf.qc.

{
    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;
}

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

MUTATOR_HOOKFUNCTION() [7/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		GiveFragsForKill	)

Definition at line 2372 of file sv_ctf.qc.

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

References autocvar_g_ctf_ignore_frags, and M_ARGV.

MUTATOR_HOOKFUNCTION() [8/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		HavocBot_ChooseRole	)

Definition at line 2623 of file sv_ctf.qc.

{
    entity bot = M_ARGV(0, entity);
 
    havocbot_ctf_reset_role(bot);
    return true;
}

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

MUTATOR_HOOKFUNCTION() [9/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		HelpMePing	)

Definition at line 2525 of file sv_ctf.qc.

{
    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;
}

References entity(), FLAG_WAYPOINT_OFFSET, M_ARGV, NULL, time, waypointsprite_deployed_lifetime, WaypointSprite_HelpMePing(), waypointsprite_limitedrange, WaypointSprite_Ping(), WaypointSprite_Spawn(), and wps_helpme.

MUTATOR_HOOKFUNCTION() [10/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		LogDeath_AppendItemCodes	)

Definition at line 2712 of file sv_ctf.qc.

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

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

MUTATOR_HOOKFUNCTION() [11/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		MakePlayerObserver	)

Definition at line 2391 of file sv_ctf.qc.

{
    entity player = M_ARGV(0, entity);
 
    ctf_RemovePlayer(player);
}

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

MUTATOR_HOOKFUNCTION() [12/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		MatchEnd	)

Definition at line 2593 of file sv_ctf.qc.

{
    IL_EACH(g_flags, true,
    {
        switch(it.ctf_status)
        {
            case FLAG_DROPPED:
            case FLAG_PASSING:
            {
                // lock the flag, game is over
                set_movetype(it, MOVETYPE_NONE);
                it.takedamage = DAMAGE_NO;
                it.solid = SOLID_NOT;
                it.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;
            }
        }
    });
}

References DAMAGE_NO, FLAG_BASE, FLAG_CARRY, FLAG_DROPPED, FLAG_PASSING, g_flags, IL_EACH, MOVETYPE_NONE, set_movetype(), and SOLID_NOT.

MUTATOR_HOOKFUNCTION() [13/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerDies	)

Definition at line 2353 of file sv_ctf.qc.

{
    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;
    }
}

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

MUTATOR_HOOKFUNCTION() [14/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerPreThink	)

Definition at line 2230 of file sv_ctf.qc.

{
    entity player = M_ARGV(0, entity);
 
    // 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);
 
    // do an iteration for each team (plus neutral) and get the flag for that team
    // this allows selection of the "best" flag for each team (e.g. the carried one)
    for(int j = 0; j <= AVAILABLE_TEAMS; ++j)
    {
        int teamnumber = (j > 0) ? Team_IndexToTeam(j) : 0;
        entity bestflag = NULL;
        int bestprio = 0;
 
        IL_EACH(g_flags, it.team == teamnumber,
        {
            // if there's a neutral flag in the map, enable oneflag display
            if(it.team == 0)
                STAT(OBJECTIVE_STATUS, player) |= CTF_FLAG_NEUTRAL;
 
            // use a priority system to decide the preferred flag
            int prio = 0;
            if(it.owner == player || it.pass_sender == player)
                prio = 3;
            else if(it.ctf_status == FLAG_DROPPED)
                prio = 2;
            else if(it.ctf_status != FLAG_BASE)
                prio = 1;
 
            if(!bestflag || prio > bestprio)
            {
                bestflag = it;
                bestprio = prio;
            }
        });
 
        if(bestflag)
        {
            int t = 0, t2 = 0, t3 = 0;
            switch(bestflag.team)
            {
                case NUM_TEAM_1:  t = CTF_RED_FLAG_CARRYING;     t2 = CTF_RED_FLAG_TAKEN;      t3 = CTF_RED_FLAG_LOST; break;
                case NUM_TEAM_2:  t = CTF_BLUE_FLAG_CARRYING;       t2 = CTF_BLUE_FLAG_TAKEN;        t3 = CTF_BLUE_FLAG_LOST; break;
                case NUM_TEAM_3:  t = CTF_YELLOW_FLAG_CARRYING;   t2 = CTF_YELLOW_FLAG_TAKEN;        t3 = CTF_YELLOW_FLAG_LOST; break;
                case NUM_TEAM_4:  t = CTF_PINK_FLAG_CARRYING;       t2 = CTF_PINK_FLAG_TAKEN;        t3 = CTF_PINK_FLAG_LOST; break;
                case 0:             t = CTF_NEUTRAL_FLAG_CARRYING; t2 = CTF_NEUTRAL_FLAG_TAKEN;  t3 = CTF_NEUTRAL_FLAG_LOST; break;
            }
 
            switch(bestflag.ctf_status)
            {
                case FLAG_PASSING:
                case FLAG_CARRY:
                {
                    if((bestflag.owner == player) || (bestflag.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;
 
    ctf_CaptureShield_Update(player, 1);
 
    // 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);
}

References AVAILABLE_TEAMS, CTF_BLUE_FLAG_CARRYING, CTF_BLUE_FLAG_LOST, CTF_BLUE_FLAG_TAKEN, CTF_FLAG_NEUTRAL, CTF_NEUTRAL_FLAG_CARRYING, CTF_NEUTRAL_FLAG_LOST, CTF_NEUTRAL_FLAG_TAKEN, CTF_PINK_FLAG_CARRYING, CTF_PINK_FLAG_LOST, CTF_PINK_FLAG_TAKEN, CTF_RED_FLAG_CARRYING, CTF_RED_FLAG_LOST, CTF_RED_FLAG_TAKEN, CTF_SHIELDED, CTF_STALEMATE, CTF_YELLOW_FLAG_CARRYING, CTF_YELLOW_FLAG_LOST, CTF_YELLOW_FLAG_TAKEN, entity(), FLAG_CARRY, FLAG_DROPPED, FLAG_PASSING, g_flags, IL_EACH, M_ARGV, NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, PlayerPreThink, STAT, and Team_IndexToTeam().

MUTATOR_HOOKFUNCTION() [15/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PlayerUseKey	)

Definition at line 2434 of file sv_ctf.qc.

{
    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 teammate
        if(autocvar_g_ctf_pass && player.flagcarried.classname != "phantomflag")
        {
            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) && !IS_INDEPENDENT_PLAYER(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 && head.flagcarried.classname != "phantomflag")
                        {
                            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;
            }
        }
    }
}

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(), game_stopped, IS_BOT_CLIENT, IS_DEAD, IS_INDEPENDENT_PLAYER, IS_PLAYER, M_ARGV, MUTATOR_RETURNVALUE, NULL, PlayerUseKey(), rint(), SAME_TEAM, Send_Notification(), time, vector, vlen2, WarpZone_FindRadius(), and WarpZone_UnTransformOrigin().

MUTATOR_HOOKFUNCTION() [16/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		PortalTeleport	)

Definition at line 2425 of file sv_ctf.qc.

{
    entity player = M_ARGV(0, entity);
 
    if(player.flagcarried)
    if(!autocvar_g_ctf_portalteleport)
        { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }
}

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

MUTATOR_HOOKFUNCTION() [17/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		SV_ParseClientCommand	)

Definition at line 2661 of file sv_ctf.qc.

{
    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;
    }
}

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

MUTATOR_HOOKFUNCTION() [18/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		TeamBalance_CheckAllowedTeams	)

Definition at line 2631 of file sv_ctf.qc.

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

References M_ARGV, and TeamBalance_CheckAllowedTeams().

MUTATOR_HOOKFUNCTION() [19/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		VehicleEnter	)

Definition at line 2543 of file sv_ctf.qc.

{
    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;
    }
}

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

MUTATOR_HOOKFUNCTION() [20/20]

MUTATOR_HOOKFUNCTION	(	ctf	,
		VehicleExit	)

Definition at line 2566 of file sv_ctf.qc.

{
    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;
    }
}

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

nades_GiveBonus()

void nades_GiveBonus	(	entity	player,
		float	score )

Definition at line 434 of file sv_nades.qc.

{
    if (autocvar_g_nades)
    if (autocvar_g_nades_bonus)
    if (IS_REAL_CLIENT(player))
    if (IS_PLAYER(player) && STAT(NADE_BONUS, player) < autocvar_g_nades_bonus_max)
    if (!STAT(FROZEN, player))
    if (!IS_DEAD(player))
    {
        if ( STAT(NADE_BONUS_SCORE, player) < 1 )
            STAT(NADE_BONUS_SCORE, player) += score/autocvar_g_nades_bonus_score_max;
 
        if ( STAT(NADE_BONUS_SCORE, player) >= 1 )
        {
            Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_NADE_BONUS);
            play2(player, SND(NADE_BONUS));
            STAT(NADE_BONUS, player)++;
            STAT(NADE_BONUS_SCORE, player) -= 1;
        }
    }
}

References autocvar_g_nades, autocvar_g_nades_bonus, autocvar_g_nades_bonus_max, autocvar_g_nades_bonus_score_max, entity(), IS_DEAD, IS_PLAYER, IS_REAL_CLIENT, play2(), Send_Notification(), SND, and STAT.

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

spawnfunc() [1/22]

spawnfunc

(

ctf_team

)

Definition at line 2821 of file sv_ctf.qc.

{
    if(!g_ctf) { delete(this); return; }
 
    this.team = this.cnt + 1;
}

References cnt, g_ctf, and team.

spawnfunc() [2/22]

spawnfunc

(

info_player_team1

)

Definition at line 202 of file spawnpoints.qc.

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

References NUM_TEAM_1, and team.

spawnfunc() [3/22]

spawnfunc

(

info_player_team2

)

Definition at line 212 of file spawnpoints.qc.

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

References NUM_TEAM_2, and team.

spawnfunc() [4/22]

spawnfunc

(

item_flag_neutral

)

Definition at line 2807 of file sv_ctf.qc.

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

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

spawnfunc() [5/22]

spawnfunc

(

item_flag_team1

)

Definition at line 2735 of file sv_ctf.qc.

{
    if(!g_ctf) { delete(this); return; }
 
    ctf_FlagSetup(NUM_TEAM_1, this);
}

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_1.

spawnfunc() [6/22]

spawnfunc

(

item_flag_team2

)

Definition at line 2753 of file sv_ctf.qc.

{
    if(!g_ctf) { delete(this); return; }
 
    ctf_FlagSetup(NUM_TEAM_2, this);
}

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_2.

spawnfunc() [7/22]

spawnfunc

(

item_flag_team3

)

Definition at line 2771 of file sv_ctf.qc.

{
    if(!g_ctf) { delete(this); return; }
 
    ctf_FlagSetup(NUM_TEAM_3, this);
}

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_3.

spawnfunc() [8/22]

spawnfunc

(

item_flag_team4

)

Definition at line 2789 of file sv_ctf.qc.

{
    if(!g_ctf) { delete(this); return; }
 
    ctf_FlagSetup(NUM_TEAM_4, this);
}

References ctf_FlagSetup(), g_ctf, and NUM_TEAM_4.

spawnfunc() [9/22]

spawnfunc

(

team_blueplayer

)

Definition at line 2843 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [10/22]

spawnfunc

(

team_CTF_blueflag

)

Definition at line 2830 of file sv_ctf.qc.

{ spawnfunc_item_flag_team2(this);    }

spawnfunc() [11/22]

spawnfunc

(

team_CTF_blueplayer

)

Definition at line 2835 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [12/22]

spawnfunc

(

team_CTF_bluespawn

)

Definition at line 2836 of file sv_ctf.qc.

{ spawnfunc_info_player_team2(this);  }

spawnfunc() [13/22]

spawnfunc

(

team_CTF_neutralflag

)

Definition at line 2838 of file sv_ctf.qc.

{ spawnfunc_item_flag_neutral(this);  }

spawnfunc() [14/22]

spawnfunc

(

team_CTF_redflag

)

Definition at line 2829 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [15/22]

spawnfunc

(

team_CTF_redplayer

)

Definition at line 2832 of file sv_ctf.qc.

{ spawnfunc_info_player_team1(this);  }

spawnfunc() [16/22]

spawnfunc

(

team_CTF_redspawn

)

Definition at line 2833 of file sv_ctf.qc.

{ spawnfunc_info_player_team1(this);  }

spawnfunc() [17/22]

spawnfunc

(

team_CTL_bluelolly

)

Definition at line 2847 of file sv_ctf.qc.

{ spawnfunc_item_flag_team2(this);    }

spawnfunc() [18/22]

spawnfunc

(

team_ctl_bluelolly

)

Definition at line 2846 of file sv_ctf.qc.

{ spawnfunc_item_flag_team2(this);    }

spawnfunc() [19/22]

spawnfunc

(

team_CTL_redlolly

)

Definition at line 2845 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [20/22]

spawnfunc

(

team_ctl_redlolly

)

Definition at line 2844 of file sv_ctf.qc.

{ spawnfunc_item_flag_team1(this);    }

spawnfunc() [21/22]

spawnfunc

(

team_neutralobelisk

)

Definition at line 2839 of file sv_ctf.qc.

{ spawnfunc_item_flag_neutral(this);  }

spawnfunc() [22/22]

spawnfunc

(

team_redplayer

)

Definition at line 2842 of file sv_ctf.qc.

{ spawnfunc_info_player_team1(this);  }

superspec_msg()

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

Definition at line 66 of file sv_superspec.qc.

{
    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));
}

References centerprint(), entity(), sprint(), SSF_SILENT, SSF_VERBOSE, and strcat().

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

superspec_Spectate()

bool superspec_Spectate	(	entity	this,
		entity	targ )

Definition at line 28 of file sv_superspec.qc.

{
    Spectate(this, targ);
    return true;
}

References entity(), and Spectate().

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

Variable Documentation

autocvar_g_ctf_allow_monster_touch

bool autocvar_g_ctf_allow_monster_touch

Definition at line 23 of file sv_ctf.qc.

autocvar_g_ctf_allow_vehicle_carry

bool autocvar_g_ctf_allow_vehicle_carry

Definition at line 21 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 22 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_drop_velocity_side

float autocvar_g_ctf_drop_velocity_side

Definition at line 34 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 33 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 92 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 93 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_dynamiclights

bool autocvar_g_ctf_dynamiclights

Definition at line 48 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 49 of file sv_ctf.qc.

Referenced by ctf_Handle_Capture(), and ctf_Handle_Return().

autocvar_g_ctf_flag_damageforcescale

float autocvar_g_ctf_flag_damageforcescale

Definition at line 50 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 52 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 51 of file sv_ctf.qc.

Referenced by ctf_Handle_Drop().

autocvar_g_ctf_flag_glowtrails

bool autocvar_g_ctf_flag_glowtrails

Definition at line 53 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_flag_health

float autocvar_g_ctf_flag_health

Definition at line 54 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 55 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 57 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 56 of file sv_ctf.qc.

Referenced by ctf_Immediate_Return_Allowed().

autocvar_g_ctf_flag_return_damage

float autocvar_g_ctf_flag_return_damage

Definition at line 60 of file sv_ctf.qc.

Referenced by ctf_CheckFlagReturn(), 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 61 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 62 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 58 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 59 of file sv_ctf.qc.

Referenced by ctf_FlagSetup(), and ctf_Handle_Drop().

autocvar_g_ctf_flag_stay

bool autocvar_g_ctf_flag_stay

Definition at line 63 of file sv_ctf.qc.

Referenced by ctf_Handle_Pickup().

autocvar_g_ctf_flag_waypoint

bool autocvar_g_ctf_flag_waypoint = true

Definition at line 64 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 65 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 66 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_flagcarrier_auto_helpme_time

float autocvar_g_ctf_flagcarrier_auto_helpme_time

Definition at line 67 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_flagcarrier_damagefactor

float autocvar_g_ctf_flagcarrier_damagefactor

Definition at line 70 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_flagcarrier_forcefactor

float autocvar_g_ctf_flagcarrier_forcefactor

Definition at line 71 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_flagcarrier_selfdamagefactor

float autocvar_g_ctf_flagcarrier_selfdamagefactor

Definition at line 68 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_flagcarrier_selfforcefactor

float autocvar_g_ctf_flagcarrier_selfforcefactor

Definition at line 69 of file sv_ctf.qc.

Referenced by if().

autocvar_g_ctf_fullbrightflags

bool autocvar_g_ctf_fullbrightflags

Definition at line 73 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_ignore_frags

bool autocvar_g_ctf_ignore_frags

Definition at line 74 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_oneflag_reverse

bool autocvar_g_ctf_oneflag_reverse

Definition at line 35 of file sv_ctf.qc.

autocvar_g_ctf_pass

bool autocvar_g_ctf_pass

Definition at line 37 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_pass_arc

float autocvar_g_ctf_pass_arc

Definition at line 38 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 39 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 40 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 41 of file sv_ctf.qc.

Referenced by ctf_CheckPassDirection().

autocvar_g_ctf_pass_radius

float autocvar_g_ctf_pass_radius

Definition at line 42 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 44 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_pass_timelimit

float autocvar_g_ctf_pass_timelimit

Definition at line 46 of file sv_ctf.qc.

Referenced by ctf_FlagThink().

autocvar_g_ctf_pass_turnrate

float autocvar_g_ctf_pass_turnrate

Definition at line 45 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_velocity

float autocvar_g_ctf_pass_velocity

Definition at line 47 of file sv_ctf.qc.

Referenced by ctf_CalculatePassVelocity().

autocvar_g_ctf_pass_wait

float autocvar_g_ctf_pass_wait

Definition at line 43 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 36 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_reverse

bool autocvar_g_ctf_reverse

Definition at line 91 of file sv_ctf.qc.

autocvar_g_ctf_score_capture

int autocvar_g_ctf_score_capture

Definition at line 76 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 77 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 75 of file sv_ctf.qc.

Referenced by ctf_FlagSetup().

autocvar_g_ctf_score_kill

int autocvar_g_ctf_score_kill

Definition at line 78 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 79 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 80 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 81 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 82 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 83 of file sv_ctf.qc.

Referenced by ctf_Handle_Pickup().

autocvar_g_ctf_score_return

int autocvar_g_ctf_score_return

Definition at line 84 of file sv_ctf.qc.

Referenced by ctf_Handle_Return().

autocvar_g_ctf_shield_force

float autocvar_g_ctf_shield_force

Definition at line 85 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 86 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 87 of file sv_ctf.qc.

Referenced by ctf_Initialize().

autocvar_g_ctf_stalemate

bool autocvar_g_ctf_stalemate

Definition at line 88 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 89 of file sv_ctf.qc.

Referenced by ctf_CheckStalemate().

autocvar_g_ctf_stalemate_time

float autocvar_g_ctf_stalemate_time

Definition at line 90 of file sv_ctf.qc.

Referenced by ctf_CheckStalemate().

autocvar_g_ctf_throw

bool autocvar_g_ctf_throw

Definition at line 24 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 25 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 26 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 27 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 28 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 29 of file sv_ctf.qc.

Referenced by MUTATOR_HOOKFUNCTION().

autocvar_g_ctf_throw_strengthmultiplier

float autocvar_g_ctf_throw_strengthmultiplier

Definition at line 30 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 31 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 32 of file sv_ctf.qc.

Referenced by ctf_Handle_Throw().

frag_damage

float frag_damage = M_ARGV(4, float)

Definition at line 2322 of file sv_ctf.qc.

Referenced by buff_Inferno_CalculateDamage(), buff_Jump_ChangeDamage(), buff_Luck_CalculateDamage(), buff_Medic_CalculateSurviveDamage(), buff_Resistance_CalculateDamage(), buff_Vengeance_CalculateDamage(), if(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

frag_force

vector frag_force = M_ARGV(6, vector)

Definition at line 2323 of file sv_ctf.qc.

Referenced by buff_Bash_AttackerCalculateForce(), buff_Bash_TargetCalculateForce(), if(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

frag_target

entity frag_target = M_ARGV(2, entity)

Definition at line 2321 of file sv_ctf.qc.

Referenced by buff_Bash_AttackerCalculateForce(), buff_Bash_TargetCalculateForce(), buff_Disability_ApplyStunned(), if(), if(), if(), if(), if(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

pushable

bool pushable

Definition at line 1348 of file sv_ctf.qc.