Fix use of self in .draw
authorMario <mario@smbclan.net>
Sun, 3 Jan 2016 15:16:27 +0000 (01:16 +1000)
committerMario <mario@smbclan.net>
Sun, 3 Jan 2016 15:16:27 +0000 (01:16 +1000)
22 files changed:
qcsrc/client/view.qc
qcsrc/client/weapons/projectile.qc
qcsrc/common/effects/qc/casings.qc
qcsrc/common/effects/qc/gibs.qc
qcsrc/common/effects/qc/modeleffects.qc
qcsrc/common/effects/qc/rubble.qh
qcsrc/common/gamemodes/gamemode/onslaught/cl_generator.qc
qcsrc/common/mutators/mutator/nades/net.qc
qcsrc/common/triggers/func/rainsnow.qc
qcsrc/common/triggers/misc/laser.qc
qcsrc/common/triggers/triggers.qc
qcsrc/common/turrets/cl_turrets.qc
qcsrc/common/turrets/turret/ewheel.qc
qcsrc/common/turrets/turret/walker.qc
qcsrc/common/vehicles/vehicle/bumblebee_weapons.qc
qcsrc/common/vehicles/vehicle/raptor_weapons.qc
qcsrc/common/weapons/weapon/arc.qc
qcsrc/common/weapons/weapon/hook.qc
qcsrc/common/weapons/weapon/shockwave.qc
qcsrc/common/weapons/weapon/vaporizer.qc
qcsrc/lib/csqcmodel/interpolate.qc
qcsrc/lib/csqcmodel/interpolate.qh

index 8752f6d..790f929 100644 (file)
@@ -1839,7 +1839,7 @@ void CSQC_UpdateView(float w, float h)
           mousepos = mousepos*0.5 + getmousepos();
         */
 
-       FOREACH_ENTITY(it.draw, LAMBDA(WITH(entity, self, it, it.draw(it))));
+       FOREACH_ENTITY(it.draw, it.draw(it));
 
        addentities(MASK_NORMAL | MASK_ENGINE | MASK_ENGINEVIEWMODELS);
        renderscene();
index c57a5ae..5ab446f 100644 (file)
@@ -252,7 +252,7 @@ NET_HANDLE(ENT_CLIENT_PROJECTILE, bool isnew)
                {
                        this.trail_oldorigin = this.origin;
                        if (!(this.count & 0x80))
-                               WITH(entity, self, this, InterpolateOrigin_Reset());
+                               InterpolateOrigin_Reset(this);
                }
 
                if (f & 0x20)
index 3e0aa35..5b64817 100644 (file)
@@ -38,31 +38,31 @@ class(Casing) .bool silent;
 class(Casing) .int state;
 class(Casing) .float cnt;
 
