sv_turrets.qh File Reference

#include "all.qh"

Include dependency graph for sv_turrets.qh:

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

Go to the source code of this file.

Macros
#define	X(class, prefix, fld, type)

Functions
	bool (entity this, entity e_target, entity e_sender) turret_addtarget
	float (entity _turret, entity _target) turret_score_target
	Function to use for target evaluation. usualy turret_targetscore_generic.
	float (entity this) turret_firecheckfunc
	STATIC_INIT (g_turrets)
bool	turret_closetotarget (entity this, vector targ, float range)
void	turret_do_updates (entity e_turret)
	updates aim org, shot org, shot dir and enemy org for selected turret
bool	turret_firecheck (entity this)
	Preforms pre-fire checks based on the uints firecheck_flags.
bool	turret_initialize (entity this, Turret tur)
entity	turret_projectile (entity actor, Sound _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim)
void	turret_projectile_explode (entity this)
void	turret_respawn (entity this)
entity	turret_select_target (entity this)
float	turret_validate_target (entity e_turret, entity e_target, float validate_flags)
	Evaluate a entity for target valitity based on validate_flags NOTE: the caller must check takedamage before calling this, to inline this check.
void	turrets_setframe (entity this, float _frame, float client_only)

Variables
float	ammo
bool	autocvar_g_turrets
float	autocvar_g_turrets_aimidle_delay
bool	autocvar_g_turrets_nofire
bool	autocvar_g_turrets_reloadcvars
float	autocvar_g_turrets_targetscan_maxdelay
float	autocvar_g_turrets_targetscan_mindelay
IntrusiveList	g_turrets
vector	idle_aim
entity	pathcurrent
entity	pathgoal
float	target_select_time
float	target_validate_time
const float	TFL_TRACKTYPE_FLUIDINERTIA = 3
const float	TFL_TRACKTYPE_FLUIDPRECISE = 2
const float	TFL_TRACKTYPE_STEPMOTOR = 1
vector	tur_aimpos
entity	tur_defend
float	tur_dist_aimpos
float	tur_dist_enemy
float	tur_dist_impact_to_aimpos
entity	tur_head
entity	tur_impactent
float	tur_impacttime
vector	tur_shotdir_updated
vector	tur_shotorg
float	turret_count
float	turret_scale_aim
	Map time control aim speed.
float	turret_scale_ammo
	Map time control ammo held and recharged.
float	turret_scale_damage
	Map time control over pain inflicted.
float	turret_scale_health
	Map time control health.
float	turret_scale_range
	Map time control targetting range.
float	turret_scale_refire
	Map time control refire.
float	turret_scale_respawn
	Map time control respawn time.
float	tvt_dist
vector	tvt_tadv
float	tvt_thadf
vector	tvt_thadv
float	volly_counter

Macro Definition Documentation

X

#define X	(		class,
			prefix,
			fld,
			type )

Value:

.type fld;

Definition at line 20 of file sv_turrets.qh.

Function Documentation

bool()

bool	(	entity	this,
		entity	e_target,
		entity	e_sender )

References entity().

float() [1/2]

float	(	entity	_turret,
		entity	_target )

Function to use for target evaluation. usualy turret_targetscore_generic.

References entity().

float() [2/2]

float

(

entity

this

)

References entity(), and vector.

STATIC_INIT()

STATIC_INIT

(

g_turrets

)

Definition at line 114 of file sv_turrets.qh.

{
    g_turrets = IL_NEW();
}

References g_turrets, and IL_NEW.

turret_closetotarget()

bool turret_closetotarget	(	entity	this,
		vector	targ,
		float	range )

Definition at line 1212 of file sv_turrets.qc.

{
    vector path_extra_size = '1 1 1' * range;
    return boxesoverlap(targ - path_extra_size, targ + path_extra_size, this.absmin - path_extra_size, this.absmax + path_extra_size);
}

References absmax, absmin, boxesoverlap(), entity(), and vector.

Referenced by ewheel_move_path(), Monster_Move(), and walker_move_path().

turret_do_updates()

void turret_do_updates

(

entity

t_turret

)

updates aim org, shot org, shot dir and enemy org for selected turret

updates aim org, shot org, shot dir and enemy org for selected turret

Definition at line 496 of file sv_turrets.qc.

{
    vector enemy_pos = real_origin(t_turret.enemy);
 
    turret_tag_fire_update(t_turret);
 
    t_turret.tur_shotdir_updated = v_forward;
    t_turret.tur_dist_enemy  = vlen(t_turret.tur_shotorg - enemy_pos);
    t_turret.tur_dist_aimpos = vlen(t_turret.tur_shotorg - t_turret.tur_aimpos);
 
    /*if ((t_turret.firecheck_flags & TFL_FIRECHECK_VERIFIED) && t_turret.enemy)
    {
        oldpos = t_turret.enemy.origin;
        setorigin(t_turret.enemy, t_turret.tur_aimpos);
        tracebox(t_turret.tur_shotorg, '-1 -1 -1', '1 1 1', t_turret.tur_shotorg + t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos, MOVE_NORMAL, t_turret);
        setorigin(t_turret.enemy, oldpos);
 
        if (trace_ent == t_turret.enemy)
            t_turret.tur_dist_impact_to_aimpos = 0;
        else
            t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos);
    }
    else*/
        tracebox(t_turret.tur_shotorg, '-1 -1 -1', '1 1 1', t_turret.tur_shotorg + t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos, MOVE_NORMAL, t_turret);
 
    t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos) - 0.5 * vlen(t_turret.enemy.maxs - t_turret.enemy.mins);
    t_turret.tur_impactent  = trace_ent;
    t_turret.tur_impacttime = vlen(t_turret.tur_shotorg - trace_endpos) / t_turret.shot_speed;
}

