super-coop/source/ai_subs.qc

298 lines
6.0 KiB
Plaintext

// ai_subs.qc: subroutines for think frames
void() sub_null = {};
void(entity attacker, float damage) sub_pain_null = {};
void() sub_remove = {remove(self);};
/*
QuakeEd only writes a single float for angles(bad idea), so up and down are
just constant angles.
*/
void() set_move_dir = {
if(self.angles == '0 -1 0') {
self.movedir = '0 0 1';
} else if(self.angles == '0 -2 0') {
self.movedir = '0 0 -1';
} else {
make_vectors(self.angles);
self.movedir = v_forward;
}
self.angles = VEC_ORIGIN;
};
/*
================
init_trigger
================
*/
void() init_trigger = {
// 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.
if(self.angles != VEC_ORIGIN) {
set_move_dir();
}
self.solid = SOLID_TRIGGER;
set_model(self, self.model); // set size and link into world
self.movetype = MOVETYPE_NONE;
self.modelindex = 0;
self.model = string_null;
};
/*
=============
sub_calc_move
calculate self.velocity and self.nextthink to reach dest from
self.origin traveling at speed
===============
*/
void(entity ent, vector tdest, float tspeed, void() func) sub_calc_move_ent = {
entity stemp;
stemp = self;
self = ent;
sub_calc_move(tdest, tspeed, func);
self = stemp;
};
void(vector tdest, float tspeed, void() func) sub_calc_move = {
vector vdestdelta;
float len, traveltime;
if(!tspeed) {
error_obj("No speed is defined!");
}
self.think1 = func;
self.finaldest = tdest;
self.think = sub_calc_move_done;
if(tdest == self.origin) {
self.velocity = VEC_ORIGIN;
self.nextthink = self.ltime + 0.1;
return;
}
// set destdelta to the vector needed to move
vdestdelta = tdest - self.origin;
// calculate length of vector
len = vec_len(vdestdelta);
// divide by speed to get time to reach dest
traveltime = len / tspeed;
if(traveltime < 0.1) {
self.velocity = VEC_ORIGIN;
self.nextthink = self.ltime + 0.1;
return;
}
// set nextthink to trigger a think when dest is reached
self.nextthink = self.ltime + traveltime;
// scale the destdelta vector by the time spent traveling to get velocity
self.velocity = vdestdelta * (1 / traveltime); // qcc won't take vec/float
};
/*
============
After moving, set origin to exact final destination
============
*/
void() sub_calc_move_done = {
set_origin(self, self.finaldest);
self.velocity = VEC_ORIGIN;
self.nextthink = -1;
if(self.think1) {
self.think1();
}
};
/*
=============
sub_calc_angle_move
calculate self.avelocity and self.nextthink to reach destangle from
self.angles rotating
The calling function should make sure self.think is valid
===============
*/
void(entity ent, vector destangle, float tspeed, void() func) sub_calc_angle_moveEnt = {
entity stemp;
stemp = self;
self = ent;
sub_calc_angle_move(destangle, tspeed, func);
self = stemp;
};
void(vector destangle, float tspeed, void() func) sub_calc_angle_move = {
vector destdelta;
float len, traveltime;
if(!tspeed) {
error_obj("No speed is defined!");
}
// set destdelta to the vector needed to move
destdelta = destangle - self.angles;
// calculate length of vector
len = vec_len(destdelta);
// divide by speed to get time to reach dest
traveltime = len / tspeed;
// set nextthink to trigger a think when dest is reached
self.nextthink = self.ltime + traveltime;
// scale the destdelta vector by the time spent traveling to get velocity
self.avelocity = destdelta * (1 / traveltime);
self.think1 = func;
self.finalangle = destangle;
self.think = sub_calc_angle_move_done;
};
/*
============
After rotating, set angle to exact final angle
============
*/
void() sub_calc_angle_move_done = {
self.angles = self.finalangle;
self.avelocity = VEC_ORIGIN;
self.nextthink = -1;
if(self.think1) {
self.think1();
}
};
//=============================================================================
void() delay_think = {
activator = self.enemy;
sub_use_targets();
remove(self);
};
/*
==============================
sub_use_targets
the global "activator" should be set to the entity that initiated the firing.
If self.delay is set, a DelayedUse entity will be created that will actually
do the sub_use_targets after that many seconds have passed.
Centerprints any self.message to the activator.
Removes all entities with a targetname that match self.killtarget,
and removes them, so some events can remove other triggers.
Search for(string)targetname in all entities that
match(string)self.target and call their .use function
==============================
*/
void() sub_use_targets = {
entity t, stemp, otemp, act;
//
// check for a delay
//
if(self.delay) {
// create a temp object to fire at a later time
t = spawn();
t.classname = "DelayedUse";
t.nextthink = time + self.delay;
t.think = delay_think;
t.enemy = activator;
t.message = self.message;
t.killtarget = self.killtarget;
t.target = self.target;
return;
}
//
// print the message
//
if(activator.classname == "player" && self.message != string_null) {
print_center(activator, self.message);
if(!self.noise) {
sound(activator, CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
}
}
//
// kill the killtagets
//
if(self.killtarget) {
t = world;
do {
t = find(t, targetname, self.killtarget);
if(!t) {
return;
}
remove(t);
} while(1);
}
//
// fire targets
//
if(self.target) {
act = activator;
t = world;
do {
t = find(t, targetname, self.target);
if(!t) {
return;
}
stemp = self;
otemp = other;
self = t;
other = stemp;
if(self.use != sub_null) {
if(self.use) {
self.use();
}
}
self = stemp;
other = otemp;
activator = act;
} while(1);
}
};
/*
in nightmare mode, all attack_finished times become 0
some monsters refire twice automatically
*/
void(float normal) sub_attack_finished = {
self.cnt = 0; // refire count for nightmare
if(skill != 3) {
self.attack_finished = time + normal;
}
};
void(void() thinkst) sub_check_refire = {
if(skill != 3) {
return;
}
if(self.cnt == 1) {
return;
}
if(!visible(self.enemy)) {
return;
}
self.cnt = 1;
self.think = thinkst;
};