X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Ftriggers%2Fsubs.qc;h=51ef002736a32201d391cc9831b9a4f84f06389f;hb=8cbf0e84432e075e617f43c037c645ea9846eba0;hp=c2be7c72d925ecd12176b44d56ab3423354ae5c2;hpb=490a31934aa67cc7de5299a4d3f625d5271f8583;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/triggers/subs.qc b/qcsrc/common/triggers/subs.qc index c2be7c72d..51ef00273 100644 --- a/qcsrc/common/triggers/subs.qc +++ b/qcsrc/common/triggers/subs.qc @@ -7,15 +7,15 @@ void SUB_CalcAngleMoveDone(entity this); ================== SUB_Friction -Applies some friction to self +Applies some friction to this ================== */ .float friction; -void SUB_Friction () -{SELFPARAM(); - self.SUB_NEXTTHINK = time; - if(self.SUB_FLAGS & FL_ONGROUND) - self.SUB_VELOCITY = self.SUB_VELOCITY * (1 - frametime * self.friction); +void SUB_Friction (entity this) +{ + this.SUB_NEXTTHINK = time; + if(this.SUB_FLAGS & FL_ONGROUND) + this.SUB_VELOCITY = this.SUB_VELOCITY * (1 - frametime * this.friction); } /* @@ -75,19 +75,19 @@ void SUB_SetFade (entity ent, float when, float fading_time) ============= SUB_CalcMove -calculate self.SUB_VELOCITY and self.SUB_NEXTTHINK to reach dest from -self.SUB_ORIGIN traveling at speed +calculate this.SUB_VELOCITY and this.SUB_NEXTTHINK to reach dest from +this.SUB_ORIGIN traveling at speed =============== */ void SUB_CalcMoveDone(entity this) { // After moving, set origin to exact final destination - SUB_SETORIGIN (self, self.finaldest); - self.SUB_VELOCITY = '0 0 0'; - self.SUB_NEXTTHINK = -1; - if (self.think1) - self.think1 (self); + SUB_SETORIGIN (this, this.finaldest); + this.SUB_VELOCITY = '0 0 0'; + this.SUB_NEXTTHINK = -1; + if (this.think1) + this.think1 (this); } .float platmovetype_turn; @@ -101,19 +101,19 @@ void SUB_CalcMove_controller_think (entity this) vector veloc; vector angloc; vector nextpos; - delta = self.destvec; - delta2 = self.destvec2; - if(time < self.animstate_endtime) + delta = this.destvec; + delta2 = this.destvec2; + if(time < this.animstate_endtime) { nexttick = time + PHYS_INPUT_FRAMETIME; - 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); - nextpos = self.origin + (delta * phasepos) + (delta2 * phasepos * phasepos); + 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(self.owner.platmovetype_turn) + if(this.owner.platmovetype_turn) { vector destangle; destangle = delta + 2 * delta2 * phasepos; @@ -121,31 +121,31 @@ void SUB_CalcMove_controller_think (entity this) destangle_x = -destangle_x; // flip up / down orientation // take the shortest distance for the angles - vector v = SUB_ANGLES(self.owner); + vector v = SUB_ANGLES(this.owner); 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); - SUB_ANGLES(self.owner) = v; - angloc = destangle - SUB_ANGLES(self.owner); + SUB_ANGLES(this.owner) = v; + angloc = destangle - SUB_ANGLES(this.owner); angloc = angloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame - self.owner.SUB_AVELOCITY = angloc; + this.owner.SUB_AVELOCITY = angloc; } - if(nexttick < self.animstate_endtime) - veloc = nextpos - self.owner.SUB_ORIGIN; + if(nexttick < this.animstate_endtime) + veloc = nextpos - this.owner.SUB_ORIGIN; else - veloc = self.finaldest - self.owner.SUB_ORIGIN; + veloc = this.finaldest - this.owner.SUB_ORIGIN; veloc = veloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame - self.owner.SUB_VELOCITY = veloc; - self.nextthink = nexttick; + this.owner.SUB_VELOCITY = veloc; + this.nextthink = nexttick; } else { // derivative: delta + 2 * delta2 (e.g. for angle positioning) - entity own = self.owner; - SUB_THINK(own, self.think1); - remove(self); - WITHSELF(own, SUB_THUNK(own)(own)); + entity own = this.owner; + SUB_THINK(own, this.think1); + remove(this); + SUB_THUNK(own)(own); } } @@ -183,29 +183,29 @@ float TSPEED_START = 1; float TSPEED_END = 2; // TODO average too? -void SUB_CalcMove_Bezier (vector tcontrol, vector tdest, float tspeedtype, float tspeed, void(entity this) func) -{SELFPARAM(); +void SUB_CalcMove_Bezier (entity this, vector tcontrol, vector tdest, float tspeedtype, float tspeed, void(entity this) func) +{ float traveltime; entity controller; if (!tspeed) - objerror ("No speed is defined!"); + objerror (this, "No speed is defined!"); - self.think1 = func; - self.finaldest = tdest; - SUB_THINK(self, SUB_CalcMoveDone); + this.think1 = func; + this.finaldest = tdest; + SUB_THINK(this, SUB_CalcMoveDone); switch(tspeedtype) { default: case TSPEED_START: - traveltime = 2 * vlen(tcontrol - self.SUB_ORIGIN) / tspeed; + traveltime = 2 * vlen(tcontrol - this.SUB_ORIGIN) / tspeed; break; case TSPEED_END: traveltime = 2 * vlen(tcontrol - tdest) / tspeed; break; case TSPEED_LINEAR: - traveltime = vlen(tdest - self.SUB_ORIGIN) / tspeed; + traveltime = vlen(tdest - this.SUB_ORIGIN) / tspeed; break; case TSPEED_TIME: traveltime = tspeed; @@ -214,51 +214,51 @@ void SUB_CalcMove_Bezier (vector tcontrol, vector tdest, float tspeedtype, float if (traveltime < 0.1) // useless anim { - self.SUB_VELOCITY = '0 0 0'; - self.SUB_NEXTTHINK = self.SUB_LTIME + 0.1; + this.SUB_VELOCITY = '0 0 0'; + this.SUB_NEXTTHINK = this.SUB_LTIME + 0.1; return; } controller = new(SUB_CalcMove_controller); - controller.owner = self; - controller.platmovetype = self.platmovetype; - controller.platmovetype_start = self.platmovetype_start; - controller.platmovetype_end = self.platmovetype_end; - SUB_CalcMove_controller_setbezier(controller, self.SUB_ORIGIN, tcontrol, tdest); + controller.owner = this; + controller.platmovetype = this.platmovetype; + controller.platmovetype_start = this.platmovetype_start; + controller.platmovetype_end = this.platmovetype_end; + SUB_CalcMove_controller_setbezier(controller, this.SUB_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 = SUB_THUNK(self); + controller.think1 = SUB_THUNK(this); // the thinking is now done by the controller - SUB_THINK(self, SUB_NullThink); // for PushMove - self.SUB_NEXTTHINK = self.SUB_LTIME + traveltime; + SUB_THINK(this, SUB_NullThink); // for PushMove + this.SUB_NEXTTHINK = this.SUB_LTIME + traveltime; // invoke controller - WITHSELF(controller, getthink(controller)(controller)); + getthink(controller)(controller); } -void SUB_CalcMove (vector tdest, float tspeedtype, float tspeed, void(entity this) func) -{SELFPARAM(); +void SUB_CalcMove (entity this, vector tdest, float tspeedtype, float tspeed, void(entity this) func) +{ vector delta; float traveltime; if (!tspeed) - objerror ("No speed is defined!"); + objerror (this, "No speed is defined!"); - self.think1 = func; - self.finaldest = tdest; - SUB_THINK(self, SUB_CalcMoveDone); + this.think1 = func; + this.finaldest = tdest; + SUB_THINK(this, SUB_CalcMoveDone); - if (tdest == self.SUB_ORIGIN) + if (tdest == this.SUB_ORIGIN) { - self.SUB_VELOCITY = '0 0 0'; - self.SUB_NEXTTHINK = self.SUB_LTIME + 0.1; + this.SUB_VELOCITY = '0 0 0'; + this.SUB_NEXTTHINK = this.SUB_LTIME + 0.1; return; } - delta = tdest - self.SUB_ORIGIN; + delta = tdest - this.SUB_ORIGIN; switch(tspeedtype) { @@ -277,56 +277,56 @@ void SUB_CalcMove (vector tdest, float tspeedtype, float tspeed, void(entity thi // 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 || (self.platmovetype_start == 1 && self.platmovetype_end == 1)) // is this correct? + if (traveltime < 0.15 || (this.platmovetype_start == 1 && this.platmovetype_end == 1)) // is this correct? { - self.SUB_VELOCITY = delta * (1/traveltime); // QuakeC doesn't allow vector/float division - self.SUB_NEXTTHINK = self.SUB_LTIME + traveltime; + this.SUB_VELOCITY = delta * (1/traveltime); // QuakeC doesn't allow vector/float division + this.SUB_NEXTTHINK = this.SUB_LTIME + traveltime; return; } // now just run like a bezier curve... - SUB_CalcMove_Bezier((self.SUB_ORIGIN + tdest) * 0.5, tdest, tspeedtype, tspeed, func); + SUB_CalcMove_Bezier(this, (this.SUB_ORIGIN + tdest) * 0.5, tdest, tspeedtype, tspeed, func); } void SUB_CalcMoveEnt (entity ent, vector tdest, float tspeedtype, float tspeed, void(entity this) func) { - WITHSELF(ent, SUB_CalcMove(tdest, tspeedtype, tspeed, func)); + SUB_CalcMove(ent, tdest, tspeedtype, tspeed, func); } /* ============= SUB_CalcAngleMove -calculate self.SUB_AVELOCITY and self.SUB_NEXTTHINK to reach destangle from -self.angles rotating +calculate this.SUB_AVELOCITY and this.SUB_NEXTTHINK to reach destangle from +this.angles rotating -The calling function should make sure self.SUB_THINK is valid +The calling function should make sure this.SUB_THINK is valid =============== */ void SUB_CalcAngleMoveDone(entity this) { // After rotating, set angle to exact final angle - self.angles = self.finalangle; - self.SUB_AVELOCITY = '0 0 0'; - self.SUB_NEXTTHINK = -1; - if (self.think1) - self.think1 (self); + this.angles = this.finalangle; + this.SUB_AVELOCITY = '0 0 0'; + this.SUB_NEXTTHINK = -1; + if (this.think1) + this.think1 (this); } // FIXME: I fixed this function only for rotation around the main axes -void SUB_CalcAngleMove (vector destangle, float tspeedtype, float tspeed, void(entity this) func) -{SELFPARAM(); +void SUB_CalcAngleMove (entity this, vector destangle, float tspeedtype, float tspeed, void(entity this) func) +{ vector delta; float traveltime; if (!tspeed) - objerror ("No speed is defined!"); + objerror (this, "No speed is defined!"); // take the shortest distance for the angles - self.angles_x -= 360 * floor((self.angles_x - destangle_x) / 360 + 0.5); - self.angles_y -= 360 * floor((self.angles_y - destangle_y) / 360 + 0.5); - self.angles_z -= 360 * floor((self.angles_z - destangle_z) / 360 + 0.5); - delta = destangle - self.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); + delta = destangle - this.angles; switch(tspeedtype) { @@ -341,22 +341,22 @@ void SUB_CalcAngleMove (vector destangle, float tspeedtype, float tspeed, void(e break; } - self.think1 = func; - self.finalangle = destangle; - SUB_THINK(self, SUB_CalcAngleMoveDone); + this.think1 = func; + this.finalangle = destangle; + SUB_THINK(this, SUB_CalcAngleMoveDone); if (traveltime < 0.1) { - self.SUB_AVELOCITY = '0 0 0'; - self.SUB_NEXTTHINK = self.SUB_LTIME + 0.1; + this.SUB_AVELOCITY = '0 0 0'; + this.SUB_NEXTTHINK = this.SUB_LTIME + 0.1; return; } - self.SUB_AVELOCITY = delta * (1 / traveltime); - self.SUB_NEXTTHINK = self.SUB_LTIME + traveltime; + this.SUB_AVELOCITY = delta * (1 / traveltime); + this.SUB_NEXTTHINK = this.SUB_LTIME + traveltime; } void SUB_CalcAngleMoveEnt (entity ent, vector destangle, float tspeedtype, float tspeed, void(entity this) func) { - WITHSELF(ent, SUB_CalcAngleMove (destangle, tspeedtype, tspeed, func)); + SUB_CalcAngleMove (ent, destangle, tspeedtype, tspeed, func); }