triggers.qc File Reference

#include "triggers.qh"

Include dependency graph for triggers.qc:

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

Go to the source code of this file.

Functions
void	DelayThink (entity this)
void	generic_netlinked_legacy_use (entity this, entity actor, entity trigger)
void	generic_netlinked_reset (entity this)
void	generic_netlinked_setactive (entity this, int act)
void	generic_setactive (entity this, int act)
bool	isPushable (entity e)
void	SUB_UseTargets (entity this, entity actor, entity trigger)
void	SUB_UseTargets_Ex (entity this, entity actor, entity trigger, bool preventReuse, int skiptargets)
void	SUB_UseTargets_PreventReuse (entity this, entity actor, entity trigger)
void	SUB_UseTargets_SkipTargets (entity this, entity actor, entity trigger, int skiptargets)
	allow excluding certain .target* fields without needing to nullify them use BIT(1) through BIT(4)
void	trigger_common_write (entity this, bool withtarget)
void	trigger_link (entity this, bool(entity this, entity to, int sendflags) sendfunc)

Function Documentation

DelayThink()

void DelayThink

(

entity

this

)

Definition at line 37 of file triggers.qc.

{
    SUB_UseTargets (this, this.enemy, NULL);
    delete(this);
}

References enemy, entity(), NULL, and SUB_UseTargets().

Referenced by SUB_UseTargets_Ex().

generic_netlinked_legacy_use()

void generic_netlinked_legacy_use	(	entity	this,
		entity	actor,
		entity	trigger )

Definition at line 96 of file triggers.qc.

{
    //LOG_WARNF("Entity %s was (de)activated by a trigger, please update map to use relays", this.targetname);
    this.setactive(this, ACTIVE_TOGGLE);
}

References ACTIVE_TOGGLE, and entity().

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

generic_netlinked_reset()

void generic_netlinked_reset

(

entity

this

)

Definition at line 74 of file triggers.qc.

{
    if(this.targetname && this.targetname != "")
    {
        if(this.spawnflags & START_ENABLED)
        {
            this.active = ACTIVE_ACTIVE;
        }
        else
        {
            this.active = ACTIVE_NOT;
        }
    }
    else
    {
        this.active = ACTIVE_ACTIVE;
    }
 
    this.SendFlags |= SF_TRIGGER_UPDATE;
}

References active, ACTIVE_ACTIVE, ACTIVE_NOT, entity(), SendFlags, SF_TRIGGER_UPDATE, spawnflags, START_ENABLED, and targetname.

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

generic_netlinked_setactive()

void generic_netlinked_setactive	(	entity	this,
		int	act )

Definition at line 63 of file triggers.qc.

{
    int old_status = this.active;
    generic_setactive(this, act);
 
    if (this.active != old_status)
    {
        this.SendFlags |= SF_TRIGGER_UPDATE;
    }
}

References active, entity(), generic_setactive(), SendFlags, and SF_TRIGGER_UPDATE.

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

generic_setactive()

void generic_setactive	(	entity	this,
		int	act )

Definition at line 44 of file triggers.qc.

{
    if(act == ACTIVE_TOGGLE)
    {
        if(this.active == ACTIVE_ACTIVE)
        {
            this.active = ACTIVE_NOT;
        }
        else
        {
            this.active = ACTIVE_ACTIVE;
        }
    }
    else
    {
        this.active = act;
    }
}

References active, ACTIVE_ACTIVE, ACTIVE_NOT, ACTIVE_TOGGLE, and entity().

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

isPushable()

bool isPushable

(

entity

e

)

Definition at line 3 of file triggers.qc.

{
    if(e.pushable)
        return true;
#ifdef SVQC
    if(IS_VEHICLE(e))
        return false;
    if(e.iscreature)
        return true;
    if (ITEM_IS_LOOT(e))
    {
        return true;
    }
    switch(e.classname)
    {
        case "body":
            return true;
        case "bullet": // antilagged bullets can't hit this either
            return false;
    }
    if (e.projectiledeathtype)
        return true;
#endif
#ifdef CSQC
    if(e.flags & FL_PROJECTILE)
        return true;
    if(e.isplayermodel)
        return true;
#endif
    return false;
}

References entity(), FL_PROJECTILE, IS_VEHICLE, and ITEM_IS_LOOT.

Referenced by conveyor_think(), jumppad_push(), nade_entrap_touch(), trigger_impulse_touch_accel(), trigger_impulse_touch_directional(), and trigger_impulse_touch_radial().

SUB_UseTargets()