-void Casing_Delete()
-{SELFPARAM();
+void Casing_Delete(entity this)
+{
     remove(self);
 }
 
 void Casing_Draw(entity this)
 {
-    if (self.move_flags & FL_ONGROUND)
+    if (this.move_flags & FL_ONGROUND)
     {
-        self.move_angles_x = 0;
-        self.move_angles_z = 0;
-        UNSET_ONGROUND(self);
+        this.move_angles_x = 0;
+        this.move_angles_z = 0;
+        UNSET_ONGROUND(this);
     }
 
-    Movetype_Physics_MatchTicrate(self, autocvar_cl_casings_ticrate, autocvar_cl_casings_sloppy);
-    if (wasfreed(self))
+    Movetype_Physics_MatchTicrate(this, autocvar_cl_casings_ticrate, autocvar_cl_casings_sloppy);
+    if (wasfreed(this))
         return; // deleted by touch function
 
-    self.renderflags = 0;
-    self.alpha = bound(0, self.cnt - time, 1);
+    this.renderflags = 0;
+    this.alpha = bound(0, this.cnt - time, 1);
 
-    if (self.alpha < ALPHA_MIN_VISIBLE)
+    if (this.alpha < ALPHA_MIN_VISIBLE)
     {
-        Casing_Delete();
-        self.drawmask = 0;
+        Casing_Delete(this);
+        this.drawmask = 0;
     }
 }
 
@@ -83,7 +83,7 @@ void Casing_Touch()
 {SELFPARAM();
     if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
     {
-        Casing_Delete();
+        Casing_Delete(self);
         return;
     }
 
index 00aa243..3d0da1b 100644 (file)
@@ -66,9 +66,9 @@ void Violence_GibSplash(entity source, float type, float amount, entity attacker
 .float cnt;
 .float gravity;
 
-void Gib_Delete()
-{SELFPARAM();
-       remove(self);
+void Gib_Delete(entity this)
+{
+       remove(this);
 }
 
 string species_prefix(int specnum);
@@ -112,7 +112,7 @@ void new_te_bloodshower (int ef, vector org, float explosionspeed, int howmany)
 void SUB_RemoveOnNoImpact()
 {
        if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
-               Gib_Delete();
+               Gib_Delete(self);
 }
 
 void Gib_Touch()
@@ -121,7 +121,7 @@ void Gib_Touch()
 
        if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
        {
-               Gib_Delete();
+               Gib_Delete(self);
                return;
        }
 
@@ -129,36 +129,36 @@ void Gib_Touch()
                sound(self, CH_PAIN, SND_GIB_SPLAT_RANDOM(), VOL_BASE, ATTEN_NORM);
        __pointparticles(_particleeffectnum(strcat(species_prefix(self.cnt), "blood")), self.origin + '0 0 1', '0 0 30', 10);
 
-       Gib_Delete();
+       Gib_Delete(self);
 }
 
 void Gib_Draw(entity this)
 {
        vector oldorg;
-       oldorg = self.origin;
+       oldorg = this.origin;
 
-       Movetype_Physics_MatchTicrate(self, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
-       if(wasfreed(self))
+       Movetype_Physics_MatchTicrate(this, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
+       if(wasfreed(this))
                return;
 
-       if(self.touch == Gib_Touch) // don't do this for the "chunk" thingie...
-               // TODO somehow make it spray in a direction dependent on self.angles
-               __trailparticles(self, _particleeffectnum(strcat(species_prefix(self.cnt), EFFECT_TR_SLIGHTBLOOD.eent_eff_name)), oldorg, self.origin);
+       if(this.touch == Gib_Touch) // don't do this for the "chunk" thingie...
+               // TODO somehow make it spray in a direction dependent on this.angles
+               __trailparticles(this, _particleeffectnum(strcat(species_prefix(this.cnt), EFFECT_TR_SLIGHTBLOOD.eent_eff_name)), oldorg, this.origin);
        else
-               __trailparticles(self, _particleeffectnum(strcat(species_prefix(self.cnt), EFFECT_TR_BLOOD.eent_eff_name)), oldorg, self.origin);
+               __trailparticles(this, _particleeffectnum(strcat(species_prefix(this.cnt), EFFECT_TR_BLOOD.eent_eff_name)), oldorg, this.origin);
 
-       self.renderflags = 0;
+       this.renderflags = 0;
 
        // make gibs die faster at low view quality
        // if view_quality is 0.5, we want to have them die twice as fast
-       self.nextthink -= frametime * (1 / bound(0.01, view_quality, 1.00) - 1);
+       this.nextthink -= frametime * (1 / bound(0.01, view_quality, 1.00) - 1);
 
-       self.alpha = bound(0, self.nextthink - time, 1);
+       this.alpha = bound(0, this.nextthink - time, 1);
 
-       if(self.alpha < ALPHA_MIN_VISIBLE)
+       if(this.alpha < ALPHA_MIN_VISIBLE)
        {
-               self.drawmask = 0;
-               Gib_Delete();
+               this.drawmask = 0;
+               Gib_Delete(this);
        }
 }
 
index 41c5ba0..d7e437e 100644 (file)
@@ -95,19 +95,19 @@ class(ModelEffect) .float scale1, scale2;
 
 void ModelEffect_Draw(entity this)
 {
-       self.angles = self.angles + frametime * self.avelocity;
-       setorigin(self, self.origin + frametime * self.velocity);
-       self.scale = self.scale1 + (self.scale2 - self.scale1) * (time - self.teleport_time) / (self.lifetime + self.fadetime - self.teleport_time);
-       self.alpha = self.cnt * bound(0, 1 - (time - self.lifetime) / self.fadetime, 1);
-       if(self.alpha < ALPHA_MIN_VISIBLE)
+       this.angles = this.angles + frametime * this.avelocity;
+       setorigin(this, this.origin + frametime * this.velocity);
+       this.scale = this.scale1 + (this.scale2 - this.scale1) * (time - this.teleport_time) / (this.lifetime + this.fadetime - this.teleport_time);
+       this.alpha = this.cnt * bound(0, 1 - (time - this.lifetime) / this.fadetime, 1);
+       if(this.alpha < ALPHA_MIN_VISIBLE)
        {
-               remove(self);
+               remove(this);
                return;
        }
-       self.drawmask = MASK_NORMAL;
-       if(self.scale <= 0)
+       this.drawmask = MASK_NORMAL;
+       if(this.scale <= 0)
        {
-               self.drawmask = 0;
+               this.drawmask = 0;
                return;
        }
 }
index 1a7cad8..73744e6 100644 (file)
@@ -6,7 +6,7 @@
 entityclass(Rubble);
 class(Rubble).float creationtime;
 
-void RubbleLimit(string cname, float limit, void() deleteproc)
+void RubbleLimit(string cname, float limit, void(entity) deleteproc)
 {
        SELFPARAM();
        entity e;
@@ -42,7 +42,7 @@ void RubbleLimit(string cname, float limit, void() deleteproc)
                if (c <= limit) break;
 
                // delete this oldest one and search again
-               WITH(entity, self, oldest, deleteproc());
+               deleteproc(oldest);
        }
 }
 
index f5b6111..6ded489 100644 (file)
@@ -44,75 +44,75 @@ void ons_generator_ray_spawn(vector org)
 
 void generator_draw(entity this)
 {
-       if(time < self.move_time)
+       if(time < this.move_time)
                return;
 
-       if(self.health > 0)
+       if(this.health > 0)
        {
                // damaged fx (less probable the more damaged is the generator)
-               if(random() < 0.9 - self.health / self.max_health)
+               if(random() < 0.9 - this.health / this.max_health)
                if(random() < 0.01)
                {
-                       pointparticles(EFFECT_ELECTRO_BALLEXPLODE, self.origin + randompos('-50 -50 -20', '50 50 50'), '0 0 0', 1);
-                       sound(self, CH_TRIGGER, SND_ONS_ELECTRICITY_EXPLODE, VOL_BASE, ATTEN_NORM);
+                       pointparticles(EFFECT_ELECTRO_BALLEXPLODE, this.origin + randompos('-50 -50 -20', '50 50 50'), '0 0 0', 1);
+                       sound(this, CH_TRIGGER, SND_ONS_ELECTRICITY_EXPLODE, VOL_BASE, ATTEN_NORM);
                }
                else
-                       pointparticles(EFFECT_ONS_GENERATOR_DAMAGED, self.origin + randompos('-60 -60 -20', '60 60 60'), '0 0 0', 1);
+                       pointparticles(EFFECT_ONS_GENERATOR_DAMAGED, this.origin + randompos('-60 -60 -20', '60 60 60'), '0 0 0', 1);
 
-               self.move_time = time + 0.1;
+               this.move_time = time + 0.1;
 
                return;
        }
 
-       if(self.count <= 0)
+       if(this.count <= 0)
                return;
 
        vector org;
        int i;
 
        // White shockwave
-       if(self.count==40||self.count==20)
+       if(this.count==40||this.count==20)
        {
-               sound(self, CH_TRIGGER, SND_ONS_SHOCKWAVE, VOL_BASE, ATTEN_NORM);
-               pointparticles(EFFECT_ELECTRO_COMBO, self.origin, '0 0 0', 6);
+               sound(this, CH_TRIGGER, SND_ONS_SHOCKWAVE, VOL_BASE, ATTEN_NORM);
+               pointparticles(EFFECT_ELECTRO_COMBO, this.origin, '0 0 0', 6);
        }
 
        // rays
        if(random() > 0.25)
        {
-               ons_generator_ray_spawn(self.origin);
+               ons_generator_ray_spawn(this.origin);
        }
 
        // Spawn fire balls
        for(i=0;i < 10;++i)
        {
-               org = self.origin + randompos('-30 -30 -30' * i + '0 0 -20', '30 30 30' * i + '0 0 20');
+               org = this.origin + randompos('-30 -30 -30' * i + '0 0 -20', '30 30 30' * i + '0 0 20');
                pointparticles(EFFECT_ONS_GENERATOR_GIB, org, '0 0 0', 1);
        }
 
        // Short explosion sound + small explosion
        if(random() < 0.25)
        {
-               te_explosion(self.origin);
-               sound(self, CH_TRIGGER, SND_GRENADE_IMPACT, VOL_BASE, ATTEN_NORM);
+               te_explosion(this.origin);
+               sound(this, CH_TRIGGER, SND_GRENADE_IMPACT, VOL_BASE, ATTEN_NORM);
        }
 
        // Particles
-       org = self.origin + randompos(self.mins + '8 8 8', self.maxs + '-8 -8 -8');
+       org = this.origin + randompos(this.mins + '8 8 8', this.maxs + '-8 -8 -8');
        pointparticles(EFFECT_ONS_GENERATOR_EXPLODE, org, '0 0 0', 1);
 
        // Final explosion
-       if(self.count==1)
+       if(this.count==1)
        {
-               org = self.origin;
+               org = this.origin;
                te_explosion(org);
                pointparticles(EFFECT_ONS_GENERATOR_EXPLODE2, org, '0 0 0', 1);
-               sound(self, CH_TRIGGER, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
+               sound(this, CH_TRIGGER, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
        }
 
-       self.move_time = time + 0.05;
+       this.move_time = time + 0.05;
 
-       self.count -= 1;
+       this.count -= 1;
 }
 
 void generator_damage(float hp)
index 072f507..70f2218 100644 (file)
@@ -6,13 +6,13 @@
 .float ltime;
 void healer_draw(entity this)
 {
-       float dt = time - self.move_time;
-       self.move_time = time;
+       float dt = time - this.move_time;
+       this.move_time = time;
        if(dt <= 0)
                return;
 
-       self.alpha = (self.ltime - time) / self.healer_lifetime;
-       self.scale = min((1 - self.alpha)*self.healer_lifetime*4,1)*self.healer_radius;
+       this.alpha = (this.ltime - time) / this.healer_lifetime;
+       this.scale = min((1 - this.alpha)*this.healer_lifetime*4,1)*this.healer_radius;
 }
 
 void healer_setup(entity e)
index 7ed9c55..fc46303 100644 (file)
@@ -94,12 +94,12 @@ spawnfunc(func_snow)
 #elif defined(CSQC)
 void Draw_Rain(entity this)
 {
-    te_particlerain(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
+    te_particlerain(this.origin + this.mins, this.origin + this.maxs, this.velocity, floor(this.count * drawframetime + random()), this.glow_color);
 }
 
 void Draw_Snow(entity this)
 {
-    te_particlesnow(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
+    te_particlesnow(this.origin + this.mins, this.origin + this.maxs, this.velocity, floor(this.count * drawframetime + random()), this.glow_color);
 }
 
 NET_HANDLE(ENT_CLIENT_RAINSNOW, bool isnew)
index 11b5807..bcd6f28 100644 (file)
@@ -268,52 +268,52 @@ class(Laser) .float modelscale; // scaling factor of the dlight
 
 void Draw_Laser(entity this)
 {
-       if(!self.state)
+       if(!this.state)
                return;
-       InterpolateOrigin_Do(self);
-       if(self.count & 0x80)
+       InterpolateOrigin_Do(this);
+       if(this.count & 0x80)
        {
-               if(self.count & 0x10)
+               if(this.count & 0x10)
                {
-                       trace_endpos = self.velocity;
+                       trace_endpos = this.velocity;
                        trace_dphitq3surfaceflags = 0;
                }
                else
-                       traceline(self.origin, self.velocity, 0, self);
+                       traceline(this.origin, this.velocity, 0, this);
        }
        else
        {
-               if(self.count & 0x10)
+               if(this.count & 0x10)
                {
-                       makevectors(self.angles);
-                       trace_endpos = self.origin + v_forward * 1048576;
+                       makevectors(this.angles);
+                       trace_endpos = this.origin + v_forward * 1048576;
                        trace_dphitq3surfaceflags = Q3SURFACEFLAG_SKY;
                }
                else
                {
-                       makevectors(self.angles);
-                       traceline(self.origin, self.origin + v_forward * 32768, 0, self);
+                       makevectors(this.angles);
+                       traceline(this.origin, this.origin + v_forward * 32768, 0, this);
                        if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
-                               trace_endpos = self.origin + v_forward * 1048576;
+                               trace_endpos = this.origin + v_forward * 1048576;
                }
        }
-       if(self.scale != 0)
+       if(this.scale != 0)
        {
-               if(self.alpha)
+               if(this.alpha)
                {
-                       Draw_CylindricLine(self.origin, trace_endpos, self.scale, "particles/laserbeam", 0, time * 3, self.colormod, self.alpha, DRAWFLAG_NORMAL, view_origin);
+                       Draw_CylindricLine(this.origin, trace_endpos, this.scale, "particles/laserbeam", 0, time * 3, this.colormod, this.alpha, DRAWFLAG_NORMAL, view_origin);
                }
                else
                {
-                       Draw_CylindricLine(self.origin, trace_endpos, self.scale, "particles/laserbeam", 0, time * 3, self.colormod, 0.5, DRAWFLAG_ADDITIVE, view_origin);
+                       Draw_CylindricLine(this.origin, trace_endpos, this.scale, "particles/laserbeam", 0, time * 3, this.colormod, 0.5, DRAWFLAG_ADDITIVE, view_origin);
                }
        }
        if (!(trace_dphitq3surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT)))
        {
-               if(self.cnt >= 0)
-                       __pointparticles(self.cnt, trace_endpos, trace_plane_normal, drawframetime * 1000);
-               if(self.colormod != '0 0 0' && self.modelscale != 0)
-                       adddynamiclight(trace_endpos + trace_plane_normal * 1, self.modelscale, self.colormod * 5);
+               if(this.cnt >= 0)
+                       __pointparticles(this.cnt, trace_endpos, trace_plane_normal, drawframetime * 1000);
+               if(this.colormod != '0 0 0' && this.modelscale != 0)
+                       adddynamiclight(trace_endpos + trace_plane_normal * 1, this.modelscale, this.colormod * 5);
        }
 }
 
index d782160..5633645 100644 (file)
@@ -292,32 +292,32 @@ void SUB_UseTargets()
 }
 
 #ifdef CSQC
-void trigger_touch_generic(void() touchfunc)
-{SELFPARAM();
+void trigger_touch_generic(entity this, void() touchfunc)
+{
        entity e;
-       for(e = findradius((self.absmin + self.absmax) * 0.5, vlen(self.absmax - self.absmin) * 0.5 + 1); e; e = e.chain)
+       for(e = findradius((this.absmin + this.absmax) * 0.5, vlen(this.absmax - this.absmin) * 0.5 + 1); e; e = e.chain)
        if(e.isplayermodel || e.classname == "csqcprojectile")
        {
                vector emin = e.absmin, emax = e.absmax;
-               if(self.solid == SOLID_BSP)
+               if(this.solid == SOLID_BSP)
                {
                        emin -= '1 1 1';
                        emax += '1 1 1';
                }
-               if(boxesoverlap(emin, emax, self.absmin, self.absmax)) // quick
-               if(WarpZoneLib_BoxTouchesBrush(emin, emax, self, e)) // accurate
+               if(boxesoverlap(emin, emax, this.absmin, this.absmax)) // quick
+               if(WarpZoneLib_BoxTouchesBrush(emin, emax, this, e)) // accurate
                {
                        other = e;
-                       touchfunc();
+                       WITH(entity, self, this, touchfunc());
                }
        }
 }
 void trigger_draw_generic(entity this)
 {
-       float dt = time - self.move_time;
-       self.move_time = time;
+       float dt = time - this.move_time;
+       this.move_time = time;
        if(dt <= 0) { return; }
 
-       if(self.trigger_touch) { trigger_touch_generic(self.trigger_touch); }
+       if(this.trigger_touch) { trigger_touch_generic(this, this.trigger_touch); }
 }
 #endif
index 99f0139..2f9107d 100644 (file)
@@ -28,28 +28,28 @@ void turret_draw(entity this)
 {
        float dt;
 
-       dt = time - self.move_time;
-       self.move_time = time;
+       dt = time - this.move_time;
+       this.move_time = time;
        if(dt <= 0)
                return;
 
-       self.tur_head.angles += dt * self.tur_head.move_avelocity;
+       this.tur_head.angles += dt * this.tur_head.move_avelocity;
 
-       if (self.health < 127)
+       if (this.health < 127)
        {
                dt = random();
 
                if(dt < 0.03)
-                       te_spark(self.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
+                       te_spark(this.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
        }
 
-       if(self.health < 85)
+       if(this.health < 85)
        if(dt < 0.01)
-               pointparticles(EFFECT_SMOKE_LARGE, (self.origin + (randomvec() * 80)), '0 0 0', 1);
+               pointparticles(EFFECT_SMOKE_LARGE, (this.origin + (randomvec() * 80)), '0 0 0', 1);
 
-       if(self.health < 32)
+       if(this.health < 32)
        if(dt < 0.015)
-               pointparticles(EFFECT_SMOKE_SMALL, (self.origin + (randomvec() * 80)), '0 0 0', 1);
+               pointparticles(EFFECT_SMOKE_SMALL, (this.origin + (randomvec() * 80)), '0 0 0', 1);
 
 }
 
@@ -245,38 +245,36 @@ void turret_construct()
 }
 
 entity turret_gibtoss(string _model, vector _from, vector _to, vector _cmod, float _explode);
-void turret_gibboom();
+void turret_gibboom(entity this);
 void turret_gib_draw(entity this)
 {
-       Movetype_Physics_MatchTicrate(self, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
+       Movetype_Physics_MatchTicrate(this, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
 
-       self.drawmask = MASK_NORMAL;
+       this.drawmask = MASK_NORMAL;
 
-       if(self.cnt)
+       if(this.cnt)
        {
-               if(time >= self.nextthink)
+               if(time >= this.nextthink)
                {
-                       turret_gibboom();
-                       remove(self);
+                       turret_gibboom(this);
+                       remove(this);
                }
        }
        else
        {
-               self.alpha = bound(0, self.nextthink - time, 1);
-               if(self.alpha < ALPHA_MIN_VISIBLE)
-                       remove(self);
+               this.alpha = bound(0, this.nextthink - time, 1);
+               if(this.alpha < ALPHA_MIN_VISIBLE)
+                       remove(this);
        }
 }
 
-void turret_gibboom()
-{SELFPARAM();
-       float i;
-
-       sound (self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
-       pointparticles(EFFECT_ROCKET_EXPLODE, self.origin, '0 0 0', 1);
+void turret_gibboom(entity this)
+{
+       sound (this, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
+       pointparticles(EFFECT_ROCKET_EXPLODE, this.origin, '0 0 0', 1);
 
-       for (i = 1; i < 5; i = i + 1)
-               turret_gibtoss(strcat("models/turrets/head-gib", ftos(i), ".md3"), self.origin + '0 0 2', self.velocity + randomvec() * 700, '0 0 0', false);
+       for (int j = 1; j < 5; j = j + 1)
+               turret_gibtoss(strcat("models/turrets/head-gib", ftos(j), ".md3"), this.origin + '0 0 2', this.velocity + randomvec() * 700, '0 0 0', false);
 }
 
 entity turret_gibtoss(string _model, vector _from, vector _to, vector _cmod, float _explode)
index e81666f..09c4155 100644 (file)
@@ -241,19 +241,19 @@ void ewheel_draw(entity this)
 {
     float dt;
 
-    dt = time - self.move_time;
-    self.move_time = time;
+    dt = time - this.move_time;
+    this.move_time = time;
     if(dt <= 0)
         return;
 
-    fixedmakevectors(self.angles);
-    setorigin(self, self.origin + self.velocity * dt);
-    self.tur_head.angles += dt * self.tur_head.move_avelocity;
-    self.angles_y = self.move_angles_y;
+    fixedmakevectors(this.angles);
+    setorigin(this, this.origin + this.velocity * dt);
+    this.tur_head.angles += dt * this.tur_head.move_avelocity;
+    this.angles_y = this.move_angles_y;
 
-    if (self.health < 127)
+    if (this.health < 127)
     if(random() < 0.05)
-        te_spark(self.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
+        te_spark(this.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
 }
 
         METHOD(EWheel, tr_setup, void(EWheel this, entity it))
index 339e997..f15a6d0 100644 (file)
@@ -636,20 +636,20 @@ void walker_draw(entity this)
 {
     float dt;
 
-    dt = time - self.move_time;
-    self.move_time = time;
+    dt = time - this.move_time;
+    this.move_time = time;
     if(dt <= 0)
         return;
 
-    fixedmakevectors(self.angles);
+    fixedmakevectors(this.angles);
     movelib_groundalign4point(300, 100, 0.25, 45);
-    setorigin(self, self.origin + self.velocity * dt);
-    self.tur_head.angles += dt * self.tur_head.move_avelocity;
-    self.angles_y = self.move_angles_y;
+    setorigin(this, this.origin + this.velocity * dt);
+    this.tur_head.angles += dt * this.tur_head.move_avelocity;
+    this.angles_y = this.move_angles_y;
 
-    if (self.health < 127)
+    if (this.health < 127)
     if(random() < 0.15)
-        te_spark(self.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
+        te_spark(this.origin + '0 0 40', randomvec() * 256 + '0 0 256', 16);
 }
 
         METHOD(WalkerTurret, tr_setup, void(WalkerTurret this, entity it))
index 0d0dfb0..1114c11 100644 (file)
@@ -111,14 +111,14 @@ void bumble_raygun_draw(entity this)
     vector _dir;
     vector _vtmp1, _vtmp2;
 
-    _len = vlen(self.origin - self.move_origin);
-    _dir = normalize(self.move_origin - self.origin);
+    _len = vlen(this.origin - this.move_origin);
+    _dir = normalize(this.move_origin - this.origin);
 
-    if(self.bumble_raygun_nextdraw < time)
+    if(this.bumble_raygun_nextdraw < time)
     {
-        boxparticles(particleeffectnum(Effects_from(self.traileffect)), self, self.origin, self.origin + _dir * -64, _dir * -_len , _dir * -_len, 1, PARTICLES_USEALPHA);
-        boxparticles(self.lip, self, self.move_origin, self.move_origin + _dir * -64, _dir * -200 , _dir * -200, 1, PARTICLES_USEALPHA);
-        self.bumble_raygun_nextdraw = time + 0.1;
+        boxparticles(particleeffectnum(Effects_from(this.traileffect)), this, this.origin, this.origin + _dir * -64, _dir * -_len , _dir * -_len, 1, PARTICLES_USEALPHA);
+        boxparticles(this.lip, this, this.move_origin, this.move_origin + _dir * -64, _dir * -200 , _dir * -200, 1, PARTICLES_USEALPHA);
+        this.bumble_raygun_nextdraw = time + 0.1;
     }
 
     float i, df, sz, al;
@@ -127,19 +127,19 @@ void bumble_raygun_draw(entity this)
         df = DRAWFLAG_NORMAL; //((random() < 0.5) ? DRAWFLAG_ADDITIVE : DRAWFLAG_SCREEN);
         sz = 5 + random() * 5;
         al = 0.25 + random() * 0.5;
-        _vtmp1 = self.origin + _dir * _len * (0.25 + i);
-        _vtmp1 += (randomvec() * (_len * 0.2) * (frametime * 2));       //self.raygun_l1;
-        Draw_CylindricLine(self.origin, _vtmp1, sz, "gfx/colors/white.tga", 1, 1, self.colormod, al, df, view_origin);
+        _vtmp1 = this.origin + _dir * _len * (0.25 + i);
+        _vtmp1 += (randomvec() * (_len * 0.2) * (frametime * 2));       //this.raygun_l1;
+        Draw_CylindricLine(this.origin, _vtmp1, sz, "gfx/colors/white.tga", 1, 1, this.colormod, al, df, view_origin);
 
-        _vtmp2 = self.origin + _dir * _len * (0.5 + i);
-        _vtmp2 += (randomvec() * (_len * 0.2) * (frametime * 5));       //self.raygun_l2;
-        Draw_CylindricLine(_vtmp1, _vtmp2, sz, "gfx/colors/white.tga", 1, 1, self.colormod, al, df, view_origin);
+        _vtmp2 = this.origin + _dir * _len * (0.5 + i);
+        _vtmp2 += (randomvec() * (_len * 0.2) * (frametime * 5));       //this.raygun_l2;
+        Draw_CylindricLine(_vtmp1, _vtmp2, sz, "gfx/colors/white.tga", 1, 1, this.colormod, al, df, view_origin);
 
-        _vtmp1 = self.origin + _dir * _len * (0.75 + i);
-        _vtmp1 += randomvec() * (_len * 0.2) * (frametime * 10);     //self.raygun_l3;
-        Draw_CylindricLine(_vtmp2, _vtmp1, sz, "gfx/colors/white.tga", 1, 1, self.colormod, al, df, view_origin);
+        _vtmp1 = this.origin + _dir * _len * (0.75 + i);
+        _vtmp1 += randomvec() * (_len * 0.2) * (frametime * 10);     //this.raygun_l3;
+        Draw_CylindricLine(_vtmp2, _vtmp1, sz, "gfx/colors/white.tga", 1, 1, this.colormod, al, df, view_origin);
 
-        Draw_CylindricLine(_vtmp1, self.move_origin +  randomvec() * 32, sz, "gfx/colors/white.tga", 1, 1, self.colormod, al, df, view_origin);
+        Draw_CylindricLine(_vtmp1, this.move_origin +  randomvec() * 32, sz, "gfx/colors/white.tga", 1, 1, this.colormod, al, df, view_origin);
     }
 }
 
index 202be52..92c6476 100644 (file)
@@ -267,18 +267,18 @@ void raptor_flare_think()
 
 void RaptorCBShellfragDraw(entity this)
 {
-    if(wasfreed(self))
+    if(wasfreed(this))
         return;
 
-    Movetype_Physics_MatchTicrate(self, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
-    self.move_avelocity += randomvec() * 15;
-    self.renderflags = 0;
+    Movetype_Physics_MatchTicrate(this, autocvar_cl_gibs_ticrate, autocvar_cl_gibs_sloppy);
+    this.move_avelocity += randomvec() * 15;
+    this.renderflags = 0;
 
-    if(self.cnt < time)
-        self.alpha = bound(0, self.nextthink - time, 1);
+    if(this.cnt < time)
+        this.alpha = bound(0, this.nextthink - time, 1);
 
-    if(self.alpha < ALPHA_MIN_VISIBLE)
-        remove(self);
+    if(this.alpha < ALPHA_MIN_VISIBLE)
+        remove(this);
 }
 
 void RaptorCBShellfragToss(vector _org, vector _vel, vector _ang)
index e7f31dd..2a12c45 100644 (file)
@@ -852,13 +852,13 @@ void Reset_ArcBeam()
 
 void Draw_ArcBeam(entity this)
 {
-       float dt = time - self.move_time;
-       self.move_time = time;
+       float dt = time - this.move_time;
+       this.move_time = time;
        if(dt <= 0) { return; }
 
-       if(!self.beam_usevieworigin)
+       if(!this.beam_usevieworigin)
        {
-               InterpolateOrigin_Do(self);
+               InterpolateOrigin_Do(this);
        }
 
        // origin = beam starting origin
@@ -867,10 +867,10 @@ void Draw_ArcBeam(entity this)
 
        vector start_pos;
        vector wantdir; //= view_forward;
-       vector beamdir; //= self.beam_dir;
+       vector beamdir; //= this.beam_dir;
 
        float segments;
-       if(self.beam_usevieworigin)
+       if(this.beam_usevieworigin)
        {
                // WEAPONTODO:
                // Currently we have to replicate nearly the same method of figuring
@@ -885,17 +885,17 @@ void Draw_ArcBeam(entity this)
                vector up = v_up;
 
                // decide upon start position
-               if(self.beam_usevieworigin == 2)
+               if(this.beam_usevieworigin == 2)
                        { start_pos = warpzone_save_view_origin; }
                else
-                       { start_pos = self.origin; }
+                       { start_pos = this.origin; }
 
                // trace forward with an estimation
                WarpZone_TraceLine(
                        start_pos,
-                       start_pos + forward * self.beam_range,
+                       start_pos + forward * this.beam_range,
                        MOVE_NOMONSTERS,
-                       self
+                       this
                );
 
                // untransform in case our trace went through a warpzone
@@ -907,77 +907,77 @@ void Draw_ArcBeam(entity this)
 
                // move shot origin to the actual gun muzzle origin
                vector origin_offset =
-                         right * -self.beam_shotorigin.y
-                       + up * self.beam_shotorigin.z;
+                         right * -this.beam_shotorigin.y
+                       + up * this.beam_shotorigin.z;
 
                start_pos = start_pos + origin_offset;
 
                // Move it also forward, but only as far as possible without hitting anything. Don't poke into walls!
-               traceline(start_pos, start_pos + forward * self.beam_shotorigin.x, MOVE_NORMAL, self);
+               traceline(start_pos, start_pos + forward * this.beam_shotorigin.x, MOVE_NORMAL, this);
                start_pos = trace_endpos;
 
                // calculate the aim direction now
                wantdir = normalize(end_pos - start_pos);
 
-               if(!self.beam_initialized)
+               if(!this.beam_initialized)
                {
-                       self.beam_dir = wantdir;
-                       self.beam_initialized = true;
+                       this.beam_dir = wantdir;
+                       this.beam_initialized = true;
                }
 
-               if(self.beam_dir != wantdir)
+               if(this.beam_dir != wantdir)
                {
                        // calculate how much we're going to move the end of the beam to the want position
                        // WEAPONTODO (server and client):
                        // blendfactor never actually becomes 0 in this situation, which is a problem
-                       // regarding precision... this means that self.beam_dir and w_shotdir approach
+                       // regarding precision... this means that this.beam_dir and w_shotdir approach
                        // eachother, however they never actually become the same value with this method.
                        // Perhaps we should do some form of rounding/snapping?
-                       float angle = vlen(wantdir - self.beam_dir) * RAD2DEG;
-                       if(angle && (angle > self.beam_maxangle))
+                       float angle = vlen(wantdir - this.beam_dir) * RAD2DEG;
+                       if(angle && (angle > this.beam_maxangle))
                        {
                                // if the angle is greater than maxangle, force the blendfactor to make this the maximum factor
                                float blendfactor = bound(
                                        0,
-                                       (1 - (self.beam_returnspeed * frametime)),
-                                       min(self.beam_maxangle / angle, 1)
+                                       (1 - (this.beam_returnspeed * frametime)),
+                                       min(this.beam_maxangle / angle, 1)
                                );
-                               self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
+                               this.beam_dir = normalize((wantdir * (1 - blendfactor)) + (this.beam_dir * blendfactor));
                        }
                        else
                        {
                                // the radius is not too far yet, no worries :D
                                float blendfactor = bound(
                                        0,
-                                       (1 - (self.beam_returnspeed * frametime)),
+                                       (1 - (this.beam_returnspeed * frametime)),
                                        1
                                );
-                               self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
+                               this.beam_dir = normalize((wantdir * (1 - blendfactor)) + (this.beam_dir * blendfactor));
                        }
 
                        // calculate how many segments are needed
                        float max_allowed_segments;
 
-                       if(self.beam_distancepersegment)
+                       if(this.beam_distancepersegment)
                        {
                                max_allowed_segments = min(
                                        ARC_MAX_SEGMENTS,
-                                       1 + (vlen(wantdir / self.beam_distancepersegment))
+                                       1 + (vlen(wantdir / this.beam_distancepersegment))
                                );
                        }
                        else { max_allowed_segments = ARC_MAX_SEGMENTS; }
 
-                       if(self.beam_degreespersegment)
+                       if(this.beam_degreespersegment)
                        {
                                segments = bound(
                                        1,
                                        (
                                                min(
                                                        angle,
-                                                       self.beam_maxangle
+                                                       this.beam_maxangle
                                                )
                                                /
-                                               self.beam_degreespersegment
+                                               this.beam_degreespersegment
                                        ),
                                        max_allowed_segments
                                );
@@ -987,17 +987,17 @@ void Draw_ArcBeam(entity this)
                else { segments = 1; }
 
                // set the beam direction which the rest of the code will refer to
-               beamdir = self.beam_dir;
+               beamdir = this.beam_dir;
 
-               // finally, set self.angles to the proper direction so that muzzle attachment points in proper direction
-               self.angles = fixedvectoangles2(forward, up); // TODO(Samual): is this == warpzone_save_view_angles?
+               // finally, set this.angles to the proper direction so that muzzle attachment points in proper direction
+               this.angles = fixedvectoangles2(forward, up); // TODO(Samual): is this == warpzone_save_view_angles?
        }
        else
        {
                // set the values from the provided info from the networked entity
-               start_pos = self.origin;
-               wantdir = self.v_angle;
-               beamdir = self.angles;
+               start_pos = this.origin;
+               wantdir = this.v_angle;
+               beamdir = this.angles;
 
                if(beamdir != wantdir)
                {
@@ -1006,26 +1006,26 @@ void Draw_ArcBeam(entity this)
                        // calculate how many segments are needed
                        float max_allowed_segments;
 
-                       if(self.beam_distancepersegment)
+                       if(this.beam_distancepersegment)
                        {
                                max_allowed_segments = min(
                                        ARC_MAX_SEGMENTS,
-                                       1 + (vlen(wantdir / self.beam_distancepersegment))
+                                       1 + (vlen(wantdir / this.beam_distancepersegment))
                                );
                        }
                        else { max_allowed_segments = ARC_MAX_SEGMENTS; }
 
-                       if(self.beam_degreespersegment)
+                       if(this.beam_degreespersegment)
                        {
                                segments = bound(
                                        1,
                                        (
                                                min(
                                                        angle,
-                                                       self.beam_maxangle
+                                                       this.beam_maxangle
                                                )
                                                /
-                                               self.beam_degreespersegment
+                                               this.beam_degreespersegment
                                        ),
                                        max_allowed_segments
                                );
@@ -1035,13 +1035,13 @@ void Draw_ArcBeam(entity this)
                else { segments = 1; }
        }
 
-       setorigin(self, start_pos);
-       self.beam_muzzleentity.angles_z = random() * 360; // WEAPONTODO: use avelocity instead?
+       setorigin(this, start_pos);
+       this.beam_muzzleentity.angles_z = random() * 360; // WEAPONTODO: use avelocity instead?
 
-       vector beam_endpos = (start_pos + (beamdir * self.beam_range));
-       vector beam_controlpoint = start_pos + wantdir * (self.beam_range * (1 - self.beam_tightness));
+       vector beam_endpos = (start_pos + (beamdir * this.beam_range));
+       vector beam_controlpoint = start_pos + wantdir * (this.beam_range * (1 - this.beam_tightness));
 
-       Draw_ArcBeam_callback_entity = self;
+       Draw_ArcBeam_callback_entity = this;
        Draw_ArcBeam_callback_last_thickness = 0;
        Draw_ArcBeam_callback_last_top = start_pos;
        Draw_ArcBeam_callback_last_bottom = start_pos;
@@ -1089,49 +1089,49 @@ void Draw_ArcBeam(entity this)
        }
 
        // visual effects for startpoint and endpoint
-       if(self.beam_hiteffect)
+       if(this.beam_hiteffect)
        {
                // FIXME we really should do this on the server so it actually
                // matches gameplay. What this client side stuff is doing is no
                // more than guesswork.
                if((trace_ent || trace_fraction < 1) && !(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT))
                pointparticles(
-                       self.beam_hiteffect,
+                       this.beam_hiteffect,
                        last_origin,
                        beamdir * -1,
                        frametime * 2
                );
        }
-       if(self.beam_hitlight[0])
+       if(this.beam_hitlight[0])
        {
                adddynamiclight(
                        last_origin,
-                       self.beam_hitlight[0],
+                       this.beam_hitlight[0],
                        vec3(
-                               self.beam_hitlight[1],
-                               self.beam_hitlight[2],
-                               self.beam_hitlight[3]
+                               this.beam_hitlight[1],
+                               this.beam_hitlight[2],
+                               this.beam_hitlight[3]
                        )
                );
        }
-       if(self.beam_muzzleeffect)
+       if(this.beam_muzzleeffect)
        {
                pointparticles(
-                       self.beam_muzzleeffect,
+                       this.beam_muzzleeffect,
                        original_start_pos + wantdir * 20,
                        wantdir * 1000,
                        frametime * 0.1
                );
        }
-       if(self.beam_muzzlelight[0])
+       if(this.beam_muzzlelight[0])
        {
                adddynamiclight(
                        original_start_pos + wantdir * 20,
-                       self.beam_muzzlelight[0],
+                       this.beam_muzzlelight[0],
                        vec3(
-                               self.beam_muzzlelight[1],
-                               self.beam_muzzlelight[2],
-                               self.beam_muzzlelight[3]
+                               this.beam_muzzlelight[1],
+                               this.beam_muzzlelight[2],
+                               this.beam_muzzlelight[3]
                        )
                );
        }
index f0ae19e..e2884ff 100644 (file)
@@ -355,18 +355,18 @@ void Draw_GrapplingHook(entity this)
        vector vs;
        float intensity, offset;
 
-       if(self.teleport_time)
-       if(time > self.teleport_time)
+       if(this.teleport_time)
+       if(time > this.teleport_time)
        {
-               sound (self, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM); // safeguard
-               self.teleport_time = 0;
+               sound (this, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM); // safeguard
+               this.teleport_time = 0;
        }
 
        InterpolateOrigin_Do(this);
 
        int s = W_GetGunAlignment(world);
 
-       switch(self.HookType)
+       switch(this.HookType)
        {
                default:
                case NET_ENT_CLIENT_HOOK:
@@ -377,20 +377,20 @@ void Draw_GrapplingHook(entity this)
                        break;
        }
 
-       if((self.owner.sv_entnum == player_localentnum - 1) && autocvar_chase_active <= 0)
+       if((this.owner.sv_entnum == player_localentnum - 1) && autocvar_chase_active <= 0)
        {
-               switch(self.HookType)
+               switch(this.HookType)
                {
                        default:
                        case NET_ENT_CLIENT_HOOK:
                                a = view_origin + view_forward * vs.x + view_right * -vs.y + view_up * vs.z;
-                               b = self.origin;
+                               b = this.origin;
                                break;
                        case NET_ENT_CLIENT_ARC_BEAM:
-                               if(self.HookRange)
-                                       b = view_origin + view_forward * self.HookRange;
+                               if(this.HookRange)
+                                       b = view_origin + view_forward * this.HookRange;
                                else
-                                       b = view_origin + view_forward * vlen(self.velocity - self.origin); // honor original length of beam!
+                                       b = view_origin + view_forward * vlen(this.velocity - this.origin); // honor original length of beam!
                                WarpZone_TraceLine(view_origin, b, MOVE_NORMAL, world);
                                b = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos);
                                a = view_origin + view_forward * vs.x + view_right * -vs.y + view_up * vs.z;
@@ -399,23 +399,23 @@ void Draw_GrapplingHook(entity this)
        }
        else
        {
-               switch(self.HookType)
+               switch(this.HookType)
                {
                        default:
                        case NET_ENT_CLIENT_HOOK:
-                               a = self.velocity;
-                               b = self.origin;
+                               a = this.velocity;
+                               b = this.origin;
                                break;
                        case NET_ENT_CLIENT_ARC_BEAM:
-                               a = self.origin;
-                               b = self.velocity;
+                               a = this.origin;
+                               b = this.velocity;
                                break;
                }
        }
 
-       t = entcs_GetTeamColor(self.owner.sv_entnum);
+       t = entcs_GetTeamColor(this.owner.sv_entnum);
 
-       switch(self.HookType)
+       switch(this.HookType)
        {
                default:
                case NET_ENT_CLIENT_HOOK:
@@ -427,12 +427,12 @@ void Draw_GrapplingHook(entity this)
                                case NUM_TEAM_2: tex = "particles/hook_blue"; rgb = '0.3 0.3 1'; break;
                                case NUM_TEAM_3: tex = "particles/hook_yellow"; rgb = '1 1 0.3'; break;
                                case NUM_TEAM_4: tex = "particles/hook_pink"; rgb = '1 0.3 1'; break;
-                               default: tex = "particles/hook_white"; rgb = entcs_GetColor(self.sv_entnum - 1); break;
+                               default: tex = "particles/hook_white"; rgb = entcs_GetColor(this.sv_entnum - 1); break;
                        }
                        break;
                case NET_ENT_CLIENT_ARC_BEAM: // todo
-                       intensity = bound(0.2, 1 + Noise_Pink(self, frametime) * 1 + Noise_Burst(self, frametime, 0.03) * 0.3, 2);
-                       offset = Noise_Brown(self, frametime) * 10;
+                       intensity = bound(0.2, 1 + Noise_Pink(this, frametime) * 1 + Noise_Burst(this, frametime, 0.03) * 0.3, 2);
+                       offset = Noise_Brown(this, frametime) * 10;
                        tex = "particles/lgbeam";
                        rgb = '1 1 1';
                        break;
@@ -442,32 +442,32 @@ void Draw_GrapplingHook(entity this)
        Draw_GrapplingHook_trace_callback_rnd = offset;
        Draw_GrapplingHook_trace_callback_rgb = rgb;
        Draw_GrapplingHook_trace_callback_a = intensity;
-       WarpZone_TraceBox_ThroughZone(a, '0 0 0', '0 0 0', b, ((self.HookType == NET_ENT_CLIENT_HOOK) ? MOVE_NOTHING : MOVE_NORMAL), world, world, Draw_GrapplingHook_trace_callback);
+       WarpZone_TraceBox_ThroughZone(a, '0 0 0', '0 0 0', b, ((this.HookType == NET_ENT_CLIENT_HOOK) ? MOVE_NOTHING : MOVE_NORMAL), world, world, Draw_GrapplingHook_trace_callback);
        Draw_GrapplingHook_trace_callback_tex = string_null;
 
        atrans = WarpZone_TransformOrigin(WarpZone_trace_transform, a);
 
-       switch(self.HookType)
+       switch(this.HookType)
        {
                default:
                case NET_ENT_CLIENT_HOOK:
                        if(vlen(trace_endpos - atrans) > 0.5)
                        {
-                               setorigin(self, trace_endpos); // hook endpoint!
-                               self.angles = vectoangles(trace_endpos - atrans);
-                               self.drawmask = MASK_NORMAL;
+                               setorigin(this, trace_endpos); // hook endpoint!
+                               this.angles = vectoangles(trace_endpos - atrans);
+                               this.drawmask = MASK_NORMAL;
                        }
                        else
                        {
-                               self.drawmask = 0;
+                               this.drawmask = 0;
                        }
                        break;
                case NET_ENT_CLIENT_ARC_BEAM:
-                       setorigin(self, a); // beam origin!
+                       setorigin(this, a); // beam origin!
                        break;
        }
 
-       switch(self.HookType)
+       switch(this.HookType)
        {
                default:
                case NET_ENT_CLIENT_HOOK:
index 645955f..46cb78e 100644 (file)
@@ -734,24 +734,24 @@ const float SW_DISTTOMIN = 200;
 void Draw_Shockwave(entity this)
 {
        // fading/removal control
-       float a = bound(0, (SW_MAXALPHA - ((time - self.sw_time) / SW_FADETIME)), SW_MAXALPHA);
-       if(a < ALPHA_MIN_VISIBLE) { remove(self); }
+       float a = bound(0, (SW_MAXALPHA - ((time - this.sw_time) / SW_FADETIME)), SW_MAXALPHA);
+       if(a < ALPHA_MIN_VISIBLE) { remove(this); }
 
        // WEAPONTODO: save this only once when creating the entity
-       vector sw_color = entcs_GetColor(self.sv_entnum - 1); // GetTeamRGB(entcs_GetTeam(self.sv_entnum));
+       vector sw_color = entcs_GetColor(this.sv_entnum - 1); // GetTeamRGB(entcs_GetTeam(this.sv_entnum));
 
        // WEAPONTODO: trace to find what we actually hit
-       vector endpos = (self.sw_shotorg + (self.sw_shotdir * self.sw_distance));
+       vector endpos = (this.sw_shotorg + (this.sw_shotdir * this.sw_distance));
 
-       vectorvectors(self.sw_shotdir);
+       vectorvectors(this.sw_shotdir);
        vector right = v_right; // save this for when we do makevectors later
        vector up = v_up; // save this for when we do makevectors later
 
        // WEAPONTODO: combine and simplify these calculations
-       vector min_end = ((self.sw_shotorg + (self.sw_shotdir * SW_DISTTOMIN)) + (up * self.sw_spread_min));
-       vector max_end = (endpos + (up * self.sw_spread_max));
-       float spread_to_min = vlen(normalize(min_end - self.sw_shotorg) - self.sw_shotdir);
-       float spread_to_max = vlen(normalize(max_end - min_end) - self.sw_shotdir);
+       vector min_end = ((this.sw_shotorg + (this.sw_shotdir * SW_DISTTOMIN)) + (up * this.sw_spread_min));
+       vector max_end = (endpos + (up * this.sw_spread_max));
+       float spread_to_min = vlen(normalize(min_end - this.sw_shotorg) - this.sw_shotdir);
+       float spread_to_max = vlen(normalize(max_end - min_end) - this.sw_shotdir);
 
        vector first_min_end = '0 0 0', prev_min_end = '0 0 0', new_min_end = '0 0 0';
        vector first_max_end = '0 0 0', prev_max_end = '0 0 0', new_max_end = '0 0 0';
@@ -768,14 +768,14 @@ void Draw_Shockwave(entity this)
 
                // first do the spread_to_min effect
                deviation = angle * spread_to_min;
-               deviation = ((self.sw_shotdir + (right * deviation.y) + (up * deviation.z)));
+               deviation = ((this.sw_shotdir + (right * deviation.y) + (up * deviation.z)));
                new_min_dist = SW_DISTTOMIN;
-               new_min_end = (self.sw_shotorg + (deviation * new_min_dist));
-               //te_lightning2(world, new_min_end, self.sw_shotorg);
+               new_min_end = (this.sw_shotorg + (deviation * new_min_dist));
+               //te_lightning2(world, new_min_end, this.sw_shotorg);
 
                // then calculate spread_to_max effect
                deviation = angle * spread_to_max;
-               deviation = ((self.sw_shotdir + (right * deviation.y) + (up * deviation.z)));
+               deviation = ((this.sw_shotdir + (right * deviation.y) + (up * deviation.z)));
                new_max_dist = vlen(new_min_end - endpos);
                new_max_end = (new_min_end + (deviation * new_max_dist));
                //te_lightning2(world, new_end, prev_min_end);
@@ -793,7 +793,7 @@ void Draw_Shockwave(entity this)
                        R_BeginPolygon("", DRAWFLAG_NORMAL);
                        R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
                        R_PolygonVertex(new_min_end, '0 0 0', sw_color, a);
-                       R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
+                       R_PolygonVertex(this.sw_shotorg, '0 0 0', sw_color, a);
                        R_EndPolygon();
 
                        // draw from min spread radius to max spread radius
@@ -815,7 +815,7 @@ void Draw_Shockwave(entity this)
                        R_BeginPolygon("", DRAWFLAG_NORMAL);
                        R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
                        R_PolygonVertex(first_min_end, '0 0 0', sw_color, a);
-                       R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
+                       R_PolygonVertex(this.sw_shotorg, '0 0 0', sw_color, a);
                        R_EndPolygon();
 
                        // draw from min spread radius to max spread radius
index 118aa72..2ece549 100644 (file)
@@ -118,7 +118,7 @@ void VaporizerBeam_Draw(entity this)
        //      rgb = e.glowmod;
        rgb *= (1 + autocvar_cl_vaporizerbeam_colorboost);
 
-       float fail = (self.nextthink - time);
+       float fail = (this.nextthink - time);
 
        Draw_VaporizerBeam_trace_callback_tex = tex;
        Draw_VaporizerBeam_trace_callback_rnd = 0;
index 311a289..4fd1383 100644 (file)
 .vector ivforward1, ivforward2;
 .vector ivup1, ivup2;
 .float itime1, itime2;
-void InterpolateOrigin_Reset()
+void InterpolateOrigin_Reset(entity this)
 {
-       SELFPARAM();
-       self.iflags &= ~IFLAG_INTERNALMASK;
-       self.itime1 = self.itime2 = 0;
+       this.iflags &= ~IFLAG_INTERNALMASK;
+       this.itime1 = this.itime2 = 0;
 }
 void InterpolateOrigin_Note(entity this)
 {
index fb2f3d3..2f48280 100644 (file)
@@ -42,7 +42,7 @@ void InterpolateOrigin_Undo(entity this);
 void InterpolateOrigin_Note(entity this);
 
 // call this when the entity got teleported, before InterpolateOrigin_Note
-void InterpolateOrigin_Reset();
+void InterpolateOrigin_Reset(entity this);
 
 // call this BEFORE drawing
 void InterpolateOrigin_Do(entity this);