References entity(), MOVE_NORMAL, real_origin(), trace_endpos, trace_ent, turret_tag_fire_update(), v_forward, vector, and vlen().

Referenced by beam_think(), and turret_think().

turret_firecheck()

bool turret_firecheck

(

entity

this

)

Preforms pre-fire checks based on the uints firecheck_flags.

Definition at line 874 of file sv_turrets.qc.

{
    // This one just dont care =)
    if (this.firecheck_flags & TFL_FIRECHECK_NO)
        return true;
 
    if (this.enemy == NULL)
        return false;
 
    // Ready?
    if ((this.firecheck_flags & TFL_FIRECHECK_REFIRE)
    && this.attack_finished_single[0] > time)
        return false;
 
    // Special case: volly fire turret that has to fire a full volly if a shot was fired.
    if ((this.shoot_flags & TFL_SHOOT_VOLLYALWAYS)
    && this.volly_counter != this.shot_volly
    && this.ammo >= this.shot_dmg)
        return true;
 
    // Lack of zombies makes shooting dead things unnecessary :P
    if ((this.firecheck_flags & TFL_FIRECHECK_DEAD)
    && IS_DEAD(this.enemy))
        return false;
 
    // Own ammo?
    if ((this.firecheck_flags & TFL_FIRECHECK_AMMO_OWN)
    && this.ammo < this.shot_dmg)
        return false;
 
    // Other's ammo? (support-supply units)
    if ((this.firecheck_flags & TFL_FIRECHECK_AMMO_OTHER)
    && this.enemy.ammo >= this.enemy.ammo_max)
        return false;
 
    // Target of opertunity?
    if (turret_validate_target(this, this.tur_impactent, this.target_validate_flags) > 0)
    {
        this.enemy = this.tur_impactent;
        return true;
    }
 
    if (this.firecheck_flags & TFL_FIRECHECK_DISTANCES)
    {
        // To close?
        if (this.tur_dist_aimpos < this.target_range_min)
        {
            if (turret_validate_target(this, this.tur_impactent, this.target_validate_flags) > 0)
                return true; // Target of opertunity?
            return false;
        }
    }
 
    // Try to avoid FF?
    if ((this.firecheck_flags & TFL_FIRECHECK_AFF)
    && SAME_TEAM(this.tur_impactent, this))
        return false;
 
    // aim<->predicted impact
    if ((this.firecheck_flags & TFL_FIRECHECK_AIMDIST)
    && this.tur_dist_impact_to_aimpos > this.aim_firetolerance_dist)
        return false;
 
    // Volly status
    if (this.shot_volly > 1
    &&  this.volly_counter == this.shot_volly
    &&  this.ammo < this.shot_dmg * this.shot_volly)
        return false;
 
    /*
    if ((this.firecheck_flags & TFL_FIRECHECK_VERIFIED)
    && this.tur_impactent != this.enemy)
        return false;
    */
 
    return true;
}

References ammo, attack_finished_single, enemy, entity(), firecheck_flags, IS_DEAD, NULL, SAME_TEAM, shoot_flags, target_validate_flags, TFL_FIRECHECK_AFF, TFL_FIRECHECK_AIMDIST, TFL_FIRECHECK_AMMO_OTHER, TFL_FIRECHECK_AMMO_OWN, TFL_FIRECHECK_DEAD, TFL_FIRECHECK_DISTANCES, TFL_FIRECHECK_NO, TFL_FIRECHECK_REFIRE, TFL_SHOOT_VOLLYALWAYS, time, tur_dist_aimpos, tur_dist_impact_to_aimpos, tur_impactent, turret_validate_target(), and volly_counter.

Referenced by turret_initialize(), turret_phaser_firecheck(), turret_tesla_firecheck(), and walker_firecheck().

turret_initialize()

bool turret_initialize	(	entity	this,
		Turret	tur )

Definition at line 1247 of file sv_turrets.qc.