void SUB_UseTargets	(	entity	this,
		entity	actor,
		entity	trigger )

Definition at line 353 of file triggers.qc.

{ SUB_UseTargets_Ex(this, actor, trigger, false, 0); }

References entity(), and SUB_UseTargets_Ex().

Referenced by assault_objective_decrease_use(), assault_roundstart_use(), button_wait(), CheatCommand(), checkpoint_passed(), counter_use(), delay_delayeduse(), DelayThink(), dompoint_captured(), door_go_up(), door_rotating_go_up(), fd_secret_use(), flipflop_use(), func_breakable_destroy(), gamestart_use(), item_key_touch(), Item_Touch(), jumppad_push(), misc_laser_think(), monoflop_fixed_use(), monoflop_think(), monoflop_use(), Monster_Damage(), multi_trigger(), multivibrator_send(), multivibrator_toggle(), ons_ControlPoint_Icon_BuildThink(), ons_ControlPoint_Icon_Damage(), ons_ControlPoint_Icon_Think(), ons_ControlPoint_Reset(), PutPlayerInServer(), relay_use(), target_give_use(), target_teleport_use(), Teleport_Touch(), train_wait(), trigger_magicear_processmessage(), trigger_relay_if_use(), trigger_relay_teamcheck_use(), and trigger_secret_touch().

SUB_UseTargets_Ex()

void SUB_UseTargets_Ex	(	entity	this,
		entity	actor,
		entity	trigger,
		bool	preventReuse,
		int	skiptargets )

Definition at line 246 of file triggers.qc.

{
//
// check for a delay
//
    if (this.delay)
    {
        // create a temp object to fire at a later time
        entity t = new_pure(DelayedUse);
        t.nextthink = time + this.delay;
        setthink(t, DelayThink);
        t.enemy = actor;
        t.message = this.message;
        t.killtarget = this.killtarget;
        if(!(skiptargets & BIT(1))) t.target = this.target;
        if(!(skiptargets & BIT(2))) t.target2 = this.target2;
        if(!(skiptargets & BIT(3))) t.target3 = this.target3;
        if(!(skiptargets & BIT(4))) t.target4 = this.target4;
        t.antiwall_flag = this.antiwall_flag;
        return;
    }
 
//
// print the message
//
#ifdef SVQC
    if(this)
    if(IS_PLAYER(actor) && this.message != "")
    if(IS_REAL_CLIENT(actor))
    {
        centerprint(actor, this.message);
        if (this.noise == "")
            play2(actor, SND(TALK));
    }
 
//
// kill the killtargets
//
    string s = this.killtarget;
    if (s != "")
    {
        for(entity t = NULL; (t = find(t, targetname, s)); )
            delete(t);
    }
#endif
 
//
// fire targets
//
 
    if(this.target_random)
        RandomSelection_Init();
 
    .string tfield;
    for(int i = 0; i < 4; ++i)
    {
        if(skiptargets & BIT(i + 1))
            continue;
        switch(i)
        {
            default:
            case 0: tfield = target; break;
            case 1: tfield = target2; break;
            case 2: tfield = target3; break;
            case 3: tfield = target4; break;
        }
        if (this.(tfield) != "")
        {
            for(entity t = NULL; (t = find(t, targetname, this.(tfield))); )
            {
                if (t.loopdetector & 1) // t is already using its targets!
                {
                    #ifdef SVQC
                    if (!autocvar_sv_dedicated)
                        LOG_WARNF("MAP BUG: target field of %s \"%s\" loops back to %s \"%s\"\n", this.classname, this.targetname, t.classname, t.targetname);
                    #endif
                    this.(tfield) = string_null; // break loop to shallower point so map works as intended without spamming every time
                }
                else if(t != this && t.use && (t.sub_target_used != time || !preventReuse))
                {
                    if(this.target_random)
                    {
                        RandomSelection_AddEnt(t, 1, 0);
                    }
                    else
                    {
                        this.loopdetector |= 1;
                        t.use(t, actor, this);
                        this.loopdetector &= ~1;
                        if(preventReuse)
                            t.sub_target_used = time;
                    }
                }
            }
        }
    }
 
    if(this.target_random && RandomSelection_chosen_ent)
    {
        this.loopdetector |= 1;
        RandomSelection_chosen_ent.use(RandomSelection_chosen_ent, actor, this);
        this.loopdetector &= ~1;
        if(preventReuse)
            RandomSelection_chosen_ent.sub_target_used = time;
    }
}

