#include "defs.qh"

Include dependency graph for subs.qh:

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

Functions
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 dest)

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

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_Friction (entity this)

void	SUB_NullThink (entity this)

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

void	SUB_SetFade_Think (entity this)

void	SUB_VanishOrRemove (entity ent)

	void (entity this) think1

Variables
string	curvetarget

float	delay

vector	dest1

vector	dest2

vector	destvec

vector	destvec2

float	fade_rate

vector	finalangle

vector	finaldest

float	friction

float	itemkeys

float	key_door_messagetime

string	killtarget

float	lip

vector	mangle

entity	move_controller

string	platmovetype

float	platmovetype_end

float	platmovetype_start

float	platmovetype_turn

vector	pos1

vector	pos2

float	sounds

float	speed

float	state

float	t_length

float	t_width

string	target2

string	target3

string	target4

float	target_random

float	trigger_reverse

const int	TSPEED_END = 2

const int	TSPEED_LINEAR = 0

const int	TSPEED_START = 1

const int	TSPEED_TIME = -1

float	wait

Function Documentation

◆ SUB_CalcAngleMove()

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

Definition at line 331 of file subs.qc.

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

Referenced by SUB_CalcAngleMoveEnt(), and train_wait().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcAngleMoveDone()

void SUB_CalcAngleMoveDone ( entity this )

Definition at line 320 of file subs.qc.

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

Referenced by SUB_CalcAngleMove(), SUB_CalcAngleMoveDone(), and SUB_NullThink().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcAngleMoveEnt()

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

Definition at line 371 of file subs.qc.

References anglemods(), angles, endsWith, entity(), find(), getSendEntity, InitializeEntity(), lodmodelindex0, lodmodelindex1, lodmodelindex2, makevectors, max(), maxs, mins, model, modelindex, movedir, MOVETYPE_NONE, MOVETYPE_PUSH, normalize(), NULL, objerror(), origin, set_movetype(), setorigin(), solid, SOLID_BSP, SOLID_TRIGGER, SUB_CalcAngleMove(), targetname, v_forward, vdist, vector(), and vlen().

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

Here is the call graph for this function:

◆ SUB_CalcMove()

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

Definition at line 256 of file subs.qc.

References 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 door_go_down(), door_go_up(), plat_go_down(), plat_go_up(), SUB_CalcMoveEnt(), and train_next().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcMove_Bezier()

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

Definition at line 194 of file subs.qc.

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

Referenced by SUB_CalcMove(), and train_next().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcMove_controller_setbezier()

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

Definition at line 166 of file subs.qc.

References setorigin().

Referenced by SUB_CalcMove_Bezier().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcMove_controller_setlinear()

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

Definition at line 181 of file subs.qc.

References setorigin().

 {
     // 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);
     destin -= org;
 
     controller.destvec = destin; // end point
     controller.destvec2 = '0 0 0';
 }

Here is the call graph for this function:

◆ SUB_CalcMove_controller_think()

void SUB_CalcMove_controller_think ( entity this )

Definition at line 106 of file subs.qc.

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

Referenced by SUB_CalcMove_Bezier().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcMoveDone()

void SUB_CalcMoveDone ( entity this )

Definition at line 94 of file subs.qc.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_CalcMoveEnt()

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

Definition at line 305 of file subs.qc.

References SUB_CalcMove().

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

Here is the call graph for this function:

◆ SUB_Friction()

void SUB_Friction ( entity this )

Definition at line 24 of file subs.qc.

References frametime, friction, IS_ONGROUND, nextthink, time, and velocity.

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

◆ SUB_NullThink()

void SUB_NullThink ( entity this )

Definition at line 3 of file subs.qc.

References entity(), spawnfunc(), SUB_CalcAngleMoveDone(), and SUB_CalcMoveDone().

Referenced by SUB_CalcMove_Bezier().

3 { }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_SetFade()

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

Definition at line 77 of file subs.qc.

References setthink, and SUB_SetFade_Think().

Referenced by Item_InitializeLoot(), Monster_Dead_Fade(), monster_dropitem(), PlayerDamage(), Portal_Remove(), respawn(), and thrown_wep_think().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_SetFade_Think()

void SUB_SetFade_Think ( entity this )

Definition at line 57 of file subs.qc.

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

Referenced by SUB_SetFade(), and SUB_SetFade_Think().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUB_VanishOrRemove()

void SUB_VanishOrRemove ( entity ent )

Definition at line 38 of file subs.qc.

References IS_CLIENT.

Referenced by SUB_SetFade_Think(), and thrown_wep_think().

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