{
    if (!autocvar_g_turrets)
        return false;
 
    if (tur.m_id == 0)
        return false; // invalid turret
 
    // if tur_head exists, we can assume this turret re-spawned
    if (!this.tur_head)
    {
        tur.tr_precache(tur);
        IL_PUSH(g_turrets, this);
        IL_PUSH(g_bot_targets, this);
    }
 
    if (!(this.spawnflags & TSF_SUSPENDED))
        DropToFloor_QC_DelayedInit(this);
 
    this.netname = tur.netname;
    load_unit_settings(this, 0);
 
    if (!this.team || !teamplay)         this.team = FLOAT_MAX;
    if (!GetResource(this, RES_HEALTH))  SetResourceExplicit(this, RES_HEALTH, 1000);
    if (!this.shot_refire)               this.shot_refire = 1;
    if (!this.tur_shotorg)               this.tur_shotorg = '50 0 50';
    if (!this.turret_flags)              this.turret_flags = TUR_FLAG_SPLASH | TUR_FLAG_MEDPROJ | TUR_FLAG_PLAYER;
    if (!this.damage_flags)              this.damage_flags = TFL_DMG_YES | TFL_DMG_RETALIATE | TFL_DMG_AIMSHAKE;
    if (!this.aim_flags)                 this.aim_flags = TFL_AIM_LEAD | TFL_AIM_SHOTTIMECOMPENSATE;
    if (!this.track_type)                this.track_type = TFL_TRACKTYPE_STEPMOTOR;
    if (!this.track_flags)               this.track_flags = TFL_TRACK_PITCH | TFL_TRACK_ROTATE;
    if (!this.ammo_flags)                this.ammo_flags = TFL_AMMO_ENERGY | TFL_AMMO_RECHARGE;
    if (!this.target_select_flags)       this.target_select_flags = TFL_TARGETSELECT_LOS | TFL_TARGETSELECT_TEAMCHECK | TFL_TARGETSELECT_RANGELIMITS | TFL_TARGETSELECT_ANGLELIMITS;
    if (!this.firecheck_flags)           this.firecheck_flags = TFL_FIRECHECK_DEAD | TFL_FIRECHECK_DISTANCES | TFL_FIRECHECK_LOS
                                                              | TFL_FIRECHECK_AIMDIST | TFL_FIRECHECK_TEAMCHECK | TFL_FIRECHECK_AMMO_OWN | TFL_FIRECHECK_REFIRE;
 
    if (this.track_type != TFL_TRACKTYPE_STEPMOTOR)
    {
        // Fluid / Ineria mode. Looks mutch nicer.
        // Can reduce aim preformance alot, needs a bit diffrent aimspeed
 
        this.aim_speed = bound(0.1, (!this.aim_speed ? 180 : this.aim_speed), 1000);
 
        if (!this.track_accel_pitch)
            this.track_accel_pitch = 0.5;
        if (!this.track_accel_rot)
            this.track_accel_rot = 0.5;
        if (!this.track_blendrate)
            this.track_blendrate = 0.35;
    }
 
    turret_initparams(this);
 
    this.turret_flags = TUR_FLAG_ISTURRET | (tur.spawnflags);
 
    if (this.turret_flags & TUR_FLAG_SPLASH)
        this.aim_flags |= TFL_AIM_SPLASH;
 
    if (this.turret_flags & TUR_FLAG_MISSILE)
        this.target_select_flags |= TFL_TARGETSELECT_MISSILES;
 
    if (this.turret_flags & TUR_FLAG_PLAYER)
        this.target_select_flags |= TFL_TARGETSELECT_PLAYERS;
 
    if (this.spawnflags & TSL_NO_RESPAWN)
        this.damage_flags |= TFL_DMG_DEATH_NORESPAWN;
 
    if (this.turret_flags & TUR_FLAG_SUPPORT)
        this.turret_score_target = turret_targetscore_support;
    else
        this.turret_score_target = turret_targetscore_generic;
 
    ++turret_count;
 
    _setmodel(this, tur.model);
    setsize(this, tur.m_mins, tur.m_maxs);
 
    this.m_id                   = tur.m_id;
    this.active                 = ACTIVE_ACTIVE;
    this.effects                = EF_NODRAW;
    this.netname                = tur.m_name;
    this.max_health             = GetResource(this, RES_HEALTH);
    this.target_validate_flags  = this.target_select_flags;
    this.ammo                   = this.ammo_max;
    this.solid                  = SOLID_BBOX;
    this.takedamage             = DAMAGE_AIM;
    set_movetype(this, MOVETYPE_NOCLIP);
    this.view_ofs               = '0 0 0';
    this.idle_aim               = '0 0 0';
    this.turret_firecheckfunc   = turret_firecheck;
    this.event_damage           = turret_damage;
    this.event_heal             = turret_heal;
    this.use                    = turret_use;
    this.bot_attack             = true;
    this.nextthink              = time + 1;
    this.reset                  = turret_reset;
 
    this.tur_head = new(turret_head);
    _setmodel(this.tur_head, tur.head_model);
    setsize(this.tur_head, '0 0 0', '0 0 0');
    setorigin(this.tur_head, '0 0 0');
    setattachment(this.tur_head, this, "tag_head");
 
    this.tur_head.netname     = this.tur_head.classname;
    this.tur_head.team        = this.team;
    this.tur_head.owner       = this;
    this.tur_head.takedamage  = DAMAGE_NO;
    this.tur_head.solid       = SOLID_NOT;
    set_movetype(this.tur_head, this.move_movetype);
 
    this.weaponentities[0] = this; // lol
 
    if (!this.tur_defend && this.target != "")
        InitializeEntity(this, turret_findtarget, INITPRIO_FINDTARGET);
 
#ifdef TURRET_DEBUG
    this.tur_debug_start = this.nextthink;
    while (vdist(this.tur_debug_rvec, <, 2))
        this.tur_debug_rvec = randomvec() * 4;
 
    this.tur_debug_rvec.x = fabs(this.tur_debug_rvec.x);
    this.tur_debug_rvec.y = fabs(this.tur_debug_rvec.y);
    this.tur_debug_rvec.z = fabs(this.tur_debug_rvec.z);
#endif
 
    turret_link(this);
    turret_respawn(this);
    turret_tag_fire_update(this);
 
    tur.tr_setup(tur, this);
 
    if (MUTATOR_CALLHOOK(TurretSpawn, this))
        return false;
 
    return true;
}

