subs.qc File Reference

#include "subs.qh"

Include dependency graph for subs.qc:

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

Go to the source code of this file.

Functions
void	ApplyMinMaxScaleAngles (entity e)
bool	InitMovingBrushTrigger (entity this)
void	InitSolidBSPTrigger (entity this)
void	InitTrigger (entity this)
bool	LOD_customize (entity this, entity client)
void	LOD_uncustomize (entity this)
void	LODmodel_attach (entity this)
void	SetBrushEntityModel (entity this, bool with_lod)
void	SetMovedir (entity this)
	spawnfunc (info_null)
void	SUB_CalcAngleMove (entity this, vector destangle, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcAngleMoveDone (entity this)
void	SUB_CalcAngleMoveEnt (entity ent, vector destangle, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove (entity this, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove_Bezier (entity this, vector tcontrol, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove_controller_setbezier (entity controller, vector org, vector control, vector destin)
void	SUB_CalcMove_controller_setlinear (entity controller, vector org, vector destin)
void	SUB_CalcMove_controller_think (entity this)
void	SUB_CalcMoveDone (entity this)
void	SUB_CalcMoveEnt (entity ent, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMovePause (entity this)
void	SUB_Friction (entity this)
void	SUB_NullThink (entity this)
void	SUB_SetFade (entity ent, float vanish_time, float fading_time)
void	SUB_SetFade_Think (entity this)
void	SUB_VanishOrRemove (entity ent)

Variables
float	friction
float	platmovetype_turn

Function Documentation

ApplyMinMaxScaleAngles()

void ApplyMinMaxScaleAngles

(

entity

e

)

Definition at line 393 of file subs.qc.

{
    if(e.angles.x != 0 || e.angles.z != 0 || e.avelocity.x != 0 || e.avelocity.z != 0) // "weird" rotation
    {
        e.maxs = '1 1 1' * vlen(
            '1 0 0' * max(-e.mins.x, e.maxs.x) +
            '0 1 0' * max(-e.mins.y, e.maxs.y) +
            '0 0 1' * max(-e.mins.z, e.maxs.z)
        );
        e.mins = -e.maxs;
    }
    else if(e.angles.y != 0 || e.avelocity.y != 0) // yaw only is a bit better
    {
        e.maxs_x = vlen(
            '1 0 0' * max(-e.mins.x, e.maxs.x) +
            '0 1 0' * max(-e.mins.y, e.maxs.y)
        );
        e.maxs_y = e.maxs.x;
        e.mins_x = -e.maxs.x;
        e.mins_y = -e.maxs.x;
    }
    if(e.scale)
        setsize(e, RoundPerfectVector(e.mins * e.scale), RoundPerfectVector(e.maxs * e.scale));
    else
        setsize(e, e.mins, e.maxs);
}

References entity(), max(), RoundPerfectVector(), and vlen().

Referenced by func_breakable_look_destroyed(), func_breakable_look_restore(), and SetBrushEntityModel().

InitMovingBrushTrigger()

bool InitMovingBrushTrigger

(

entity

this

)

Definition at line 577 of file subs.qc.

{
// trigger angles are used for one-way touches.  An angle of 0 is assumed
// to mean no restrictions, so use a yaw of 360 instead.
    this.solid = SOLID_BSP;
    SetBrushEntityModel(this, true);
    set_movetype(this, MOVETYPE_PUSH);
    if(this.modelindex == 0)
    {
        objerror(this, "InitMovingBrushTrigger: no brushes found!");
        return false;
    }
    return true;
}

References entity(), modelindex, MOVETYPE_PUSH, objerror, set_movetype(), SetBrushEntityModel(), solid, and SOLID_BSP.

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

InitSolidBSPTrigger()

void InitSolidBSPTrigger

(

entity

this

)

Definition at line 565 of file subs.qc.

{
// trigger angles are used for one-way touches.  An angle of 0 is assumed
// to mean no restrictions, so use a yaw of 360 instead.
    SetMovedir(this);
    this.solid = SOLID_BSP;
    SetBrushEntityModel(this, false);
    set_movetype(this, MOVETYPE_NONE); // why was this PUSH? -div0
//  this.modelindex = 0;
    this.model = "";
}

References entity(), model, MOVETYPE_NONE, set_movetype(), SetBrushEntityModel(), SetMovedir(), solid, and SOLID_BSP.

InitTrigger()

void InitTrigger

(

entity

this

)

Definition at line 553 of file subs.qc.

{
// trigger angles are used for one-way touches.  An angle of 0 is assumed
// to mean no restrictions, so use a yaw of 360 instead.
    SetMovedir(this);
    this.solid = SOLID_TRIGGER;
    SetBrushEntityModel(this, false);
    set_movetype(this, MOVETYPE_NONE);
    this.modelindex = 0;
    this.model = "";
}

References entity(), model, modelindex, MOVETYPE_NONE, set_movetype(), SetBrushEntityModel(), SetMovedir(), solid, and SOLID_TRIGGER.

Referenced by spawnfunc().

LOD_customize()

bool LOD_customize	(	entity	this,
		entity	client )

Definition at line 443 of file subs.qc.

{
    if(autocvar_loddebug)
    {
        int d = autocvar_loddebug;
        if(d == 1)
            this.modelindex = this.lodmodelindex0;
        else if(d == 2 || !this.lodmodelindex2)
            this.modelindex = this.lodmodelindex1;
        else // if(d == 3)
            this.modelindex = this.lodmodelindex2;
        return true;
    }
 
    // TODO csqc network this so it only gets sent once
    vector near_point = NearestPointOnBox(this, client.origin);
    if(vdist(near_point - client.origin, <, this.loddistance1))
        this.modelindex = this.lodmodelindex0;
    else if(!this.lodmodelindex2 || vdist(near_point - client.origin, <, this.loddistance2))
        this.modelindex = this.lodmodelindex1;
    else
        this.modelindex = this.lodmodelindex2;
 
    return true;
}

References autocvar_loddebug, entity(), lodmodelindex0, lodmodelindex1, lodmodelindex2, modelindex, NearestPointOnBox(), vdist, and vector.

Referenced by LODmodel_attach().

LOD_uncustomize()

void LOD_uncustomize

(

entity

this

)

Definition at line 469 of file subs.qc.

{
    this.modelindex = this.lodmodelindex0;
}

References entity(), lodmodelindex0, and modelindex.

Referenced by LODmodel_attach().

LODmodel_attach()

void LODmodel_attach

(

entity

this

)

Definition at line 474 of file subs.qc.

{
    entity e;
 
    if(!this.loddistance1)
        this.loddistance1 = 1000;
    if(!this.loddistance2)
        this.loddistance2 = 2000;
    this.lodmodelindex0 = this.modelindex;
 
    if(this.lodtarget1 != "")
    {
        e = find(NULL, targetname, this.lodtarget1);
        if(e)
        {
            this.lodmodel1 = e.model;
            delete(e);
        }
    }
    if(this.lodtarget2 != "")
    {
        e = find(NULL, targetname, this.lodtarget2);
        if(e)
        {
            this.lodmodel2 = e.model;
            delete(e);
        }
    }
 
    if(autocvar_loddebug < 0)
    {
        this.lodmodel1 = this.lodmodel2 = ""; // don't even initialize
    }
 
    if(this.lodmodel1 != "" && fexists(this.lodmodel1))
    {
        vector mi, ma;
        mi = this.mins;
        ma = this.maxs;
 
        precache_model(this.lodmodel1);
        _setmodel(this, this.lodmodel1);
        this.lodmodelindex1 = this.modelindex;
 
        if(this.lodmodel2 != "" && fexists(this.lodmodel2))
        {
            precache_model(this.lodmodel2);
            _setmodel(this, this.lodmodel2);
            this.lodmodelindex2 = this.modelindex;
        }
 
        this.modelindex = this.lodmodelindex0;
        setsize(this, mi, ma);
    }
 
    if(this.lodmodelindex1)
        if (!getSendEntity(this))
            SetCustomizer(this, LOD_customize, LOD_uncustomize);
}

References autocvar_loddebug, entity(), fexists(), find(), getSendEntity, LOD_customize(), LOD_uncustomize(), loddistance1, loddistance2, lodmodel1, lodmodel2, lodmodelindex0, lodmodelindex1, lodmodelindex2, lodtarget1, lodtarget2, maxs, mins, modelindex, NULL, SetCustomizer(), targetname, and vector.

Referenced by SetBrushEntityModel().

SetBrushEntityModel()

void SetBrushEntityModel	(	entity	this,
		bool	with_lod )

Definition at line 420 of file subs.qc.

{
    // Ensure .solid is set correctly before calling this (for area grid linking/unlinking)
 
    if(this.model != "")
    {
        precache_model(this.model);
        if(this.mins != '0 0 0' || this.maxs != '0 0 0')
        {
            vector mi = this.mins;
            vector ma = this.maxs;
            _setmodel(this, this.model); // no precision needed
            setsize(this, mi, ma);
        }
        else
            _setmodel(this, this.model); // no precision needed
        if(with_lod)
            InitializeEntity(this, LODmodel_attach, INITPRIO_FINDTARGET);
    }
    setorigin(this, this.origin);
    ApplyMinMaxScaleAngles(this);
}

References ApplyMinMaxScaleAngles(), entity(), InitializeEntity(), INITPRIO_FINDTARGET, LODmodel_attach(), maxs, mins, model, origin, and vector.

Referenced by func_breakable_setup(), g_clientmodel_init(), g_model_init(), InitMovingBrushTrigger(), InitSolidBSPTrigger(), InitTrigger(), spawnfunc(), and spawnfunc().

SetMovedir()

void SetMovedir

(

entity

this

)

Definition at line 540 of file subs.qc.

{
    if(this.movedir != '0 0 0')
        this.movedir = normalize(this.movedir);
    else
    {
        makevectors(this.angles);
        this.movedir = v_forward;
    }
 
    this.angles = '0 0 0';
}

References angles, entity(), makevectors, movedir, normalize(), and v_forward.

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

spawnfunc()

spawnfunc

(

info_null

)

Definition at line 9 of file subs.qc.

{
    delete(this);
    // if anything breaks, tell the mapper to fix their map! info_null is meant to remove itself immediately.
}

SUB_CalcAngleMove()

void SUB_CalcAngleMove	(	entity	this,
		vector	destangle,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func )

Definition at line 347 of file subs.qc.

{
    if (!tspeed)
        objerror (this, "No speed is defined!");
 
    // take the shortest distance for the angles
    this.angles_x -= 360 * floor((this.angles_x - destangle_x) / 360 + 0.5);
    this.angles_y -= 360 * floor((this.angles_y - destangle_y) / 360 + 0.5);
    this.angles_z -= 360 * floor((this.angles_z - destangle_z) / 360 + 0.5);
    vector delta = destangle - this.angles;
    float traveltime;
 
    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
        case TSPEED_END:
        case TSPEED_LINEAR:
            traveltime = vlen (delta) / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }
 
    this.think1 = func;
    this.finalangle = destangle;
    setthink(this, SUB_CalcAngleMoveDone);
 
    if (traveltime < 0.1)
    {
        this.avelocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }
 
    this.avelocity = delta * (1 / traveltime);
    this.nextthink = this.ltime + traveltime;
}

References angles, angles_y, avelocity, entity(), finalangle, floor(), ltime, nextthink, objerror, setthink, SUB_CalcAngleMoveDone(), TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, vector, and vlen().

Referenced by door_rotating_go_down(), door_rotating_go_up(), SUB_CalcAngleMoveEnt(), and train_wait().

SUB_CalcAngleMoveDone()

void SUB_CalcAngleMoveDone

(

entity

this

)

Definition at line 336 of file subs.qc.

{
    // After rotating, set angle to exact final angle
    this.angles = this.finalangle;
    this.avelocity = '0 0 0';
    this.nextthink = -1;
    if (this.think1 && this.think1 != SUB_CalcAngleMoveDone) // avoid endless loops
        this.think1 (this);
}

References angles, avelocity, entity(), finalangle, nextthink, and SUB_CalcAngleMoveDone().

Referenced by SUB_CalcAngleMove(), and SUB_CalcAngleMoveDone().

SUB_CalcAngleMoveEnt()

void SUB_CalcAngleMoveEnt	(	entity	ent,
		vector	destangle,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func )

Definition at line 387 of file subs.qc.

{
    SUB_CalcAngleMove (ent, destangle, tspeedtype, tspeed, func);
}

References entity(), SUB_CalcAngleMove(), and vector.

SUB_CalcMove()

void SUB_CalcMove	(	entity	this,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func )

Definition at line 267 of file subs.qc.

{
    vector    delta;
    float   traveltime;
 
    if (!tspeed)
        objerror (this, "No speed is defined!");
 
    this.think1 = func;
    this.finaldest = tdest;
    setthink(this, SUB_CalcMoveDone);
 
    if (tdest == this.origin)
    {
        this.velocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }
 
    delta = tdest - this.origin;
 
    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
        case TSPEED_END:
        case TSPEED_LINEAR:
            traveltime = vlen (delta) / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }
 
    // Q3 implements this fallback for all movers at the end of its InitMover()
    // If .speed is negative this applies, instead of the mover-specific default speed.
    if (traveltime <= 0)
        traveltime = 0.001;
 
    // Very short animations don't really show off the effect
    // of controlled animation, so let's just use linear movement.
    // Alternatively entities can choose to specify non-controlled movement.
    // The only currently implemented alternative movement is linear (value 1)
    if (traveltime < 0.15 || (this.platmovetype_start == 1 && this.platmovetype_end == 1)) // is this correct?
    {
        this.velocity = delta * (1/traveltime); // QuakeC doesn't allow vector/float division
        this.nextthink = this.ltime + traveltime;
        return;
    }
 
    // now just run like a bezier curve...
    SUB_CalcMove_Bezier(this, (this.origin + tdest) * 0.5, tdest, tspeedtype, tspeed, func);
}

References entity(), finaldest, ltime, nextthink, objerror, origin, platmovetype_end, platmovetype_start, setthink, SUB_CalcMove_Bezier(), SUB_CalcMoveDone(), TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, vector, velocity, and vlen().

Referenced by button_fire(), button_return(), door_go_down(), door_go_up(), fd_secret_move2(), fd_secret_move4(), fd_secret_move6(), fd_secret_use(), plat_go_down(), plat_go_up(), SUB_CalcMoveEnt(), and train_next().

SUB_CalcMove_Bezier()

void SUB_CalcMove_Bezier	(	entity	this,
		vector	tcontrol,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func )

Definition at line 204 of file subs.qc.

{
    float   traveltime;
    entity controller;
 
    if (!tspeed)
        objerror (this, "No speed is defined!");
 
    this.think1 = func;
    this.finaldest = tdest;
    setthink(this, SUB_CalcMoveDone);
 
    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
            traveltime = 2 * vlen(tcontrol - this.origin) / tspeed;
            break;
        case TSPEED_END:
            traveltime = 2 * vlen(tcontrol - tdest)       / tspeed;
            break;
        case TSPEED_LINEAR:
            traveltime = vlen(tdest - this.origin)        / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }
 
    if (traveltime < 0.1) // useless anim
    {
        this.velocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }
 
    // delete the previous controller, otherwise changing movement midway is glitchy
    if (this.move_controller != NULL)
    {
        delete(this.move_controller);
    }
    controller = new_pure(SUB_CalcMove_controller);
    set_movetype(controller, MOVETYPE_NONE); // mark the entity as physics driven so that thinking is handled by QC
    controller.owner = this;
    this.move_controller = controller;
    controller.platmovetype = this.platmovetype;
    controller.platmovetype_start = this.platmovetype_start;
    controller.platmovetype_end = this.platmovetype_end;
    SUB_CalcMove_controller_setbezier(controller, this.origin, tcontrol, tdest);
    controller.finaldest = (tdest + '0 0 0.125'); // where do we want to end? Offset to overshoot a bit.
    controller.animstate_starttime = time;
    controller.animstate_endtime = time + traveltime;
    setthink(controller, SUB_CalcMove_controller_think);
    controller.think1 = getthink(this);
 
    // the thinking is now done by the controller
    setthink(this, SUB_NullThink); // for PushMove
    this.nextthink = this.ltime + traveltime;
 
    // invoke controller
    getthink(controller)(controller);
}

References entity(), finaldest, getthink, ltime, move_controller, MOVETYPE_NONE, new_pure, nextthink, NULL, objerror, origin, platmovetype, platmovetype_end, platmovetype_start, set_movetype(), setthink, SUB_CalcMove_controller_setbezier(), SUB_CalcMove_controller_think(), SUB_CalcMoveDone(), SUB_NullThink(), time, TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, vector, velocity, and vlen().

Referenced by SUB_CalcMove(), and train_next().

SUB_CalcMove_controller_setbezier()

void SUB_CalcMove_controller_setbezier	(	entity	controller,
		vector	org,
		vector	control,
		vector	destin )

Definition at line 174 of file subs.qc.

{
    // 0 * (1-t) * (1-t) + 2 * control * t * (1-t) + destin * t * t
    // 2 * control * t - 2 * control * t * t + destin * t * t
    // 2 * control * t + (destin - 2 * control) * t * t
 
    //setorigin(controller, org); // don't link to the world
    controller.origin = org;
    control -= org;
    destin -= org;
 
    controller.destvec = 2 * control; // control point
    controller.destvec2 = destin - 2 * control; // quadratic part required to reach end point
    // also: initial d/dphasepos origin = 2 * control, final speed = 2 * (destin - control)
}

References entity(), org, and vector.

Referenced by SUB_CalcMove_Bezier().

SUB_CalcMove_controller_setlinear()

void SUB_CalcMove_controller_setlinear	(	entity	controller,
		vector	org,
		vector	destin )

Definition at line 190 of file subs.qc.

{
    // 0 * (1-t) * (1-t) + 2 * control * t * (1-t) + destin * t * t
    // 2 * control * t - 2 * control * t * t + destin * t * t
    // 2 * control * t + (destin - 2 * control) * t * t
 
    //setorigin(controller, org); // don't link to the world
    controller.origin = org;
    destin -= org;
 
    controller.destvec = destin; // end point
    controller.destvec2 = '0 0 0';
}

References entity(), org, and vector.

SUB_CalcMove_controller_think()

void SUB_CalcMove_controller_think

(

entity

this

)

Definition at line 114 of file subs.qc.

{
    float traveltime;
    float phasepos;
    float nexttick;
    vector delta;
    vector delta2;
    vector veloc;
    vector angloc;
    vector nextpos;
    delta = this.destvec;
    delta2 = this.destvec2;
    if(time < this.animstate_endtime)
    {
        nexttick = time + PHYS_INPUT_FRAMETIME;
 
        traveltime = this.animstate_endtime - this.animstate_starttime;
        phasepos = (nexttick - this.animstate_starttime) / traveltime; // range: [0, 1]
        phasepos = cubic_speedfunc(this.platmovetype_start, this.platmovetype_end, phasepos);
        nextpos = this.origin + (delta * phasepos) + (delta2 * phasepos * phasepos);
        // derivative: delta + 2 * delta2 * phasepos (e.g. for angle positioning)
 
        if(this.owner.platmovetype_turn)
        {
            vector destangle;
            destangle = delta + 2 * delta2 * phasepos;
            destangle = vectoangles(destangle);
            destangle_x = -destangle_x; // flip up / down orientation
 
            // take the shortest distance for the angles
            vector v = this.owner.angles;
            v.x -= 360 * floor((v.x - destangle_x) / 360 + 0.5);
            v.y -= 360 * floor((v.y - destangle_y) / 360 + 0.5);
            v.z -= 360 * floor((v.z - destangle_z) / 360 + 0.5);
            this.owner.angles = v;
            angloc = destangle - this.owner.angles;
            angloc = angloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame
            this.owner.avelocity = angloc;
        }
        if(nexttick < this.animstate_endtime)
            veloc = nextpos - this.owner.origin;
        else
            veloc = this.finaldest - this.owner.origin;
        veloc = veloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame
 
        this.owner.velocity = veloc;
        this.nextthink = nexttick;
    }
    else
    {
        // derivative: delta + 2 * delta2 (e.g. for angle positioning)
        entity own = this.owner;
        setthink(own, this.think1);
        // set the owner's reference to this entity to NULL
        own.move_controller = NULL;
        delete(this);
        getthink(own)(own);
    }
}

References animstate_endtime, animstate_starttime, cubic_speedfunc(), destvec, destvec2, entity(), finaldest, floor(), getthink, nextthink, NULL, origin, owner, PHYS_INPUT_FRAMETIME, platmovetype_end, platmovetype_start, setthink, time, vectoangles(), and vector.

Referenced by SUB_CalcMove_Bezier().

SUB_CalcMoveDone()

void SUB_CalcMoveDone

(

entity

this

)

Definition at line 94 of file subs.qc.

{
    // After moving, set origin to exact final destination
 
    setorigin (this, this.finaldest);
    this.velocity = '0 0 0';
    this.nextthink = -1;
    if (this.think1 && this.think1 != SUB_CalcMoveDone)
        this.think1 (this);
}

References entity(), finaldest, nextthink, SUB_CalcMoveDone(), and velocity.

Referenced by SUB_CalcMove(), SUB_CalcMove_Bezier(), and SUB_CalcMoveDone().

SUB_CalcMoveEnt()

void SUB_CalcMoveEnt	(	entity	ent,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func )

Definition at line 321 of file subs.qc.

{
    SUB_CalcMove(ent, tdest, tspeedtype, tspeed, func);
}

References entity(), SUB_CalcMove(), and vector.

SUB_CalcMovePause()

void SUB_CalcMovePause

(

entity

this

)

Definition at line 105 of file subs.qc.

{
    if (!this.move_controller)
        return;
    this.move_controller.animstate_starttime += frametime;
    this.move_controller.animstate_endtime += frametime;
}

References entity(), frametime, and move_controller.

Referenced by door_blocked().

SUB_Friction()

void SUB_Friction

(

entity

this

)

Definition at line 24 of file subs.qc.

{
    this.nextthink = time;
    if(IS_ONGROUND(this))
        this.velocity = this.velocity * (1 - frametime * this.friction);
}

References entity(), frametime, friction, IS_ONGROUND, nextthink, time, and velocity.

SUB_NullThink()

void SUB_NullThink

(

entity

this

)

Definition at line 3 of file subs.qc.

{ }

References entity().

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

SUB_SetFade()

void SUB_SetFade	(	entity	ent,
		float	vanish_time,
		float	fading_time )

Definition at line 77 of file subs.qc.

{
    if (fading_time <= 0)
        fading_time = 0.01;
    ent.fade_rate = 1/fading_time;
    setthink(ent, SUB_SetFade_Think);
    ent.nextthink = vanish_time;
}

References entity(), setthink, and SUB_SetFade_Think().

Referenced by LaunchDebris(), Monster_Dead_Fade(), PlayerDamage(), Portal_Remove(), respawn(), and spiderbot_blowup().

SUB_SetFade_Think()

void SUB_SetFade_Think

(

entity

this

)

Definition at line 57 of file subs.qc.

{
    if(this.alpha == 0)
        this.alpha = 1;
    setthink(this, SUB_SetFade_Think);
    this.nextthink = time;
    this.alpha -= frametime * this.fade_rate;
    if (this.alpha < 0.01)
        SUB_VanishOrRemove(this);
    else
        this.nextthink = time;
}

References alpha, entity(), fade_rate, frametime, nextthink, setthink, SUB_SetFade_Think(), SUB_VanishOrRemove(), and time.

Referenced by SUB_SetFade(), and SUB_SetFade_Think().

SUB_VanishOrRemove()

void SUB_VanishOrRemove

(

entity

ent

)

Definition at line 38 of file subs.qc.

{
    if (IS_CLIENT(ent))
    {
        // vanish
        ent.alpha = -1;
        ent.effects = 0;
#ifdef SVQC
        ent.glow_size = 0;
        ent.pflags = 0;
#endif
    }
    else
    {
        // remove
        delete(ent);
    }
}

References entity(), and IS_CLIENT.

Referenced by SUB_SetFade_Think().

Variable Documentation

friction

float friction

Definition at line 23 of file subs.qc.

Referenced by SUB_Friction().

platmovetype_turn

float platmovetype_turn

Definition at line 113 of file subs.qc.

Referenced by plat_send(), spawnfunc(), train_send(), and train_wait().