laser.qc File Reference

#include "laser.qh"
#include <lib/csqcmodel/interpolate.qh>
#include <lib/csqcmodel/cl_model.qh>

Include dependency graph for laser.qc:

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

Go to the source code of this file.

Functions
bool	laser_SendEntity (entity this, entity to, float sendflags)
void	laser_setactive (entity this, int act)
void	laser_use (entity this, entity actor, entity trigger)
void	misc_laser_aim (entity this)
void	misc_laser_init (entity this)
void	misc_laser_think (entity this)
	spawnfunc (misc_laser)

Variables
entity	pusher

Function Documentation

laser_SendEntity()

bool laser_SendEntity	(	entity	this,
		entity	to,
		float	sendflags )

Definition at line 123 of file laser.qc.

{
    WriteHeader(MSG_ENTITY, ENT_CLIENT_LASER);
    sendflags = sendflags & 0x0F; // use that bit to indicate finite length laser
    if(this.spawnflags & LASER_FINITE)
        sendflags |= SF_LASER_FINITE;
    if(this.alpha)
        sendflags |= SF_LASER_ALPHA;
    if(this.scale != 1 || this.modelscale != 1)
        sendflags |= SF_LASER_SCALE;
    if(this.spawnflags & LASER_NOTRACE)
        sendflags |= SF_LASER_NOTRACE;
    WriteByte(MSG_ENTITY, sendflags);
    if(sendflags & SF_LASER_UPDATE_ORIGIN)
    {
        WriteVector(MSG_ENTITY, this.origin);
    }
    if(sendflags & SF_LASER_UPDATE_EFFECT)
    {
        WriteByte(MSG_ENTITY, this.beam_color.x * 255.0);
        WriteByte(MSG_ENTITY, this.beam_color.y * 255.0);
        WriteByte(MSG_ENTITY, this.beam_color.z * 255.0);
        if(sendflags & SF_LASER_ALPHA)
            WriteByte(MSG_ENTITY, this.alpha * 255.0);
        if(sendflags & SF_LASER_SCALE)
        {
            WriteByte(MSG_ENTITY, bound(0, this.scale * 16.0, 255));
            WriteByte(MSG_ENTITY, bound(0, this.modelscale * 16.0, 255));
        }
        if((sendflags & SF_LASER_FINITE) || !(sendflags & SF_LASER_NOTRACE)) // effect doesn't need sending if the laser is infinite and has collision testing turned off
            WriteShort(MSG_ENTITY, this.cnt);
    }
    if(sendflags & SF_LASER_UPDATE_TARGET)
    {
        if(sendflags & SF_LASER_FINITE)
        {
            WriteVector(MSG_ENTITY, this.enemy.origin);
        }
        else
        {
            WriteAngleVector2D(MSG_ENTITY, this.mangle);
        }
    }
    if(sendflags & SF_LASER_UPDATE_ACTIVE)
        WriteByte(MSG_ENTITY, this.active);
    return true;
}

References active, alpha, beam_color, bound(), cnt, enemy, entity(), LASER_FINITE, LASER_NOTRACE, mangle, modelscale, MSG_ENTITY, origin, scale, SF_LASER_ALPHA, SF_LASER_FINITE, SF_LASER_NOTRACE, SF_LASER_SCALE, SF_LASER_UPDATE_ACTIVE, SF_LASER_UPDATE_EFFECT, SF_LASER_UPDATE_ORIGIN, SF_LASER_UPDATE_TARGET, spawnflags, WriteByte(), WriteHeader, and WriteShort().

Referenced by spawnfunc().

laser_setactive()

void laser_setactive	(	entity	this,
		int	act )

Definition at line 184 of file laser.qc.

{
    int old_status = this.active;
    if(act == ACTIVE_TOGGLE)
    {
        if(this.active == ACTIVE_ACTIVE)
        {
            this.active = ACTIVE_NOT;
        }
        else
        {
            this.active = ACTIVE_ACTIVE;
        }
    }
    else
    {
        this.active = act;
    }
 
    if (this.active != old_status)
    {
        this.SendFlags |= SF_LASER_UPDATE_ACTIVE;
        misc_laser_aim(this);
    }
}

References active, ACTIVE_ACTIVE, ACTIVE_NOT, ACTIVE_TOGGLE, entity(), misc_laser_aim(), SendFlags, and SF_LASER_UPDATE_ACTIVE.

Referenced by spawnfunc().

laser_use()

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

Definition at line 210 of file laser.qc.

{
    this.setactive(this, ACTIVE_TOGGLE);
}

References ACTIVE_TOGGLE, and entity().

Referenced by spawnfunc().

misc_laser_aim()

void misc_laser_aim

(

entity

this

)

Definition at line 12 of file laser.qc.

{
    vector a;
    if(this.enemy)
    {
        if(this.spawnflags & LASER_FINITE)
        {
            if(this.enemy.origin != this.mangle)
            {
                this.mangle = this.enemy.origin;
                this.SendFlags |= SF_LASER_UPDATE_TARGET;
            }
        }
        else
        {
            a = vectoangles(this.enemy.origin - this.origin);
            a_x = -a_x;
            if(a != this.mangle)
            {
                this.mangle = a;
                this.SendFlags |= SF_LASER_UPDATE_TARGET;
            }
        }
    }
    else
    {
        if(this.angles != this.mangle)
        {
            this.mangle = this.angles;
            this.SendFlags |= SF_LASER_UPDATE_TARGET;
        }
    }
    if(this.origin != this.oldorigin)
    {
        this.SendFlags |= SF_LASER_UPDATE_ORIGIN;
        this.oldorigin = this.origin;
    }
}

