-void SUB_Null() {}
-float SUB_True() { return 1; }
-float SUB_False() { return 0; }
+void SUB_NullThink(void) { }
void() SUB_CalcMoveDone;
void() SUB_CalcAngleMoveDone;
//print(ftos(time), " -> ", ftos(e.frame), "\n");
}
-vector animfixfps(entity e, vector a)
-{
- // multi-frame anim: keep as-is
- if(a_y == 1)
- {
- float dur;
- dur = frameduration(e.modelindex, a_x);
- if(dur > 0)
- a_z = 1.0 / dur;
- }
- return a;
-}
-
/*
==================
SUB_Remove
*/
void SUB_VanishOrRemove (entity ent)
{
- if (ent.flags & FL_CLIENT)
+ if (IS_CLIENT(ent))
{
// vanish
ent.alpha = -1;
*/
void SUB_SetFade (entity ent, float when, float fadetime)
{
- //if (ent.flags & FL_CLIENT) // && ent.deadflag != DEAD_NO)
- // return;
- //ent.alpha = 1;
ent.fade_rate = 1/fadetime;
ent.think = SUB_SetFade_Think;
ent.nextthink = when;
vector delta;
vector delta2;
vector veloc;
+ vector angloc;
vector nextpos;
delta = self.destvec;
delta2 = self.destvec2;
traveltime = self.animstate_endtime - self.animstate_starttime;
phasepos = (nexttick - self.animstate_starttime) / traveltime; // range: [0, 1]
phasepos = cubic_speedfunc(self.platmovetype_start, self.platmovetype_end, phasepos);
-
- /* switch(self.platmovetype)
- {
- case 1: // linear
- break;
- // phasepos = cubic_speedfunc(1, 1, phasepos); // identity
- case 2: // cosine
- // phasepos = (1 - cos(phasepos * 3.14159265)) / 2;
- phasepos = cubic_speedfunc(0, 0, phasepos);
- break;
- case 3: // inverted cosine
- // phasepos = acos(1 - phasepos * 2) / 3.14159265;
- phasepos = cubic_speedfunc(2, 2, phasepos);
- break;
- case 4: // half cosine
- // phasepos = (1 - cos(phasepos * (3.14159265 / 2)));
- phasepos = cubic_speedfunc(0, 1.5, phasepos);
- break;
- case 5: // inverted half cosine
- // phasepos = sin(phasepos * (3.14159265 / 2));
- phasepos = cubic_speedfunc(1.5, 0, phasepos);
- break;
- } */
nextpos = self.origin + (delta * phasepos) + (delta2 * phasepos * phasepos);
// derivative: delta + 2 * delta2 * phasepos (e.g. for angle positioning)
- if(nexttick < self.animstate_endtime) {
- veloc = nextpos - self.owner.origin;
- veloc = veloc * (1 / sys_frametime); // so it arrives for the next frame
- } else {
- veloc = self.finaldest - self.owner.origin;
- veloc = veloc * (1 / sys_frametime); // so it arrives for the next frame
- }
- self.owner.velocity = veloc;
if(self.owner.platmovetype_turn)
{
- vector vel;
- vel = delta + 2 * delta2 * phasepos;
- vel_z = -vel_z; // invert z velocity
- vel = vectoangles(vel);
- self.owner.angles = vel;
+ 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
+ self.owner.angles_x -= 360 * floor((self.owner.angles_x - destangle_x) / 360 + 0.5);
+ self.owner.angles_y -= 360 * floor((self.owner.angles_y - destangle_y) / 360 + 0.5);
+ self.owner.angles_z -= 360 * floor((self.owner.angles_z - destangle_z) / 360 + 0.5);
+ angloc = destangle - self.owner.angles;
+ angloc = angloc * (1 / sys_frametime); // so it arrives for the next frame
+ self.owner.avelocity = angloc;
}
+ if(nexttick < self.animstate_endtime)
+ veloc = nextpos - self.owner.origin;
+ else
+ veloc = self.finaldest - self.owner.origin;
+ veloc = veloc * (1 / sys_frametime); // so it arrives for the next frame
+
+ self.owner.velocity = veloc;
self.nextthink = nexttick;
} else {
// derivative: delta + 2 * delta2 (e.g. for angle positioning)
controller.think1 = self.think;
// the thinking is now done by the controller
- self.think = SUB_Null;
+ self.think = SUB_NullThink; // for PushMove
self.nextthink = self.ltime + traveltime;
// invoke controller
// check whether antilagged traces are enabled
if (lag < 0.001)
lag = 0;
- if (clienttype(forent) != CLIENTTYPE_REAL)
+ if not(IS_REAL_CLIENT(forent))
lag = 0; // only antilag for clients
// change shooter to SOLID_BBOX so the shot can hit corpses
if(self.model != "")
{
precache_model(self.model);
- setmodel(self, self.model); // no precision needed
+ if(self.mins != '0 0 0' || self.maxs != '0 0 0')
+ {
+ vector mi = self.mins;
+ vector ma = self.maxs;
+ setmodel(self, self.model); // no precision needed
+ setsize(self, mi, ma);
+ }
+ else
+ setmodel(self, self.model); // no precision needed
InitializeEntity(self, LODmodel_attach, INITPRIO_FINDTARGET);
}
setorigin(self, self.origin);
if(self.model != "")
{
precache_model(self.model);
- setmodel(self, self.model); // no precision needed
+ if(self.mins != '0 0 0' || self.maxs != '0 0 0')
+ {
+ vector mi = self.mins;
+ vector ma = self.maxs;
+ setmodel(self, self.model); // no precision needed
+ setsize(self, mi, ma);
+ }
+ else
+ setmodel(self, self.model); // no precision needed
}
setorigin(self, self.origin);
ApplyMinMaxScaleAngles(self);