References active, ACTIVE_ACTIVE, aim_flags, ammo, ammo_flags, autocvar_g_turrets, bot_attack, bound(), DAMAGE_AIM, damage_flags, DAMAGE_NO, DropToFloor_QC_DelayedInit(), EF_NODRAW, effects, entity(), fabs(), firecheck_flags, FLOAT_MAX, g_bot_targets, g_turrets, GetResource(), idle_aim, IL_PUSH(), InitializeEntity(), INITPRIO_FINDTARGET, load_unit_settings(), m_id, Turret::m_id, Turret::m_maxs, Turret::m_mins, Turret::m_name, max_health, move_movetype, MOVETYPE_NOCLIP, MUTATOR_CALLHOOK, netname, nextthink, randomvec(), set_movetype(), SetResourceExplicit(), solid, SOLID_BBOX, SOLID_NOT, spawnflags, Turret::spawnflags, takedamage, target, target_select_flags, target_validate_flags, team, teamplay, TFL_AIM_LEAD, TFL_AIM_SHOTTIMECOMPENSATE, TFL_AIM_SPLASH, TFL_AMMO_ENERGY, TFL_AMMO_RECHARGE, TFL_DMG_AIMSHAKE, TFL_DMG_DEATH_NORESPAWN, TFL_DMG_RETALIATE, TFL_DMG_YES, TFL_FIRECHECK_AIMDIST, TFL_FIRECHECK_AMMO_OWN, TFL_FIRECHECK_DEAD, TFL_FIRECHECK_DISTANCES, TFL_FIRECHECK_LOS, TFL_FIRECHECK_REFIRE, TFL_FIRECHECK_TEAMCHECK, TFL_TARGETSELECT_ANGLELIMITS, TFL_TARGETSELECT_LOS, TFL_TARGETSELECT_MISSILES, TFL_TARGETSELECT_PLAYERS, TFL_TARGETSELECT_RANGELIMITS, TFL_TARGETSELECT_TEAMCHECK, TFL_TRACK_PITCH, TFL_TRACK_ROTATE, TFL_TRACKTYPE_STEPMOTOR, time, Turret::tr_precache(), Turret::tr_setup(), track_flags, TSF_SUSPENDED, TSL_NO_RESPAWN, tur_defend, TUR_FLAG_ISTURRET, TUR_FLAG_MEDPROJ, TUR_FLAG_MISSILE, TUR_FLAG_PLAYER, TUR_FLAG_SPLASH, TUR_FLAG_SUPPORT, tur_head, tur_shotorg, turret_count, turret_damage(), turret_findtarget(), turret_firecheck(), turret_flags, turret_heal(), turret_initparams(), turret_link(), turret_reset(), turret_respawn(), turret_tag_fire_update(), turret_targetscore_generic(), turret_targetscore_support(), turret_use(), use, vdist, view_ofs, and weaponentities.

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

turret_projectile()

entity turret_projectile	(	entity	actor,
		Sound	_snd,
		float	_size,
		float	_health,
		float	_death,
		float	_proj_type,
		float	_cull,
		float	_cli_anim )

Definition at line 455 of file sv_turrets.qc.

{
    TC(Sound, _snd);
 
    sound(actor, CH_WEAPON_A, _snd, VOL_BASE, ATTEN_NORM);
    entity proj = spawn();
    setorigin(proj, actor.tur_shotorg);
    setsize(proj, '-0.5 -0.5 -0.5' * _size, '0.5 0.5 0.5' * _size);
    proj.owner     = actor;
    proj.realowner = actor;
    proj.bot_dodge = true;
    proj.bot_dodgerating = actor.shot_dmg;
    setthink(proj, turret_projectile_explode);
    settouch(proj, turret_projectile_touch);
    proj.nextthink = time + 9;
    set_movetype(proj, MOVETYPE_FLYMISSILE);
    proj.velocity = normalize(actor.tur_shotdir_updated + randomvec() * actor.shot_spread) * actor.shot_speed;
    proj.flags = FL_PROJECTILE;
    IL_PUSH(g_projectiles, proj);
    IL_PUSH(g_bot_dodge, proj);
    proj.enemy = actor.enemy;
    proj.projectiledeathtype = _death;
    PROJECTILE_MAKETRIGGER(proj);
    if (_health)
    {
        SetResourceExplicit(proj, RES_HEALTH, _health);
        proj.takedamage = DAMAGE_YES;
        proj.event_damage = turret_projectile_damage;
    }
    else
        proj.flags |= FL_NOTARGET;
 
    CSQCProjectile(proj, _cli_anim, _proj_type, _cull);
 
    return proj;
}