References angles, enemy, entity(), LASER_FINITE, mangle, oldorigin, origin, SendFlags, SF_LASER_UPDATE_ORIGIN, SF_LASER_UPDATE_TARGET, spawnflags, vectoangles(), and vector.

Referenced by laser_setactive(), and misc_laser_think().

misc_laser_init()

void misc_laser_init

(

entity

this

)

Definition at line 51 of file laser.qc.

{
    if(this.target != "")
        this.enemy = find(NULL, targetname, this.target);
}

References enemy, entity(), find(), NULL, target, and targetname.

Referenced by spawnfunc().

misc_laser_think()

void misc_laser_think

(

entity

this

)

Definition at line 58 of file laser.qc.

{
    vector o;
    entity hitent;
    vector hitloc;
 
    this.nextthink = time;
 
    if(this.active == ACTIVE_NOT)
        return;
 
    misc_laser_aim(this);
 
    if(this.enemy)
    {
        o = this.enemy.origin;
        if (!(this.spawnflags & LASER_FINITE))
            o = this.origin + normalize(o - this.origin) * LASER_BEAM_MAXLENGTH;
    }
    else
    {
        makevectors(this.mangle);
        o = this.origin + v_forward * LASER_BEAM_MAXLENGTH;
    }
 
    if(this.dmg || this.enemy.target != "")
    {
        traceline(this.origin, o, MOVE_NORMAL, this);
    }
    hitent = trace_ent;
    hitloc = trace_endpos;
 
    if(this.enemy.target != "") // DETECTOR laser
    {
        if(trace_ent.iscreature)
        {
            this.pusher = hitent;
            if(!this.count)
            {
                this.count = 1;
 
                SUB_UseTargets(this.enemy, this.enemy.pusher, NULL);
            }
        }
        else
        {
            if(this.count)
            {
                this.count = 0;
 
                SUB_UseTargets(this.enemy, this.enemy.pusher, NULL);
            }
        }
    }
 
    if(this.dmg)
    {
        if(this.team)
            if(((this.spawnflags & LASER_INVERT_TEAM) == 0) == (this.team != hitent.team))
                return;
        if(hitent.takedamage)
            Damage(hitent, this, this, ((this.dmg < 0) ? 100000 : (this.dmg * frametime)), DEATH_HURTTRIGGER.m_id, DMG_NOWEP, hitloc, '0 0 0');
    }
}

References active, ACTIVE_NOT, count, Damage(), dmg, DMG_NOWEP, enemy, entity(), frametime, LASER_BEAM_MAXLENGTH, LASER_FINITE, LASER_INVERT_TEAM, makevectors, mangle, misc_laser_aim(), MOVE_NORMAL, nextthink, normalize(), NULL, origin, pusher, spawnflags, SUB_UseTargets(), team, time, trace_endpos, trace_ent, v_forward, and vector.

Referenced by spawnfunc().

spawnfunc()

spawnfunc

(

misc_laser

)

Definition at line 215 of file laser.qc.

{
    if(this.mdl)
    {
        if(this.mdl == "none")
            this.cnt = -1;
        else
        {
            this.cnt = _particleeffectnum(this.mdl);
            if(this.cnt < 0 && this.dmg)
                this.cnt = particleeffectnum(EFFECT_LASER_DEADLY);
        }
    }
    else if(!this.cnt)
    {
        if(this.dmg)
            this.cnt = particleeffectnum(EFFECT_LASER_DEADLY);
        else
            this.cnt = -1;
    }
    if(this.cnt < 0)
        this.cnt = -1;
 
    if(!this.beam_color && this.colormod)
    {
        LOG_WARN("misc_laser uses legacy field 'colormod', please use 'beam_color' instead");
        this.beam_color = this.colormod;
    }
 
    if(this.beam_color == '0 0 0')
    {
        if(!this.alpha)
            this.beam_color = '1 0 0';
    }
 
    if(this.message == "")
    {
        this.message = "saw the light";
    }
    if (this.message2 == "")
    {
        this.message2 = "was pushed into a laser by";
    }
    if(!this.scale)
    {
        this.scale = 1;
    }
    if(!this.modelscale)
    {
        this.modelscale = 1;
    }
    else if(this.modelscale < 0)
    {
        this.modelscale = 0;
    }
    setthink(this, misc_laser_think);
    this.nextthink = time;
    InitializeEntity(this, misc_laser_init, INITPRIO_FINDTARGET);
 
    this.mangle = this.angles;
 
    Net_LinkEntity(this, false, 0, laser_SendEntity);
 
    this.setactive = laser_setactive;
 
    if(this.targetname && this.targetname != "")
    {
        // backwards compatibility
        this.use = laser_use;
    }
 
    this.reset = generic_netlinked_reset;
    this.reset(this);
}

References alpha, angles, beam_color, cnt, colormod, dmg, generic_netlinked_reset(), InitializeEntity(), INITPRIO_FINDTARGET, laser_SendEntity(), laser_setactive(), laser_use(), LOG_WARN, mangle, mdl, message, message2, misc_laser_init(), misc_laser_think(), modelscale, Net_LinkEntity(), nextthink, particleeffectnum, scale, setthink, targetname, time, and use.

Variable Documentation

pusher

entity pusher

Definition at line 57 of file laser.qc.

Referenced by _GlobalSound(), football_touch(), InitBall(), misc_laser_think(), and PlayerDamage().