X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fphysics%2Fmovelib.qc;h=e66e3c9a9ce58f19b447a714f6bcd3bdcc7bd3c6;hb=cd4f4226492c148756d24b0bb46fdd8d23d41234;hp=207b4c636de56fae18d7303bd9719d2d1742ab34;hpb=f41d9f31538bef0259d2b2c74536bb977901f99d;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/physics/movelib.qc b/qcsrc/common/physics/movelib.qc
index 207b4c636..e66e3c9a9 100644
--- a/qcsrc/common/physics/movelib.qc
+++ b/qcsrc/common/physics/movelib.qc
@@ -5,23 +5,23 @@
 
 /**
     Simulate drag
-    self.velocity = movelib_dragvec(self.velocity,0.02,0.5);
+    this.velocity = movelib_dragvec(this.velocity,0.02,0.5);
 **/
-vector movelib_dragvec(float drag, float exp_)
-{SELFPARAM();
+vector movelib_dragvec(entity this, float drag, float exp_)
+{
     float lspeed,ldrag;
 
-    lspeed = vlen(self.velocity);
+    lspeed = vlen(this.velocity);
     ldrag = lspeed * drag;
     ldrag = ldrag * (drag * exp_);
     ldrag = 1 - (ldrag / lspeed);
 
-    return self.velocity * ldrag;
+    return this.velocity * ldrag;
 }
 
 /**
     Simulate drag
-    self.velocity *= movelib_dragflt(somespeed,0.01,0.7);
+    this.velocity *= movelib_dragflt(somespeed,0.01,0.7);
 **/
 float movelib_dragflt(float fspeed,float drag,float exp_)
 {
@@ -37,70 +37,70 @@ float movelib_dragflt(float fspeed,float drag,float exp_)
 /**
     Do a inertia simulation based on velocity.
     Basicaly, this allows you to simulate loss of steering with higher speed.
-    self.velocity = movelib_inertmove_byspeed(self.velocity,newvel,1000,0.1,0.9);
+    this.velocity = movelib_inertmove_byspeed(this.velocity,newvel,1000,0.1,0.9);
 **/
-vector movelib_inertmove_byspeed(vector vel_new, float vel_max,float newmin,float oldmax)
-{SELFPARAM();
+vector movelib_inertmove_byspeed(entity this, vector vel_new, float vel_max,float newmin,float oldmax)
+{
     float influense;
 
-    influense = vlen(self.velocity) * (1 / vel_max);
+    influense = vlen(this.velocity) * (1 / vel_max);
 
     influense = bound(newmin,influense,oldmax);
 
-    return (vel_new * (1 - influense)) + (self.velocity * influense);
+    return (vel_new * (1 - influense)) + (this.velocity * influense);
 }
 
-vector movelib_inertmove(vector new_vel,float new_bias)
-{SELFPARAM();
-    return new_vel * new_bias + self.velocity * (1-new_bias);
+vector movelib_inertmove(entity this, vector new_vel,float new_bias)
+{
+    return new_vel * new_bias + this.velocity * (1-new_bias);
 }
 
-void movelib_move(vector force,float max_velocity,float drag,float theMass,float breakforce)
-{SELFPARAM();
+void movelib_move(entity this, vector force,float max_velocity,float drag,float theMass,float breakforce)
+{
     float deltatime;
     float acceleration;
     float mspeed;
     vector breakvec;
 
-    deltatime = time - self.movelib_lastupdate;
+    deltatime = time - this.movelib_lastupdate;
     if (deltatime > 0.15) deltatime = 0;
-    self.movelib_lastupdate = time;
+    this.movelib_lastupdate = time;
     if (!deltatime) return;
 
-    mspeed = vlen(self.velocity);
+    mspeed = vlen(this.velocity);
 
     if (theMass)
         acceleration = vlen(force) / theMass;
     else
         acceleration = vlen(force);
 
-    if (IS_ONGROUND(self))
+    if (IS_ONGROUND(this))
     {
         if (breakforce)
         {
-            breakvec = (normalize(self.velocity) * (breakforce / theMass) * deltatime);
-            self.velocity = self.velocity - breakvec;
+            breakvec = (normalize(this.velocity) * (breakforce / theMass) * deltatime);
+            this.velocity = this.velocity - breakvec;
         }
 
-        self.velocity = self.velocity + force * (acceleration * deltatime);
+        this.velocity = this.velocity + force * (acceleration * deltatime);
     }
 
     if (drag)
-        self.velocity = movelib_dragvec(drag, 1);
+        this.velocity = movelib_dragvec(this, drag, 1);
 
-    if (self.waterlevel > 1)
+    if (this.waterlevel > 1)
     {
-        self.velocity = self.velocity + force * (acceleration * deltatime);
-        self.velocity = self.velocity + '0 0 0.05' * autocvar_sv_gravity * deltatime;
+        this.velocity = this.velocity + force * (acceleration * deltatime);
+        this.velocity = this.velocity + '0 0 0.05' * autocvar_sv_gravity * deltatime;
     }
     else
-        self.velocity = self.velocity + '0 0 -1' * autocvar_sv_gravity * deltatime;
+        this.velocity = this.velocity + '0 0 -1' * autocvar_sv_gravity * deltatime;
 
-    mspeed = vlen(self.velocity);
+    mspeed = vlen(this.velocity);
 
     if (max_velocity)
         if (mspeed > max_velocity)
-            self.velocity = normalize(self.velocity) * (mspeed - 50);//* max_velocity;
+            this.velocity = normalize(this.velocity) * (mspeed - 50);//* max_velocity;
 }
 
 /*
@@ -112,17 +112,17 @@ void movelib_move(vector force,float max_velocity,float drag,float theMass,float
 .float buoyancy;
 float movelib_deltatime;
 
-void movelib_startupdate()
+void movelib_startupdate(entity this)
 {
-    movelib_deltatime = time - self.movelib_lastupdate;
+    movelib_deltatime = time - this.movelib_lastupdate;
 
     if (movelib_deltatime > 0.5)
         movelib_deltatime = 0;
 
-    self.movelib_lastupdate = time;
+    this.movelib_lastupdate = time;
 }
 
-void movelib_update(vector dir,float force)
+void movelib_update(entity this, vector dir,float force)
 {
     vector acceleration;
     float old_speed;
@@ -135,45 +135,45 @@ void movelib_update(vector dir,float force)
 
     if(!movelib_deltatime)
         return;
-    v_z = self.velocity_z;
-    old_speed    = vlen(self.velocity);
-    old_dir      = normalize(self.velocity);
+    v_z = this.velocity_z;
+    old_speed    = vlen(this.velocity);
+    old_dir      = normalize(this.velocity);
 
-    //ggravity      =  (autocvar_sv_gravity / self.mass) * '0 0 100';
-    acceleration =  (force / self.mass) * dir;
-    //acceleration -= old_dir * (old_speed / self.mass);
+    //ggravity      =  (autocvar_sv_gravity / this.mass) * '0 0 100';
+    acceleration =  (force / this.mass) * dir;
+    //acceleration -= old_dir * (old_speed / this.mass);
     acceleration -= ggravity;
 
-    if(self.waterlevel > 1)
+    if(this.waterlevel > 1)
     {
-        ffriction = self.water_friction;
-        acceleration += self.buoyancy * '0 0 1';
+        ffriction = this.water_friction;
+        acceleration += this.buoyancy * '0 0 1';
     }
     else
-        if(IS_ONGROUND(self))
-            ffriction = self.ground_friction;
+        if(IS_ONGROUND(this))
+            ffriction = this.ground_friction;
         else
-            ffriction = self.air_friction;
+            ffriction = this.air_friction;
 
     acceleration *= ffriction;
-    //self.velocity = self.velocity * (ffriction * movelib_deltatime);
-    self.velocity += acceleration * movelib_deltatime;
-    self.velocity_z = v_z;
+    //this.velocity = this.velocity * (ffriction * movelib_deltatime);
+    this.velocity += acceleration * movelib_deltatime;
+    this.velocity_z = v_z;
 
 }
 */
 
-void movelib_brake_simple(float force)
-{SELFPARAM();
+void movelib_brake_simple(entity this, float force)
+{
     float mspeed;
     vector mdir;
     float vz;
 
-    mspeed = max(0,vlen(self.velocity) - force);
-    mdir   = normalize(self.velocity);
-    vz = self.velocity.z;
-    self.velocity = mdir * mspeed;
-    self.velocity_z = vz;
+    mspeed = max(0,vlen(this.velocity) - force);
+    mdir   = normalize(this.velocity);
+    vz = this.velocity.z;
+    this.velocity = mdir * mspeed;
+    this.velocity_z = vz;
 }
 
 /**
@@ -182,41 +182,41 @@ Yed need to set v_up and v_forward (generally by calling makevectors) before cal
 **/
 #endif
 
-void movelib_groundalign4point(float spring_length, float spring_up, float blendrate, float _max)
-{SELFPARAM();
+void movelib_groundalign4point(entity this, float spring_length, float spring_up, float blendrate, float _max)
+{
     vector a, b, c, d, e, r, push_angle, ahead, side;
 
     push_angle.y = 0;
-    r = (self.absmax + self.absmin) * 0.5 + (v_up * spring_up);
+    r = (this.absmax + this.absmin) * 0.5 + (v_up * spring_up);
     e = v_up * spring_length;
 
     // Put springs slightly inside bbox
-    ahead = v_forward * (self.maxs.x * 0.8);
-    side  = v_right   * (self.maxs.y * 0.8);
+    ahead = v_forward * (this.maxs.x * 0.8);
+    side  = v_right   * (this.maxs.y * 0.8);
 
     a = r + ahead + side;
     b = r + ahead - side;
     c = r - ahead + side;
     d = r - ahead - side;
 
-    traceline(a, a - e,MOVE_NORMAL,self);
+    traceline(a, a - e,MOVE_NORMAL,this);
     a.z =  (1 - trace_fraction);
     r = trace_endpos;
 
-    traceline(b, b - e,MOVE_NORMAL,self);
+    traceline(b, b - e,MOVE_NORMAL,this);
     b.z =  (1 - trace_fraction);
     r += trace_endpos;
 
-    traceline(c, c - e,MOVE_NORMAL,self);
+    traceline(c, c - e,MOVE_NORMAL,this);
     c.z =  (1 - trace_fraction);
     r += trace_endpos;
 
-    traceline(d, d - e,MOVE_NORMAL,self);
+    traceline(d, d - e,MOVE_NORMAL,this);
     d.z =  (1 - trace_fraction);
     r += trace_endpos;
 
     a.x = r.z;
-    r = self.origin;
+    r = this.origin;
     r.z = r.z;
 
     push_angle.x = (a.z - c.z) * _max;
@@ -225,13 +225,13 @@ void movelib_groundalign4point(float spring_length, float spring_up, float blend
     push_angle.z = (b.z - a.z) * _max;
     push_angle.z += (d.z - c.z) * _max;
 
-    //self.angles_x += push_angle_x * 0.95;
-    //self.angles_z += push_angle_z * 0.95;
+    //this.angles_x += push_angle_x * 0.95;
+    //this.angles_z += push_angle_z * 0.95;
 
-    self.angles_x = ((1-blendrate) *  self.angles.x)  + (push_angle.x * blendrate);
-    self.angles_z = ((1-blendrate) *  self.angles.z)  + (push_angle.z * blendrate);
+    this.angles_x = ((1-blendrate) *  this.angles.x)  + (push_angle.x * blendrate);
+    this.angles_z = ((1-blendrate) *  this.angles.z)  + (push_angle.z * blendrate);
 
-    //a = self.origin;
-    setorigin(self,r);
+    //a = this.origin;
+    setorigin(this, r);
 }