References ATTEN_NORM, CH_WEAPON_A, CSQCProjectile(), DAMAGE_YES, entity(), FL_NOTARGET, FL_PROJECTILE, g_bot_dodge, g_projectiles, IL_PUSH(), MOVETYPE_FLYMISSILE, normalize(), PROJECTILE_MAKETRIGGER, randomvec(), set_movetype(), SetResourceExplicit(), setthink, settouch, sound, spawn, TC, time, turret_projectile_damage(), turret_projectile_explode(), turret_projectile_touch(), and VOL_BASE.

turret_projectile_explode()

void turret_projectile_explode

(

entity

this

)

Definition at line 412 of file sv_turrets.qc.

{
    this.takedamage = DAMAGE_NO;
    this.event_damage = func_null;
 
#ifdef TURRET_DEBUG
    float d = RadiusDamage(this, this.owner,
#else
    RadiusDamage(this, this.realowner,
#endif
        this.owner.shot_dmg,
        0,
        this.owner.shot_radius,
        this,
        NULL,
        this.owner.shot_force,
        this.projectiledeathtype,
        DMG_NOWEP,
        NULL
    );
#ifdef TURRET_DEBUG
    this.owner.tur_debug_dmg_t_h += d;
    this.owner.tur_debug_dmg_t_f += this.owner.shot_dmg;
#endif
 
    delete(this);
}

References DAMAGE_NO, DMG_NOWEP, entity(), func_null(), NULL, owner, RadiusDamage(), realowner, and takedamage.

Referenced by turret_hellion_missile_think(), turret_hk_missile_think(), turret_projectile(), turret_projectile_damage(), and turret_projectile_touch().

turret_respawn()

void turret_respawn

(

entity

this

)

Definition at line 265 of file sv_turrets.qc.

{
    // Make sure all parts belong to the same team since
    // this function doubles as "teamchange" function.
    this.tur_head.team       = this.team;
    this.effects            &= ~EF_NODRAW;
    this.deadflag            = DEAD_NO;
    this.effects             = EF_LOWPRECISION;
    this.solid               = SOLID_BBOX;
    this.takedamage          = DAMAGE_AIM;
    this.event_damage        = turret_damage;
    this.event_heal          = turret_heal;
    this.avelocity           = '0 0 0';
    this.tur_head.avelocity  = this.avelocity;
    this.tur_head.angles     = this.idle_aim;
    SetResourceExplicit(this, RES_HEALTH, this.max_health);
    this.enemy               = NULL;
    this.volly_counter       = this.shot_volly;
    this.ammo                = this.ammo_max;
 
    this.nextthink = time;
    setthink(this, turret_think);
 
    this.SendFlags = TNSF_FULL_UPDATE;
 
    Turret tur = get_turretinfo(this.m_id);
    tur.tr_setup(tur, this);
 
    setorigin(this, this.origin); // make sure it's linked to the area grid
}

References ammo, avelocity, DAMAGE_AIM, DEAD_NO, deadflag, EF_LOWPRECISION, EF_NODRAW, effects, enemy, entity(), get_turretinfo, idle_aim, m_id, max_health, nextthink, NULL, origin, SendFlags, SetResourceExplicit(), setthink, solid, SOLID_BBOX, takedamage, team, time, TNSF_FULL_UPDATE, Turret::tr_setup(), tur_head, turret_damage(), turret_heal(), turret_think(), and volly_counter.

Referenced by assault_roundstart_use(), MUTATOR_HOOKFUNCTION(), turret_hide(), turret_initialize(), and turret_reset().

turret_select_target()

entity turret_select_target

(

entity

this

)

Definition at line 809 of file sv_turrets.qc.

{
    entity e;        // target looper entity
    float  score;    // target looper entity score
    entity e_enemy;  // currently best scoreing target
    float  m_score;  // currently best scoreing target's score
 
    m_score = 0;
    if (this.enemy && this.enemy.takedamage && turret_validate_target(this, this.enemy, this.target_validate_flags) > 0)
    {
        e_enemy = this.enemy;
        m_score = this.turret_score_target(this, e_enemy) * this.target_select_samebias;
    }
    else
        e_enemy = this.enemy = NULL;
 
    e = findradius(this.origin, this.target_range);
 
    // Nothing to aim at?
    if (!e)
        return NULL;
 
    float f;
    for (; e; e = e.chain)
        if (e.takedamage)
        {
            f = turret_validate_target(this, e, this.target_select_flags);
            //dprint("F is: ", ftos(f), "\n");
            if (f > 0)
            {
                score = this.turret_score_target(this, e);
                if (score > m_score && score > 0)
                {
                    e_enemy = e;
                    m_score = score;
                }
            }
        }
 
    return e_enemy;
}

References enemy, entity(), NULL, origin, target_select_flags, target_validate_flags, and turret_validate_target().

Referenced by turret_tesla_firecheck(), and turret_think().

turret_validate_target()

float turret_validate_target	(	entity	e_turret,
		entity	e_target,
		float	validate_flags )

Evaluate a entity for target valitity based on validate_flags NOTE: the caller must check takedamage before calling this, to inline this check.

Definition at line 677 of file sv_turrets.qc.

{
    //if (!validate_flags & TFL_TARGETSELECT_NOBUILTIN)
    //  return -0.5;
 
    if (!e_target)
        return -2;
 
    if (e_target.owner == e_turret || e_target == e_turret.realowner) // Don't attack against owner
        return -0.5;
 
    if (!checkpvs(e_target.origin, e_turret))
        return -1;
    if (e_target.alpha != 0 && e_target.alpha <= 0.3)
        return -1;
 
    if (MUTATOR_CALLHOOK(TurretValidateTarget, e_turret, e_target, validate_flags))
        return M_ARGV(3, float);
 
    if (validate_flags & TFL_TARGETSELECT_NO)
        return -4;
 
    if (e_target.flags & FL_NOTARGET) // If only this was used more..
        return -5;
 
    if (GetResource(e_target, RES_HEALTH) <= 0) // Cant touch this
        return -6;
 
    // vehicle
    if (IS_VEHICLE(e_target)
    && (validate_flags & TFL_TARGETSELECT_VEHICLES) && !e_target.owner)
        return -7;
 
    if (IS_CLIENT(e_target)) // player
    {
        if (!(validate_flags & TFL_TARGETSELECT_PLAYERS))
            return -7;
        if (IS_DEAD(e_target))
            return -8;
    }
 
    // enemy turrets
    if ((validate_flags & TFL_TARGETSELECT_NOTURRETS)
    && e_target.owner.tur_head == e_target
    && DIFF_TEAM(e_target, e_turret)) // Dont break support units.
        return -9;
 
    // Missile
    if ((e_target.flags & FL_PROJECTILE)
    && !(validate_flags & TFL_TARGETSELECT_MISSILES))
        return -10;
 
    if ((validate_flags & TFL_TARGETSELECT_MISSILESONLY)
    && !(e_target.flags & FL_PROJECTILE))
        return -10.5;
 
    // Team check
    if (validate_flags & TFL_TARGETSELECT_TEAMCHECK)
    {
        if (validate_flags & TFL_TARGETSELECT_OWNTEAM)
        {
            if (DIFF_TEAM(e_target, e_turret))
                return -11;
            if (DIFF_TEAM(e_turret, e_target.owner))
                return -12;
            if (DIFF_TEAM(e_turret, e_target.aiment))
                return -12; // portals
        }
        else
        {
            if (SAME_TEAM(e_target, e_turret))
                return -13;
            if (SAME_TEAM(e_turret, e_target.owner))
                return -14;
            if (SAME_TEAM(e_turret, e_target.aiment))
                return -14; // portals
        }
    }
 
    // Range limits?
    tvt_dist = vlen(e_turret.origin - real_origin(e_target));
    if (validate_flags & TFL_TARGETSELECT_RANGELIMITS)
    {
        if (tvt_dist < e_turret.target_range_min)
            return -15;
        if (tvt_dist > e_turret.target_range)
            return -16;
    }
 
    // Can we even aim this thing?
    tvt_thadv = angleofs3(e_turret.tur_head.origin, e_turret.angles + e_turret.tur_head.angles, e_target.origin);
    tvt_tadv = shortangle_vxy(angleofs(e_turret, e_target), e_turret.angles);
    tvt_thadf = vlen(tvt_thadv);
 
    /*
    if ((validate_flags & TFL_TARGETSELECT_FOV)
    && e_turret.target_select_fov < tvt_thadf)
        return -21;
    */
 
    if (validate_flags & TFL_TARGETSELECT_ANGLELIMITS)
    {
        if (fabs(tvt_tadv.x) > e_turret.aim_maxpitch)
            return -17;
        if (fabs(tvt_tadv.y) > e_turret.aim_maxrot)
            return -18;
    }
 
    // Line of sight?
    if (validate_flags & TFL_TARGETSELECT_LOS)
    {
        vector v_tmp = real_origin(e_target) + 0.5 * (e_target.mins + e_target.maxs);
 
        traceline(e_turret.origin + '0 0 16', v_tmp, 0, e_turret);
        if (vdist(v_tmp - trace_endpos, >, e_turret.aim_firetolerance_dist))
            return -19;
    }
 
    if (e_target.classname == "grapplinghook")
        return -20;
    /*
    if (e_target.classname == "func_button")
        return -21;
    */
 
#ifdef TURRET_DEBUG_TARGETSELECT
    LOG_TRACE("Target:", e_target.netname, " is a valid target for ", e_turret.netname);
#endif
 
    return 1;
}

References angleofs, angleofs3(), checkpvs(), DIFF_TEAM, entity(), fabs(), FL_NOTARGET, FL_PROJECTILE, GetResource(), IS_CLIENT, IS_DEAD, IS_VEHICLE, LOG_TRACE, M_ARGV, MUTATOR_CALLHOOK, real_origin(), SAME_TEAM, shortangle_vxy(), TFL_TARGETSELECT_ANGLELIMITS, TFL_TARGETSELECT_LOS, TFL_TARGETSELECT_MISSILES, TFL_TARGETSELECT_MISSILESONLY, TFL_TARGETSELECT_NO, TFL_TARGETSELECT_NOTURRETS, TFL_TARGETSELECT_OWNTEAM, TFL_TARGETSELECT_PLAYERS, TFL_TARGETSELECT_RANGELIMITS, TFL_TARGETSELECT_TEAMCHECK, TFL_TARGETSELECT_VEHICLES, trace_endpos, tvt_dist, tvt_tadv, tvt_thadf, tvt_thadv, vdist, vector, and vlen().

Referenced by turret_firecheck(), turret_hk_addtarget(), turret_select_target(), turret_tesla_firecheck(), turret_think(), and walker_melee_do_dmg().

turrets_setframe()

void turrets_setframe	(	entity	this,
		float	_frame,
		float	client_only )

Definition at line 299 of file sv_turrets.qc.

{
    if ((client_only ? this.clientframe : this.frame) != _frame)
    {
        this.SendFlags |= TNSF_ANIM;
        this.anim_start_time = time;
    }
 
    if (client_only)
        this.clientframe = _frame;
    else
        this.frame = _frame;
 
}

References anim_start_time, clientframe, entity(), frame, SendFlags, time, and TNSF_ANIM.

Referenced by ewheel_move_enemy(), and walker_setnoanim().

Variable Documentation

ammo

float ammo

Definition at line 43 of file sv_turrets.qh.

Referenced by ammo_pickupevalfunc(), DrawAmmoItem(), GetAmmoConsumption(), REGISTER_BUFF(), turret_fire(), turret_firecheck(), turret_fusionreactor_firecheck(), turret_initialize(), turret_respawn(), turret_think(), W_Crylink_Attack(), W_Crylink_Attack2(), W_DecreaseAmmo(), W_Devastator_Attack(), W_Devastator_DoRemoteExplode(), W_Devastator_Explode(), W_Electro_Attack_Bolt(), W_Electro_Attack_Orb(), W_Hagar_Attack(), W_Hagar_Attack2(), W_Hagar_Attack2_Load(), W_HLAC_Attack(), W_HLAC_Attack2(), W_MineLayer_Attack(), W_Mortar_Attack(), W_Mortar_Attack2(), W_OverkillHeavyMachineGun_Attack_Auto(), W_OverkillMachineGun_Attack_Auto(), W_OverkillNex_Attack(), W_OverkillRocketPropelledChainsaw_Attack(), W_ReloadedAndReady(), W_Rifle_FireBullet(), W_Shotgun_Attack3_Frame1(), W_Shotgun_Attack3_Frame2(), W_Vaporizer_Attack(), W_Vortex_Attack(), and weapon_prepareattack_checkammo().

autocvar_g_turrets

bool autocvar_g_turrets

Definition at line 5 of file sv_turrets.qh.

Referenced by spawnfunc(), and turret_initialize().

autocvar_g_turrets_aimidle_delay

float autocvar_g_turrets_aimidle_delay

Definition at line 6 of file sv_turrets.qh.

Referenced by turret_think().

autocvar_g_turrets_nofire

bool autocvar_g_turrets_nofire

Definition at line 7 of file sv_turrets.qh.

Referenced by turret_fire().

autocvar_g_turrets_reloadcvars

bool autocvar_g_turrets_reloadcvars

Definition at line 8 of file sv_turrets.qh.

Referenced by turrets_manager_think().

autocvar_g_turrets_targetscan_maxdelay

float autocvar_g_turrets_targetscan_maxdelay

Definition at line 9 of file sv_turrets.qh.

Referenced by turret_tesla_firecheck(), and turret_think().

autocvar_g_turrets_targetscan_mindelay

float autocvar_g_turrets_targetscan_mindelay

Definition at line 10 of file sv_turrets.qh.

Referenced by turret_tesla_firecheck(), and turret_think().

g_turrets

IntrusiveList g_turrets

Definition at line 113 of file sv_turrets.qh.

Referenced by assault_roundstart_use(), STATIC_INIT(), turret_initialize(), turret_targettrigger_touch(), and turrets_manager_think().

idle_aim

vector idle_aim

Definition at line 44 of file sv_turrets.qh.

Referenced by turret_findtarget(), turret_initialize(), turret_respawn(), and turret_track().

pathcurrent

entity pathcurrent

Definition at line 86 of file sv_turrets.qh.

Referenced by ewheel_findtarget(), ewheel_move_path(), walker_findtarget(), and walker_move_path().

pathgoal

entity pathgoal

Definition at line 88 of file sv_turrets.qh.

Referenced by ewheel_findtarget(), ewheel_move_path(), walker_findtarget(), and walker_move_path().

target_select_time

float target_select_time

Definition at line 39 of file sv_turrets.qh.

Referenced by turret_tesla_firecheck(), and turret_think().

target_validate_time

float target_validate_time

Definition at line 40 of file sv_turrets.qh.

Referenced by turret_tesla_firecheck(), and turret_think().

TFL_TRACKTYPE_FLUIDINERTIA

const float TFL_TRACKTYPE_FLUIDINERTIA = 3

Definition at line 64 of file sv_turrets.qh.

Referenced by turret_track().

TFL_TRACKTYPE_FLUIDPRECISE

const float TFL_TRACKTYPE_FLUIDPRECISE = 2

Definition at line 63 of file sv_turrets.qh.

Referenced by turret_track().

TFL_TRACKTYPE_STEPMOTOR

const float TFL_TRACKTYPE_STEPMOTOR = 1

Definition at line 62 of file sv_turrets.qh.

Referenced by turret_initialize(), and turret_track().

tur_aimpos

vector tur_aimpos

Definition at line 31 of file sv_turrets.qh.

Referenced by turret_fire(), turret_think(), and turret_track().

tur_defend

entity tur_defend

Definition at line 29 of file sv_turrets.qh.

Referenced by turret_findtarget(), and turret_initialize().

tur_dist_aimpos

float tur_dist_aimpos

Definition at line 35 of file sv_turrets.qh.

Referenced by turret_firecheck().

tur_dist_enemy

float tur_dist_enemy

Definition at line 34 of file sv_turrets.qh.

Referenced by ewheel_move_enemy().

tur_dist_impact_to_aimpos

float tur_dist_impact_to_aimpos

Definition at line 36 of file sv_turrets.qh.

Referenced by turret_firecheck().

tur_head

entity tur_head

Definition at line 28 of file sv_turrets.qh.

Referenced by ewheel_draw(), ewheel_move_enemy(), NET_HANDLE(), racer_exit(), raptor_exit(), spiderbot_blowup(), spiderbot_rocket_do(), turret_changeteam(), turret_construct(), turret_damage(), turret_die(), turret_draw(), turret_findtarget(), turret_initialize(), turret_link(), turret_remove(), turret_respawn(), turret_send(), turret_tag_fire_update(), turret_track(), vehicle_initialize(), vehicle_use(), vehicles_painframe(), vehicles_reset_colors(), and walker_draw().

tur_impactent

entity tur_impactent

Definition at line 33 of file sv_turrets.qh.

Referenced by turret_firecheck().

tur_impacttime

float tur_impacttime

Definition at line 32 of file sv_turrets.qh.

Referenced by raptor_flare_think(), and turret_fire().

tur_shotdir_updated

vector tur_shotdir_updated

Definition at line 70 of file sv_turrets.qh.

tur_shotorg

vector tur_shotorg

Definition at line 30 of file sv_turrets.qh.

Referenced by turret_aim_generic(), turret_initialize(), turret_tag_fire_update(), turret_track(), walker_rocket_loop(), walker_rocket_loop2(), walker_rocket_loop3(), and walker_rocket_think().

turret_count

float turret_count

Definition at line 90 of file sv_turrets.qh.

Referenced by turret_initialize().

turret_scale_aim

float turret_scale_aim

Map time control aim speed.

Definition at line 55 of file sv_turrets.qh.

turret_scale_ammo

float turret_scale_ammo

Map time control ammo held and recharged.

Definition at line 53 of file sv_turrets.qh.

turret_scale_damage

float turret_scale_damage

Map time control over pain inflicted.

Definition at line 47 of file sv_turrets.qh.

turret_scale_health

float turret_scale_health

Map time control health.

Definition at line 57 of file sv_turrets.qh.

turret_scale_range

float turret_scale_range

Map time control targetting range.

Definition at line 49 of file sv_turrets.qh.

turret_scale_refire

float turret_scale_refire

Map time control refire.

Definition at line 51 of file sv_turrets.qh.

turret_scale_respawn

float turret_scale_respawn

Map time control respawn time.

Definition at line 59 of file sv_turrets.qh.

tvt_dist

float tvt_dist

Definition at line 111 of file sv_turrets.qh.

Referenced by turret_targetscore_generic(), turret_targetscore_support(), and turret_validate_target().

tvt_tadv

vector tvt_tadv

Definition at line 109 of file sv_turrets.qh.

Referenced by turret_validate_target().

tvt_thadf

float tvt_thadf

Definition at line 110 of file sv_turrets.qh.

Referenced by turret_targetscore_generic(), and turret_validate_target().

tvt_thadv

vector tvt_thadv

Definition at line 108 of file sv_turrets.qh.

Referenced by turret_validate_target().

volly_counter

float volly_counter

Definition at line 37 of file sv_turrets.qh.

Referenced by turret_fire(), turret_firecheck(), turret_respawn(), and turret_think().