References antiwall_flag, autocvar_sv_dedicated, BIT, centerprint(), classname, delay, DelayThink(), entity(), find(), IS_PLAYER, IS_REAL_CLIENT, killtarget, LOG_WARNF, loopdetector, message, new_pure, noise, NULL, play2(), RandomSelection_AddEnt, RandomSelection_chosen_ent, RandomSelection_Init(), setthink, SND, string_null, target, target2, target3, target4, target_random, targetname, and time.

Referenced by SUB_UseTargets(), SUB_UseTargets_PreventReuse(), and SUB_UseTargets_SkipTargets().

SUB_UseTargets_PreventReuse()

void SUB_UseTargets_PreventReuse	(	entity	this,
		entity	actor,
		entity	trigger )

Definition at line 354 of file triggers.qc.

{ SUB_UseTargets_Ex(this, actor, trigger, true, 0); }

References entity(), and SUB_UseTargets_Ex().

SUB_UseTargets_SkipTargets()

void SUB_UseTargets_SkipTargets	(	entity	this,
		entity	actor,
		entity	trigger,
		int	skiptargets )

allow excluding certain .target* fields without needing to nullify them use BIT(1) through BIT(4)

Definition at line 355 of file triggers.qc.

{ SUB_UseTargets_Ex(this, actor, trigger, false, skiptargets); }

References entity(), and SUB_UseTargets_Ex().

Referenced by WarpZone_Touch().

trigger_common_write()

void trigger_common_write	(	entity	this,
		bool	withtarget )

Definition at line 108 of file triggers.qc.

{
    int f = 0;
    if(this.warpzone_isboxy)
        BITSET_ASSIGN(f, 1);
    if(this.origin != '0 0 0')
        BITSET_ASSIGN(f, 4);
    if(this.movedir != '0 0 0')
        BITSET_ASSIGN(f, 8);
    if(this.angles != '0 0 0')
        BITSET_ASSIGN(f, 16);
    WriteByte(MSG_ENTITY, f);
 
    if(withtarget)
    {
        // probably some way to clean this up...
        int targbits = 0;
        if(this.target && this.target != "") targbits |= BIT(0);
        if(this.target2 && this.target2 != "") targbits |= BIT(1);
        if(this.target3 && this.target3 != "") targbits |= BIT(2);
        if(this.target4 && this.target4 != "") targbits |= BIT(3);
        if(this.targetname && this.targetname != "") targbits |= BIT(4);
        if(this.killtarget && this.killtarget != "") targbits |= BIT(5);
 
        WriteByte(MSG_ENTITY, targbits);
 
        if(targbits & BIT(0))
            WriteString(MSG_ENTITY, this.target);
        if(targbits & BIT(1))
            WriteString(MSG_ENTITY, this.target2);
        if(targbits & BIT(2))
            WriteString(MSG_ENTITY, this.target3);
        if(targbits & BIT(3))
            WriteString(MSG_ENTITY, this.target4);
        if(targbits & BIT(4))
            WriteString(MSG_ENTITY, this.targetname);
        if(targbits & BIT(5))
            WriteString(MSG_ENTITY, this.killtarget);
    }
 
    if(f & 4)
        WriteVector(MSG_ENTITY, this.origin);
 
    if(f & 8)
        WriteVector(MSG_ENTITY, this.movedir);
 
    if(f & 16)
        WriteVector(MSG_ENTITY, this.angles);
 
    WriteShort(MSG_ENTITY, this.modelindex);
    WriteVector(MSG_ENTITY, this.mins);
    WriteVector(MSG_ENTITY, this.maxs);
    WriteByte(MSG_ENTITY, bound(1, this.scale * 16, 255));
}

References angles, BIT, BITSET_ASSIGN, bound(), entity(), killtarget, maxs, mins, modelindex, movedir, MSG_ENTITY, origin, scale, target, target2, target3, target4, targetname, warpzone_isboxy, WriteByte(), WriteShort(), and WriteString().

Referenced by door_send(), func_ladder_send(), plat_send(), train_send(), trigger_impulse_send(), trigger_keylock_send(), trigger_push_send(), trigger_push_velocity_send(), and trigger_teleport_send().

trigger_link()

void trigger_link	(	entity	this,
		bool(entity this, entity to, int sendflags)	sendfunc )

Definition at line 102 of file triggers.qc.

{
    setSendEntity(this, sendfunc);
    this.SendFlags = 0xFFFFFF;
}

References entity(), SendFlags, and setSendEntity.

Referenced by func_ladder_link(), trigger_impulse_link(), trigger_push_link(), and trigger_push_velocity_link().