From: Mario <mario@smbclan.net>
Date: Thu, 19 May 2016 21:32:06 +0000 (+1000)
Subject: Clean up even more self uses
X-Git-Tag: xonotic-v0.8.2~919
X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=304b8158c9b753dd5674d055a1b91bd5472a66b8;p=xonotic%2Fxonotic-data.pk3dir.git

Clean up even more self uses
---

diff --git a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
index b0872497dc..dd844e77ea 100644
--- a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
+++ b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
@@ -125,8 +125,8 @@ void relocate_nexball(entity this)
 void DropOwner()
 {SELFPARAM();
 	entity ownr;
-	ownr = self.owner;
-	DropBall(self, ownr.origin, ownr.velocity);
+	ownr = this.owner;
+	DropBall(this, ownr.origin, ownr.velocity);
 	makevectors(ownr.v_angle.y * '0 1 0');
 	ownr.velocity += ('0 0 0.75' - v_forward) * 1000;
 	UNSET_ONGROUND(ownr);
@@ -227,56 +227,56 @@ void DropBall(entity ball, vector org, vector vel)
 void InitBall()
 {SELFPARAM();
 	if(gameover) return;
-	UNSET_ONGROUND(self);
-	self.movetype = MOVETYPE_BOUNCE;
-	if(self.classname == "nexball_basketball")
-		self.touch = basketball_touch;
-	else if(self.classname == "nexball_football")
-		self.touch = football_touch;
-	self.cnt = 0;
-	self.think = ResetBall;
-	self.nextthink = time + autocvar_g_nexball_delay_idle + 3;
-	self.teamtime = 0;
-	self.pusher = world;
-	self.team = false;
-	_sound(self, CH_TRIGGER, self.noise1, VOL_BASE, ATTEN_NORM);
-	WaypointSprite_Ping(self.waypointsprite_attachedforcarrier);
+	UNSET_ONGROUND(this);
+	this.movetype = MOVETYPE_BOUNCE;
+	if(this.classname == "nexball_basketball")
+		this.touch = basketball_touch;
+	else if(this.classname == "nexball_football")
+		this.touch = football_touch;
+	this.cnt = 0;
+	this.think = ResetBall;
+	this.nextthink = time + autocvar_g_nexball_delay_idle + 3;
+	this.teamtime = 0;
+	this.pusher = world;
+	this.team = false;
+	_sound(this, CH_TRIGGER, this.noise1, VOL_BASE, ATTEN_NORM);
+	WaypointSprite_Ping(this.waypointsprite_attachedforcarrier);
 	LogNB("init", world);
 }
 
 void ResetBall()
 {SELFPARAM();
-	if(self.cnt < 2)	// step 1
+	if(this.cnt < 2)	// step 1
 	{
-		if(time == self.teamtime)
-			bprint("The ", Team_ColoredFullName(self.team), " held the ball for too long.\n");
+		if(time == this.teamtime)
+			bprint("The ", Team_ColoredFullName(this.team), " held the ball for too long.\n");
 
-		self.touch = func_null;
-		self.movetype = MOVETYPE_NOCLIP;
-		self.velocity = '0 0 0'; // just in case?
-		if(!self.cnt)
+		this.touch = func_null;
+		this.movetype = MOVETYPE_NOCLIP;
+		this.velocity = '0 0 0'; // just in case?
+		if(!this.cnt)
 			LogNB("resetidle", world);
-		self.cnt = 2;
-		self.nextthink = time;
+		this.cnt = 2;
+		this.nextthink = time;
 	}
-	else if(self.cnt < 4)	  // step 2 and 3
+	else if(this.cnt < 4)	  // step 2 and 3
 	{
-//		dprint("Step ", ftos(self.cnt), ": Calculated velocity: ", vtos(self.spawnorigin - self.origin), ", time: ", ftos(time), "\n");
-		self.velocity = (self.spawnorigin - self.origin) * (self.cnt - 1); // 1 or 0.5 second movement
-		self.nextthink = time + 0.5;
-		self.cnt += 1;
+//		dprint("Step ", ftos(this.cnt), ": Calculated velocity: ", vtos(this.spawnorigin - this.origin), ", time: ", ftos(time), "\n");
+		this.velocity = (this.spawnorigin - this.origin) * (this.cnt - 1); // 1 or 0.5 second movement
+		this.nextthink = time + 0.5;
+		this.cnt += 1;
 	}
 	else	 // step 4
 	{
 //		dprint("Step 4: time: ", ftos(time), "\n");
-		if(vlen(self.origin - self.spawnorigin) > 10)  // should not happen anymore
+		if(vlen(this.origin - this.spawnorigin) > 10)  // should not happen anymore
 			LOG_TRACE("The ball moved too far away from its spawn origin.\nOffset: ",
-				   vtos(self.origin - self.spawnorigin), " Velocity: ", vtos(self.velocity), "\n");
-		self.velocity = '0 0 0';
-		setorigin(self, self.spawnorigin); // make sure it's positioned correctly anyway
-		self.movetype = MOVETYPE_NONE;
-		self.think = InitBall;
-		self.nextthink = max(time, game_starttime) + autocvar_g_nexball_delay_start;
+				   vtos(this.origin - this.spawnorigin), " Velocity: ", vtos(this.velocity), "\n");
+		this.velocity = '0 0 0';
+		setorigin(this, this.spawnorigin); // make sure it's positioned correctly anyway
+		this.movetype = MOVETYPE_NONE;
+		this.think = InitBall;
+		this.nextthink = max(time, game_starttime) + autocvar_g_nexball_delay_start;
 	}
 }
 
@@ -709,16 +709,16 @@ spawnfunc(ball_bound)
 void W_Nexball_Think()
 {SELFPARAM();
 	//dprint("W_Nexball_Think\n");
-	//vector new_dir = steerlib_arrive(self.enemy.origin, 2500);
-	vector new_dir = normalize(self.enemy.origin + '0 0 50' - self.origin);
-	vector old_dir = normalize(self.velocity);
-	float _speed = vlen(self.velocity);
+	//vector new_dir = steerlib_arrive(this.enemy.origin, 2500);
+	vector new_dir = normalize(this.enemy.origin + '0 0 50' - this.origin);
+	vector old_dir = normalize(this.velocity);
+	float _speed = vlen(this.velocity);
 	vector new_vel = normalize(old_dir + (new_dir * autocvar_g_nexball_safepass_turnrate)) * _speed;
 	//vector new_vel = (new_dir * autocvar_g_nexball_safepass_turnrate
 
-	self.velocity = new_vel;
+	this.velocity = new_vel;
 
-	self.nextthink = time;
+	this.nextthink = time;
 }
 
 void W_Nexball_Touch()
diff --git a/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc b/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc
index 6653f28ad3..726dd52d62 100644
--- a/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc
+++ b/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc
@@ -400,31 +400,31 @@ void ons_Link_CheckUpdate()
 	// TODO check if the two sides have moved (currently they won't move anyway)
 	float cc = 0, cc1 = 0, cc2 = 0;
 
-	if(self.goalentity.islinked || self.goalentity.iscaptured) { cc1 = (self.goalentity.team - 1) * 0x01; }
-	if(self.enemy.islinked || self.enemy.iscaptured) { cc2 = (self.enemy.team - 1) * 0x10; }
+	if(this.goalentity.islinked || this.goalentity.iscaptured) { cc1 = (this.goalentity.team - 1) * 0x01; }
+	if(this.enemy.islinked || this.enemy.iscaptured) { cc2 = (this.enemy.team - 1) * 0x10; }
 
 	cc = cc1 + cc2;
 
-	if(cc != self.clientcolors)
+	if(cc != this.clientcolors)
 	{
-		self.clientcolors = cc;
-		self.SendFlags |= 4;
+		this.clientcolors = cc;
+		this.SendFlags |= 4;
 	}
 
-	self.nextthink = time;
+	this.nextthink = time;
 }
 
 void ons_DelayedLinkSetup(entity this)
 {
-	self.goalentity = find(world, targetname, self.target);
-	self.enemy = find(world, targetname, self.target2);
-	if(!self.goalentity) { objerror("can not find target\n"); }
-	if(!self.enemy) { objerror("can not find target2\n"); }
+	this.goalentity = find(world, targetname, this.target);
+	this.enemy = find(world, targetname, this.target2);
+	if(!this.goalentity) { objerror("can not find target\n"); }
+	if(!this.enemy) { objerror("can not find target2\n"); }
 
-	LOG_DEBUG(strcat(etos(self.goalentity), " linked with ", etos(self.enemy), "\n"));
-	self.SendFlags |= 3;
-	self.think = ons_Link_CheckUpdate;
-	self.nextthink = time;
+	LOG_DEBUG(strcat(etos(this.goalentity), " linked with ", etos(this.enemy), "\n"));
+	this.SendFlags |= 3;
+	this.think = ons_Link_CheckUpdate;
+	this.nextthink = time;
 }
 
 
@@ -561,7 +561,7 @@ void ons_ControlPoint_Icon_Damage(entity this, entity inflictor, entity attacker
 
 void ons_ControlPoint_Icon_Think()
 {SELFPARAM();
-	self.nextthink = time + ONS_CP_THINKRATE;
+	this.nextthink = time + ONS_CP_THINKRATE;
 
 	if(autocvar_g_onslaught_cp_proxydecap)
 	{
@@ -569,9 +569,9 @@ void ons_ControlPoint_Icon_Think()
 		int _friendly_count = 0;
 
 		FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it), {
-			if(vdist(it.origin - self.origin, <, autocvar_g_onslaught_cp_proxydecap_distance))
+			if(vdist(it.origin - this.origin, <, autocvar_g_onslaught_cp_proxydecap_distance))
 			{
-				if(SAME_TEAM(it, self))
+				if(SAME_TEAM(it, this))
 					++_friendly_count;
 				else
 					++_enemy_count;
@@ -581,49 +581,49 @@ void ons_ControlPoint_Icon_Think()
 		_friendly_count = _friendly_count * (autocvar_g_onslaught_cp_proxydecap_dps * ONS_CP_THINKRATE);
 		_enemy_count = _enemy_count * (autocvar_g_onslaught_cp_proxydecap_dps * ONS_CP_THINKRATE);
 
-		self.health = bound(0, self.health + (_friendly_count - _enemy_count), self.max_health);
-		self.SendFlags |= CPSF_STATUS;
-		if(self.health <= 0)
+		this.health = bound(0, this.health + (_friendly_count - _enemy_count), this.max_health);
+		this.SendFlags |= CPSF_STATUS;
+		if(this.health <= 0)
 		{
-			ons_ControlPoint_Icon_Damage(self, self, self, 1, 0, self.origin, '0 0 0');
+			ons_ControlPoint_Icon_Damage(this, this, this, 1, 0, this.origin, '0 0 0');
 			return;
 		}
 	}
 
-	if (time > self.pain_finished + 5)
+	if (time > this.pain_finished + 5)
 	{
-		if(self.health < self.max_health)
+		if(this.health < this.max_health)
 		{
-			self.health = self.health + self.count;
-			if (self.health >= self.max_health)
-				self.health = self.max_health;
-			WaypointSprite_UpdateHealth(self.owner.sprite, self.health);
+			this.health = this.health + this.count;
+			if (this.health >= this.max_health)
+				this.health = this.max_health;
+			WaypointSprite_UpdateHealth(this.owner.sprite, this.health);
 		}
 	}
 
-	if(self.owner.islinked != self.owner.waslinked)
+	if(this.owner.islinked != this.owner.waslinked)
 	{
 		// unteam the spawnpoint if needed
-		int t = self.owner.team;
-		if(!self.owner.islinked)
-			self.owner.team = 0;
+		int t = this.owner.team;
+		if(!this.owner.islinked)
+			this.owner.team = 0;
 
-		SUB_UseTargets(self.owner, self, NULL);
+		SUB_UseTargets(this.owner, this, NULL);
 
-		self.owner.team = t;
+		this.owner.team = t;
 
-		self.owner.waslinked = self.owner.islinked;
+		this.owner.waslinked = this.owner.islinked;
 	}
 
 	// damaged fx
-	if(random() < 0.6 - self.health / self.max_health)
+	if(random() < 0.6 - this.health / this.max_health)
 	{
-		Send_Effect(EFFECT_ELECTRIC_SPARKS, self.origin + randompos('-10 -10 -20', '10 10 20'), '0 0 0', 1);
+		Send_Effect(EFFECT_ELECTRIC_SPARKS, this.origin + randompos('-10 -10 -20', '10 10 20'), '0 0 0', 1);
 
 		if(random() > 0.8)
-			sound(self, CH_PAIN, SND_ONS_SPARK1, VOL_BASE, ATTEN_NORM);
+			sound(this, CH_PAIN, SND_ONS_SPARK1, VOL_BASE, ATTEN_NORM);
 		else if (random() > 0.5)
-			sound(self, CH_PAIN, SND_ONS_SPARK2, VOL_BASE, ATTEN_NORM);
+			sound(this, CH_PAIN, SND_ONS_SPARK2, VOL_BASE, ATTEN_NORM);
 	}
 }
 
@@ -631,54 +631,54 @@ void ons_ControlPoint_Icon_BuildThink()
 {SELFPARAM();
 	int a;
 
-	self.nextthink = time + ONS_CP_THINKRATE;
+	this.nextthink = time + ONS_CP_THINKRATE;
 
 	// only do this if there is power
-	a = ons_ControlPoint_CanBeLinked(self.owner, self.owner.team);
+	a = ons_ControlPoint_CanBeLinked(this.owner, this.owner.team);
 	if(!a)
 		return;
 
-	self.health = self.health + self.count;
+	this.health = this.health + this.count;
 
-	self.SendFlags |= CPSF_STATUS;
+	this.SendFlags |= CPSF_STATUS;
 
-	if (self.health >= self.max_health)
+	if (this.health >= this.max_health)
 	{
-		self.health = self.max_health;
-		self.count = autocvar_g_onslaught_cp_regen * ONS_CP_THINKRATE; // slow repair rate from now on
-		self.think = ons_ControlPoint_Icon_Think;
-		sound(self, CH_TRIGGER, SND_ONS_CONTROLPOINT_BUILT, VOL_BASE, ATTEN_NORM);
-		self.owner.iscaptured = true;
-		self.solid = SOLID_BBOX;
+		this.health = this.max_health;
+		this.count = autocvar_g_onslaught_cp_regen * ONS_CP_THINKRATE; // slow repair rate from now on
+		this.think = ons_ControlPoint_Icon_Think;
+		sound(this, CH_TRIGGER, SND_ONS_CONTROLPOINT_BUILT, VOL_BASE, ATTEN_NORM);
+		this.owner.iscaptured = true;
+		this.solid = SOLID_BBOX;
 
-		Send_Effect(EFFECT_CAP(self.owner.team), self.owner.origin, '0 0 0', 1);
+		Send_Effect(EFFECT_CAP(this.owner.team), this.owner.origin, '0 0 0', 1);
 
-		WaypointSprite_UpdateMaxHealth(self.owner.sprite, self.max_health);
-		WaypointSprite_UpdateHealth(self.owner.sprite, self.health);
+		WaypointSprite_UpdateMaxHealth(this.owner.sprite, this.max_health);
+		WaypointSprite_UpdateHealth(this.owner.sprite, this.health);
 
-		if(IS_PLAYER(self.owner.ons_toucher))
+		if(IS_PLAYER(this.owner.ons_toucher))
 		{
-			Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ONSLAUGHT_CAPTURE, self.owner.ons_toucher.netname, self.owner.message);
-			Send_Notification(NOTIF_ALL_EXCEPT, self.owner.ons_toucher, MSG_CENTER, APP_TEAM_NUM(self.owner.ons_toucher.team, CENTER_ONS_CAPTURE), self.owner.message);
-			Send_Notification(NOTIF_ONE, self.owner.ons_toucher, MSG_CENTER, CENTER_ONS_CAPTURE, self.owner.message);
-			PlayerScore_Add(self.owner.ons_toucher, SP_ONS_CAPS, 1);
-			PlayerTeamScore_AddScore(self.owner.ons_toucher, 10);
+			Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ONSLAUGHT_CAPTURE, this.owner.ons_toucher.netname, this.owner.message);
+			Send_Notification(NOTIF_ALL_EXCEPT, this.owner.ons_toucher, MSG_CENTER, APP_TEAM_NUM(this.owner.ons_toucher.team, CENTER_ONS_CAPTURE), this.owner.message);
+			Send_Notification(NOTIF_ONE, this.owner.ons_toucher, MSG_CENTER, CENTER_ONS_CAPTURE, this.owner.message);
+			PlayerScore_Add(this.owner.ons_toucher, SP_ONS_CAPS, 1);
+			PlayerTeamScore_AddScore(this.owner.ons_toucher, 10);
 		}
 
-		self.owner.ons_toucher = world;
+		this.owner.ons_toucher = world;
 
 		onslaught_updatelinks();
 
 		// Use targets now (somebody make sure this is in the right place..)
-		SUB_UseTargets(self.owner, self, NULL);
+		SUB_UseTargets(this.owner, this, NULL);
 
-		self.SendFlags |= CPSF_SETUP;
+		this.SendFlags |= CPSF_SETUP;
 	}
-	if(self.owner.model != MDL_ONS_CP_PAD2.model_str())
-		setmodel_fixsize(self.owner, MDL_ONS_CP_PAD2);
+	if(this.owner.model != MDL_ONS_CP_PAD2.model_str())
+		setmodel_fixsize(this.owner, MDL_ONS_CP_PAD2);
 
-	if(random() < 0.9 - self.health / self.max_health)
-		Send_Effect(EFFECT_RAGE, self.origin + 10 * randomvec(), '0 0 -1', 1);
+	if(random() < 0.9 - this.health / this.max_health)
+		Send_Effect(EFFECT_RAGE, this.origin + 10 * randomvec(), '0 0 -1', 1);
 }
 
 void onslaught_controlpoint_icon_link(entity e, void() spawnproc);
@@ -1027,20 +1027,20 @@ void ons_GeneratorDamage(entity this, entity inflictor, entity attacker, float d
 
 void ons_GeneratorThink()
 {SELFPARAM();
-	self.nextthink = time + GEN_THINKRATE;
+	this.nextthink = time + GEN_THINKRATE;
 	if (!gameover)
 	{
-		if(!self.isshielded && self.wait < time)
+		if(!this.isshielded && this.wait < time)
 		{
-			self.wait = time + 5;
+			this.wait = time + 5;
 			FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), {
-				if(SAME_TEAM(it, self))
+				if(SAME_TEAM(it, this))
 				{
 					Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_ONS_NOTSHIELDED_TEAM);
 					soundto(MSG_ONE, it, CHAN_AUTO, SND(KH_ALARM), VOL_BASE, ATTEN_NONE);    // FIXME: unique sound?
 				}
 				else
-					Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(self.team, CENTER_ONS_NOTSHIELDED));
+					Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(this.team, CENTER_ONS_NOTSHIELDED));
 			});
 		}
 	}
diff --git a/qcsrc/common/minigames/minigame/pong.qc b/qcsrc/common/minigames/minigame/pong.qc
index 87c75f48c5..5074dccffd 100644
--- a/qcsrc/common/minigames/minigame/pong.qc
+++ b/qcsrc/common/minigames/minigame/pong.qc
@@ -148,53 +148,53 @@ bool pong_goal(entity ball, int pteam)
 void pong_ball_think()
 {SELFPARAM();
 	float think_speed = autocvar_sys_ticrate;
-	self.nextthink = time + think_speed;
+	this.nextthink = time + think_speed;
 
-	self.origin_x += self.velocity_x * think_speed;
-	self.origin_y += self.velocity_y * think_speed;
-	self.SendFlags |= MINIG_SF_UPDATE;
+	this.origin_x += this.velocity_x * think_speed;
+	this.origin_y += this.velocity_y * think_speed;
+	this.SendFlags |= MINIG_SF_UPDATE;
 
 	int i;
 	for ( i = 1; i <= PONG_MAX_PLAYERS; i++ )
-		if ( pong_paddle_hit(self, i) )
+		if ( pong_paddle_hit(this, i) )
 		{
-			pong_paddle_bounce(self,i);
-			self.team = i;
-			self.SendFlags |= PONG_SF_BALLTEAM;
+			pong_paddle_bounce(this,i);
+			this.team = i;
+			this.SendFlags |= PONG_SF_BALLTEAM;
 			return;
 		}
 
-	if ( self.origin_y <= self.pong_length )
+	if ( this.origin_y <= this.pong_length )
 	{
-		if ( !pong_goal(self,3) )
+		if ( !pong_goal(this,3) )
 		{
-			self.origin_y = self.pong_length;
-			self.velocity_y *= -1;
+			this.origin_y = this.pong_length;
+			this.velocity_y *= -1;
 		}
 	}
-	else if ( self.origin_y >= 1-self.pong_length )
+	else if ( this.origin_y >= 1-this.pong_length )
 	{
-		if ( !pong_goal(self,4) )
+		if ( !pong_goal(this,4) )
 		{
-			self.origin_y = 1-self.pong_length;
-			self.velocity_y *= -1;
+			this.origin_y = 1-this.pong_length;
+			this.velocity_y *= -1;
 		}
 	}
 
-	if ( self.origin_x <= self.pong_length )
+	if ( this.origin_x <= this.pong_length )
 	{
-		if ( !pong_goal(self,2) )
+		if ( !pong_goal(this,2) )
 		{
-			 self.origin_x = self.pong_length;
-			 self.velocity_x *= -1;
+			 this.origin_x = this.pong_length;
+			 this.velocity_x *= -1;
 		}
 	}
-	else if ( self.origin_x >= 1-self.pong_length )
+	else if ( this.origin_x >= 1-this.pong_length )
 	{
-		if ( !pong_goal(self,1) )
+		if ( !pong_goal(this,1) )
 		{
-			 self.origin_x = 1-self.pong_length;
-			 self.velocity_x *= -1;
+			 this.origin_x = 1-this.pong_length;
+			 this.velocity_x *= -1;
 		}
 	}
 
@@ -204,18 +204,18 @@ void pong_ball_think()
 void pong_ai_think()
 {SELFPARAM();
 	float think_speed = autocvar_sv_minigames_pong_ai_thinkspeed;
-	self.nextthink = time + think_speed;
+	this.nextthink = time + think_speed;
 
 	float distance;
 	float next_distance;
 	float min_distance = 1;
 	entity ball = world;
 	entity mayball = world;
-	while ( ( mayball = findentity(mayball,owner,self.owner) ) )
+	while ( ( mayball = findentity(mayball,owner,this.owner) ) )
 		if ( mayball.classname == "pong_ball" )
 		{
-			distance = vlen(mayball.origin-self.pong_ai_paddle.origin);
-			next_distance = vlen(mayball.origin+mayball.velocity-self.pong_ai_paddle.origin);
+			distance = vlen(mayball.origin-this.pong_ai_paddle.origin);
+			next_distance = vlen(mayball.origin+mayball.velocity-this.pong_ai_paddle.origin);
 			if (  distance < min_distance && ( distance < 0.5 || next_distance < distance ) )
 			{
 				min_distance = distance;
@@ -224,31 +224,31 @@ void pong_ai_think()
 		}
 
 	float target = 0.5;
-	float self_pos;
+	float my_pos;
 
 
-	if ( self.team <= 2 )
+	if ( this.team <= 2 )
 	{
 		if ( ball )
 			target = ball.origin_y + ball.velocity_y*think_speed;
-		self_pos = self.pong_ai_paddle.origin_y;
+		my_pos = this.pong_ai_paddle.origin_y;
 	}
 	else
 	{
 		if ( ball )
 			target = ball.origin_x + ball.velocity_x*think_speed;
-		self_pos = self.pong_ai_paddle.origin_x;
+		my_pos = this.pong_ai_paddle.origin_x;
 	}
 
-	distance = self.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance
+	distance = this.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance
 		+ autocvar_sv_minigames_pong_paddle_speed * think_speed;
 
-	if (target < self_pos - distance)
-		self.pong_keys = PONG_KEY_DECREASE;
-	else if (target > self_pos + distance)
-		self.pong_keys = PONG_KEY_INCREASE;
+	if (target < my_pos - distance)
+		this.pong_keys = PONG_KEY_DECREASE;
+	else if (target > my_pos + distance)
+		this.pong_keys = PONG_KEY_INCREASE;
 	else
-		self.pong_keys = 0;
+		this.pong_keys = 0;
 }
 
 entity pong_ai_spawn(entity paddle)
@@ -269,23 +269,23 @@ entity pong_ai_spawn(entity paddle)
 void pong_paddle_think()
 {SELFPARAM();
 	float think_speed = autocvar_sys_ticrate;
-	self.nextthink = time + think_speed;
+	this.nextthink = time + think_speed;
 
-	if ( self.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE ||
-		 self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
+	if ( this.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE ||
+		 this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
 	{
 		float movement = autocvar_sv_minigames_pong_paddle_speed * think_speed;
-		float halflen = self.pong_length/2;
+		float halflen = this.pong_length/2;
 
-		if ( self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
+		if ( this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE )
 			movement *= -1;
 
-		if ( self.team > 2 )
-			self.origin_x = bound(halflen, self.origin_x+movement, 1-halflen);
+		if ( this.team > 2 )
+			this.origin_x = bound(halflen, this.origin_x+movement, 1-halflen);
 		else
-			self.origin_y = bound(halflen, self.origin_y+movement, 1-halflen);
+			this.origin_y = bound(halflen, this.origin_y+movement, 1-halflen);
 
-		self.SendFlags |= MINIG_SF_UPDATE;
+		this.SendFlags |= MINIG_SF_UPDATE;
 	}
 }
 
diff --git a/qcsrc/common/minigames/minigame/snake.qc b/qcsrc/common/minigames/minigame/snake.qc
index d367472d82..56efb2e097 100644
--- a/qcsrc/common/minigames/minigame/snake.qc
+++ b/qcsrc/common/minigames/minigame/snake.qc
@@ -156,14 +156,14 @@ void snake_move_head(entity minigame, entity head);
 void snake_head_think()
 {
     SELFPARAM();
-	entity minigame = self.owner;
+	entity minigame = this.owner;
 
 	if(minigame.minigame_flags & SNAKE_TURN_MOVE)
-		snake_move_head(minigame, self);
+		snake_move_head(minigame, this);
 
 	snake_check_winner(minigame);
 
-	self.nextthink = time + self.snake_delay;
+	this.nextthink = time + this.snake_delay;
 }
 
 void minigame_setup_snake(entity minigame, int pteam)
diff --git a/qcsrc/common/monsters/monster/mage.qc b/qcsrc/common/monsters/monster/mage.qc
index 66ea47f251..de7bccb4b2 100644
--- a/qcsrc/common/monsters/monster/mage.qc
+++ b/qcsrc/common/monsters/monster/mage.qc
@@ -173,55 +173,55 @@ void M_Mage_Attack_Spike_Touch()
 // copied from W_Seeker_Think
 void M_Mage_Attack_Spike_Think()
 {SELFPARAM();
-	if (time > self.ltime || (self.enemy && self.enemy.health <= 0) || self.owner.health <= 0) {
-		self.projectiledeathtype |= HITTYPE_SPLASH;
-		M_Mage_Attack_Spike_Explode(self);
+	if (time > this.ltime || (this.enemy && this.enemy.health <= 0) || this.owner.health <= 0) {
+		this.projectiledeathtype |= HITTYPE_SPLASH;
+		M_Mage_Attack_Spike_Explode(this);
 	}
 
-	float spd = vlen(self.velocity);
+	float spd = vlen(this.velocity);
 	spd = bound(
 		spd - (autocvar_g_monster_mage_attack_spike_decel) * frametime,
 		(autocvar_g_monster_mage_attack_spike_speed_max),
 		spd + (autocvar_g_monster_mage_attack_spike_accel) * frametime
 	);
 
-	if (self.enemy != world)
-		if (self.enemy.takedamage != DAMAGE_AIM || IS_DEAD(self.enemy))
-			self.enemy = world;
+	if (this.enemy != world)
+		if (this.enemy.takedamage != DAMAGE_AIM || IS_DEAD(this.enemy))
+			this.enemy = world;
 
-	if (self.enemy != world)
+	if (this.enemy != world)
 	{
-		entity e = self.enemy;
+		entity e = this.enemy;
 		vector eorg = 0.5 * (e.absmin + e.absmax);
 		float turnrate = (autocvar_g_monster_mage_attack_spike_turnrate); // how fast to turn
-		vector desireddir = normalize(eorg - self.origin);
-		vector olddir = normalize(self.velocity); // get my current direction
+		vector desireddir = normalize(eorg - this.origin);
+		vector olddir = normalize(this.velocity); // get my current direction
 
 		// Do evasive maneuvers for world objects? ( this should be a cpu hog. :P )
-		if ((autocvar_g_monster_mage_attack_spike_smart) && vdist(eorg - self.origin, >, autocvar_g_monster_mage_attack_spike_smart_mindist))
+		if ((autocvar_g_monster_mage_attack_spike_smart) && vdist(eorg - this.origin, >, autocvar_g_monster_mage_attack_spike_smart_mindist))
 		{
-			// Is it a better idea (shorter distance) to trace to the target itself?
-			if ( vlen2(self.origin + olddir * self.wait) < vlen2(eorg - self.origin))
-				traceline(self.origin, self.origin + olddir * self.wait, false, self);
+			// Is it a better idea (shorter distance) to trace to the target itthis?
+			if ( vlen2(this.origin + olddir * this.wait) < vlen2(eorg - this.origin))
+				traceline(this.origin, this.origin + olddir * this.wait, false, this);
 			else
-				traceline(self.origin, eorg, false, self);
+				traceline(this.origin, eorg, false, this);
 
 			// Setup adaptive tracelength
-			self.wait = bound((autocvar_g_monster_mage_attack_spike_smart_trace_min), vlen(self.origin - trace_endpos), self.wait = (autocvar_g_monster_mage_attack_spike_smart_trace_max));
+			this.wait = bound((autocvar_g_monster_mage_attack_spike_smart_trace_min), vlen(this.origin - trace_endpos), this.wait = (autocvar_g_monster_mage_attack_spike_smart_trace_max));
 
 			// Calc how important it is that we turn and add this to the desierd (enemy) dir.
 			desireddir = normalize(((trace_plane_normal * (1 - trace_fraction)) + (desireddir * trace_fraction)) * 0.5);
 		}
 
 		vector newdir = normalize(olddir + desireddir * turnrate); // take the average of the 2 directions; not the best method but simple & easy
-		self.velocity = newdir * spd; // make me fly in the new direction at my flight speed
+		this.velocity = newdir * spd; // make me fly in the new direction at my flight speed
 	}
 
 	///////////////
 
-	//self.angles = vectoangles(self.velocity);			// turn model in the new flight direction
-	self.nextthink = time;// + 0.05; // csqc projectiles
-	UpdateCSQCProjectile(self);
+	//this.angles = vectoangles(this.velocity);			// turn model in the new flight direction
+	this.nextthink = time;// + 0.05; // csqc projectiles
+	UpdateCSQCProjectile(this);
 }
 
 void M_Mage_Attack_Spike(entity this, vector dir)
diff --git a/qcsrc/common/monsters/monster/shambler.qc b/qcsrc/common/monsters/monster/shambler.qc
index 139967a2cc..97e0d49ba5 100644
--- a/qcsrc/common/monsters/monster/shambler.qc
+++ b/qcsrc/common/monsters/monster/shambler.qc
@@ -78,36 +78,36 @@ void M_Shambler_Attack_Swing(entity this)
 
 #include <common/effects/qc/all.qh>
 
-void M_Shambler_Attack_Lightning_Explode()
-{SELFPARAM();
+void M_Shambler_Attack_Lightning_Explode(entity this)
+{
 	entity head;
 
-	sound(self, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM);
-	Send_Effect(EFFECT_ELECTRO_IMPACT, self.origin, '0 0 0', 1);
+	sound(this, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM);
+	Send_Effect(EFFECT_ELECTRO_IMPACT, this.origin, '0 0 0', 1);
 
-	self.event_damage = func_null;
-	self.takedamage = DAMAGE_NO;
-	self.movetype = MOVETYPE_NONE;
-	self.velocity = '0 0 0';
+	this.event_damage = func_null;
+	this.takedamage = DAMAGE_NO;
+	this.movetype = MOVETYPE_NONE;
+	this.velocity = '0 0 0';
 
-	if(self.movetype == MOVETYPE_NONE)
-		self.velocity = self.oldvelocity;
+	if(this.movetype == MOVETYPE_NONE)
+		this.velocity = this.oldvelocity;
 
-	RadiusDamage (self, self.realowner, (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_radius), world, world, (autocvar_g_monster_shambler_attack_lightning_force), self.projectiledeathtype, other);
+	RadiusDamage (this, this.realowner, (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_radius), world, world, (autocvar_g_monster_shambler_attack_lightning_force), this.projectiledeathtype, other);
 
-	for(head = findradius(self.origin, (autocvar_g_monster_shambler_attack_lightning_radius_zap)); head; head = head.chain) if(head != self.realowner) if(head.takedamage)
+	for(head = findradius(this.origin, (autocvar_g_monster_shambler_attack_lightning_radius_zap)); head; head = head.chain) if(head != this.realowner) if(head.takedamage)
 	{
-		te_csqc_lightningarc(self.origin, head.origin);
-		Damage(head, self, self.realowner, (autocvar_g_monster_shambler_attack_lightning_damage_zap) * MONSTER_SKILLMOD(self), DEATH_MONSTER_SHAMBLER_ZAP.m_id, head.origin, '0 0 0');
+		te_csqc_lightningarc(this.origin, head.origin);
+		Damage(head, this, this.realowner, (autocvar_g_monster_shambler_attack_lightning_damage_zap) * MONSTER_SKILLMOD(this), DEATH_MONSTER_SHAMBLER_ZAP.m_id, head.origin, '0 0 0');
 	}
 
-	self.think = SUB_Remove_self;
-	self.nextthink = time + 0.2;
+	this.think = SUB_Remove_self;
+	this.nextthink = time + 0.2;
 }
 
 void M_Shambler_Attack_Lightning_Explode_use(entity this, entity actor, entity trigger)
 {
-	WITHSELF(this, M_Shambler_Attack_Lightning_Explode());
+	M_Shambler_Attack_Lightning_Explode(this);
 }
 
 void M_Shambler_Attack_Lightning_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
@@ -133,11 +133,11 @@ void M_Shambler_Attack_Lightning_Touch()
 
 void M_Shambler_Attack_Lightning_Think()
 {SELFPARAM();
-	self.nextthink = time;
-	if (time > self.cnt)
+	this.nextthink = time;
+	if (time > this.cnt)
 	{
 		other = world;
-		M_Shambler_Attack_Lightning_Explode();
+		M_Shambler_Attack_Lightning_Explode(this);
 		return;
 	}
 }
diff --git a/qcsrc/common/monsters/monster/wyvern.qc b/qcsrc/common/monsters/monster/wyvern.qc
index 1adf8f84c8..3757f7941f 100644
--- a/qcsrc/common/monsters/monster/wyvern.qc
+++ b/qcsrc/common/monsters/monster/wyvern.qc
@@ -102,19 +102,19 @@ const float wyvern_anim_death	= 4;
 void M_Wyvern_Attack_Fireball_Explode()
 {
 	SELFPARAM();
-	Send_Effect(EFFECT_FIREBALL_EXPLODE, self.origin, '0 0 0', 1);
+	Send_Effect(EFFECT_FIREBALL_EXPLODE, this.origin, '0 0 0', 1);
 
-	entity own = self.realowner;
+	entity own = this.realowner;
 
-	RadiusDamage(self, own, autocvar_g_monster_wyvern_attack_fireball_damage, autocvar_g_monster_wyvern_attack_fireball_edgedamage, autocvar_g_monster_wyvern_attack_fireball_force, world, world, autocvar_g_monster_wyvern_attack_fireball_radius, self.projectiledeathtype, world);
+	RadiusDamage(this, own, autocvar_g_monster_wyvern_attack_fireball_damage, autocvar_g_monster_wyvern_attack_fireball_edgedamage, autocvar_g_monster_wyvern_attack_fireball_force, world, world, autocvar_g_monster_wyvern_attack_fireball_radius, this.projectiledeathtype, world);
 
 	FOREACH_ENTITY_FLOAT(takedamage, DAMAGE_AIM,
 	{
-		if(vdist(it.origin - self.origin, <=, autocvar_g_monster_wyvern_attack_fireball_radius))
-			Fire_AddDamage(it, own, 5 * MONSTER_SKILLMOD(own), autocvar_g_monster_wyvern_attack_fireball_damagetime, self.projectiledeathtype);
+		if(vdist(it.origin - this.origin, <=, autocvar_g_monster_wyvern_attack_fireball_radius))
+			Fire_AddDamage(it, own, 5 * MONSTER_SKILLMOD(own), autocvar_g_monster_wyvern_attack_fireball_damagetime, this.projectiledeathtype);
 	});
 
-	remove(self);
+	remove(this);
 }
 
 void M_Wyvern_Attack_Fireball_Touch()
diff --git a/qcsrc/common/monsters/sv_monsters.qc b/qcsrc/common/monsters/sv_monsters.qc
index def29e969d..0179a251b8 100644
--- a/qcsrc/common/monsters/sv_monsters.qc
+++ b/qcsrc/common/monsters/sv_monsters.qc
@@ -212,7 +212,7 @@ void Monster_Delay_Action(entity this)
 void Monster_Delay_Action_self()
 {
     SELFPARAM();
-	Monster_Delay_Action(self);
+	Monster_Delay_Action(this);
 }
 
 void Monster_Delay(entity this, int repeat_count, float defer_amnt, void(entity) func)
diff --git a/qcsrc/common/mutators/mutator/buffs/buffs.qc b/qcsrc/common/mutators/mutator/buffs/buffs.qc
index 3ab9bc1cd0..18841767fc 100644
--- a/qcsrc/common/mutators/mutator/buffs/buffs.qc
+++ b/qcsrc/common/mutators/mutator/buffs/buffs.qc
@@ -175,16 +175,16 @@ void buff_Waypoint_Spawn(entity e)
 	e.buff_waypoint.waypointsprite_visible_for_player = buff_Waypoint_visible_for_player;
 }
 
-void buff_SetCooldown(float cd)
-{SELFPARAM();
+void buff_SetCooldown(entity this, float cd)
+{
 	cd = max(0, cd);
 
-	if(!self.buff_waypoint)
-		buff_Waypoint_Spawn(self);
+	if(!this.buff_waypoint)
+		buff_Waypoint_Spawn(this);
 
-	WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + cd);
-	self.buff_activetime = cd;
-	self.buff_active = !cd;
+	WaypointSprite_UpdateBuildFinished(this.buff_waypoint, time + cd);
+	this.buff_activetime = cd;
+	this.buff_active = !cd;
 }
 
 void buff_Respawn(entity this)
@@ -300,80 +300,80 @@ void buff_NewType(entity ent, float cb)
 
 void buff_Think()
 {SELFPARAM();
-	if(self.buffs != self.oldbuffs)
+	if(this.buffs != this.oldbuffs)
 	{
-		entity buff = buff_FirstFromFlags(self.buffs);
-		self.color = buff.m_color;
-		self.glowmod = buff_GlowColor(buff);
-		self.skin = buff.m_skin;
+		entity buff = buff_FirstFromFlags(this.buffs);
+		this.color = buff.m_color;
+		this.glowmod = buff_GlowColor(buff);
+		this.skin = buff.m_skin;
 
-		setmodel(self, MDL_BUFF);
+		setmodel(this, MDL_BUFF);
 
-		if(self.buff_waypoint)
+		if(this.buff_waypoint)
 		{
-			//WaypointSprite_Disown(self.buff_waypoint, 1);
-			WaypointSprite_Kill(self.buff_waypoint);
-			buff_Waypoint_Spawn(self);
-			if(self.buff_activetime)
-				WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + self.buff_activetime - frametime);
+			//WaypointSprite_Disown(this.buff_waypoint, 1);
+			WaypointSprite_Kill(this.buff_waypoint);
+			buff_Waypoint_Spawn(this);
+			if(this.buff_activetime)
+				WaypointSprite_UpdateBuildFinished(this.buff_waypoint, time + this.buff_activetime - frametime);
 		}
 
-		self.oldbuffs = self.buffs;
+		this.oldbuffs = this.buffs;
 	}
 
 	if(!gameover)
 	if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime)
-	if(!self.buff_activetime_updated)
+	if(!this.buff_activetime_updated)
 	{
-		buff_SetCooldown(self.buff_activetime);
-		self.buff_activetime_updated = true;
+		buff_SetCooldown(this, this.buff_activetime);
+		this.buff_activetime_updated = true;
 	}
 
-	if(!self.buff_active && !self.buff_activetime)
-	if(!self.owner || STAT(FROZEN, self.owner) || IS_DEAD(self.owner) || !self.owner.iscreature || !(self.owner.buffs & self.buffs))
+	if(!this.buff_active && !this.buff_activetime)
+	if(!this.owner || STAT(FROZEN, this.owner) || IS_DEAD(this.owner) || !this.owner.iscreature || !(this.owner.buffs & this.buffs))
 	{
-		buff_SetCooldown(autocvar_g_buffs_cooldown_respawn + frametime);
-		self.owner = world;
+		buff_SetCooldown(this, autocvar_g_buffs_cooldown_respawn + frametime);
+		this.owner = world;
 		if(autocvar_g_buffs_randomize)
-			buff_NewType(self, self.buffs);
+			buff_NewType(this, this.buffs);
 
-		if(autocvar_g_buffs_random_location || (self.spawnflags & 64))
-			buff_Respawn(self);
+		if(autocvar_g_buffs_random_location || (this.spawnflags & 64))
+			buff_Respawn(this);
 	}
 
-	if(self.buff_activetime)
+	if(this.buff_activetime)
 	if(!gameover)
 	if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime)
 	{
-		self.buff_activetime = max(0, self.buff_activetime - frametime);
+		this.buff_activetime = max(0, this.buff_activetime - frametime);
 
-		if(!self.buff_activetime)
+		if(!this.buff_activetime)
 		{
-			self.buff_active = true;
-			sound(self, CH_TRIGGER, SND_STRENGTH_RESPAWN, VOL_BASE, ATTN_NORM);
-			Send_Effect(EFFECT_ITEM_RESPAWN, CENTER_OR_VIEWOFS(self), '0 0 0', 1);
+			this.buff_active = true;
+			sound(this, CH_TRIGGER, SND_STRENGTH_RESPAWN, VOL_BASE, ATTN_NORM);
+			Send_Effect(EFFECT_ITEM_RESPAWN, CENTER_OR_VIEWOFS(this), '0 0 0', 1);
 		}
 	}
 
-	if(self.buff_active)
+	if(this.buff_active)
 	{
-		if(self.team && !self.buff_waypoint)
-			buff_Waypoint_Spawn(self);
+		if(this.team && !this.buff_waypoint)
+			buff_Waypoint_Spawn(this);
 
-		if(self.lifetime)
-		if(time >= self.lifetime)
-			buff_Respawn(self);
+		if(this.lifetime)
+		if(time >= this.lifetime)
+			buff_Respawn(this);
 	}
 
-	self.nextthink = time;
-	//self.angles_y = time * 110.1;
+	this.nextthink = time;
+	//this.angles_y = time * 110.1;
 }
 
-void buff_Waypoint_Reset()
-{SELFPARAM();
-	WaypointSprite_Kill(self.buff_waypoint);
+void buff_Waypoint_Reset(entity this)
+{
+	WaypointSprite_Kill(this.buff_waypoint);
 
-	if(self.buff_activetime) { buff_Waypoint_Spawn(self); }
+	if(this.buff_activetime) { buff_Waypoint_Spawn(this); }
 }
 
 void buff_Reset(entity this)
@@ -381,8 +381,8 @@ void buff_Reset(entity this)
 	if(autocvar_g_buffs_randomize)
 		buff_NewType(this, this.buffs);
 	this.owner = world;
-	buff_SetCooldown(autocvar_g_buffs_cooldown_activate);
-	buff_Waypoint_Reset();
+	buff_SetCooldown(this, autocvar_g_buffs_cooldown_activate);
+	buff_Waypoint_Reset(this);
 	this.buff_activetime_updated = false;
 
 	if(autocvar_g_buffs_random_location || (this.spawnflags & 64))
@@ -392,68 +392,65 @@ void buff_Reset(entity this)
 float buff_Customize()
 {SELFPARAM();
 	entity player = WaypointSprite_getviewentity(other);
-	if(!self.buff_active || (self.team && DIFF_TEAM(player, self)))
+	if(!this.buff_active || (this.team && DIFF_TEAM(player, this)))
 	{
-		self.alpha = 0.3;
-		if(self.effects & EF_FULLBRIGHT) { self.effects &= ~(EF_FULLBRIGHT); }
-		self.pflags = 0;
+		this.alpha = 0.3;
+		if(this.effects & EF_FULLBRIGHT) { this.effects &= ~(EF_FULLBRIGHT); }
+		this.pflags = 0;
 	}
 	else
 	{
-		self.alpha = 1;
-		if(!(self.effects & EF_FULLBRIGHT)) { self.effects |= EF_FULLBRIGHT; }
-		self.light_lev = 220 + 36 * sin(time);
-		self.pflags = PFLAGS_FULLDYNAMIC;
+		this.alpha = 1;
+		if(!(this.effects & EF_FULLBRIGHT)) { this.effects |= EF_FULLBRIGHT; }
+		this.light_lev = 220 + 36 * sin(time);
+		this.pflags = PFLAGS_FULLDYNAMIC;
 	}
 	return true;
 }
 
-void buff_Init(entity ent)
-{SELFPARAM();
-	if(!cvar("g_buffs")) { remove(ent); return; }
-
-	if(!teamplay && ent.team) { ent.team = 0; }
-
-	entity buff = buff_FirstFromFlags(self.buffs);
-
-	setself(ent);
-	if(!self.buffs || buff_Available(buff))
-		buff_NewType(self, 0);
-
-	self.classname = "item_buff";
-	self.solid = SOLID_TRIGGER;
-	self.flags = FL_ITEM;
-	self.think = buff_Think;
-	self.touch = buff_Touch;
-	self.reset = buff_Reset;
-	self.nextthink = time + 0.1;
-	self.gravity = 1;
-	self.movetype = MOVETYPE_TOSS;
-	self.scale = 1;
-	self.skin = buff.m_skin;
-	self.effects = EF_FULLBRIGHT | EF_STARDUST | EF_NOSHADOW;
-	self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY;
-	self.customizeentityforclient = buff_Customize;
-	//self.gravity = 100;
-	self.color = buff.m_color;
-	self.glowmod = buff_GlowColor(self);
-	buff_SetCooldown(autocvar_g_buffs_cooldown_activate + game_starttime);
-	self.buff_active = !self.buff_activetime;
-	self.pflags = PFLAGS_FULLDYNAMIC;
-
-	if(self.spawnflags & 1)
-		self.noalign = true;
-
-	if(self.noalign)
-		self.movetype = MOVETYPE_NONE; // reset by random location
-
-	setmodel(self, MDL_BUFF);
-	setsize(self, BUFF_MIN, BUFF_MAX);
-
-	if(cvar("g_buffs_random_location") || (self.spawnflags & 64))
-		buff_Respawn(self);
+void buff_Init(entity this)
+{
+	if(!cvar("g_buffs")) { remove(this); return; }
+
+	if(!teamplay && this.team) { this.team = 0; }
 
-	setself(this);
+	entity buff = buff_FirstFromFlags(this.buffs);
+
+	if(!this.buffs || buff_Available(buff))
+		buff_NewType(this, 0);
+
+	this.classname = "item_buff";
+	this.solid = SOLID_TRIGGER;
+	this.flags = FL_ITEM;
+	this.think = buff_Think;
+	this.touch = buff_Touch;
+	this.reset = buff_Reset;
+	this.nextthink = time + 0.1;
+	this.gravity = 1;
+	this.movetype = MOVETYPE_TOSS;
+	this.scale = 1;
+	this.skin = buff.m_skin;
+	this.effects = EF_FULLBRIGHT | EF_STARDUST | EF_NOSHADOW;
+	this.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY;
+	this.customizeentityforclient = buff_Customize;
+	//this.gravity = 100;
+	this.color = buff.m_color;
+	this.glowmod = buff_GlowColor(this);
+	buff_SetCooldown(this, autocvar_g_buffs_cooldown_activate + game_starttime);
+	this.buff_active = !this.buff_activetime;
+	this.pflags = PFLAGS_FULLDYNAMIC;
+
+	if(this.spawnflags & 1)
+		this.noalign = true;
+
+	if(this.noalign)
+		this.movetype = MOVETYPE_NONE; // reset by random location
+
+	setmodel(this, MDL_BUFF);
+	setsize(this, BUFF_MIN, BUFF_MAX);
+
+	if(cvar("g_buffs_random_location") || (this.spawnflags & 64))
+		buff_Respawn(this);
 }
 
 void buff_Init_Compat(entity ent, entity replacement)
@@ -479,10 +476,10 @@ void buff_SpawnReplacement(entity ent, entity old)
 
 void buff_Vengeance_DelayedDamage()
 {SELFPARAM();
-	if(self.enemy)
-		Damage(self.enemy, self.owner, self.owner, self.dmg, DEATH_BUFF.m_id, self.enemy.origin, '0 0 0');
+	if(this.enemy)
+		Damage(this.enemy, this.owner, this.owner, this.dmg, DEATH_BUFF.m_id, this.enemy.origin, '0 0 0');
 
-	remove(self);
+	remove(this);
 	return;
 }
 
diff --git a/qcsrc/common/mutators/mutator/instagib/instagib.qc b/qcsrc/common/mutators/mutator/instagib/instagib.qc
index 575e95210f..d9504f82f6 100644
--- a/qcsrc/common/mutators/mutator/instagib/instagib.qc
+++ b/qcsrc/common/mutators/mutator/instagib/instagib.qc
@@ -31,7 +31,7 @@ spawnfunc(item_minst_cells)
 
 void instagib_invisibility()
 {SELFPARAM();
-	self.strength_finished = autocvar_g_balance_powerup_strength_time;
+	this.strength_finished = autocvar_g_balance_powerup_strength_time;
 	StartItem(this, ITEM_Invisibility);
 }
 
@@ -42,7 +42,7 @@ void instagib_extralife()
 
 void instagib_speed()
 {SELFPARAM();
-	self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
+	this.invincible_finished = autocvar_g_balance_powerup_invincible_time;
 	StartItem(this, ITEM_Speed);
 }
 
@@ -55,86 +55,86 @@ void instagib_stop_countdown(entity e)
 	Kill_Notification(NOTIF_ONE_ONLY, e, MSG_CENTER, CPID_INSTAGIB_FINDAMMO);
 	e.instagib_needammo = false;
 }
-void instagib_ammocheck()
-{SELFPARAM();
-	if(time < self.instagib_nextthink)
+void instagib_ammocheck(entity this)
+{
+	if(time < this.instagib_nextthink)
 		return;
-	if(!IS_PLAYER(self))
+	if(!IS_PLAYER(this))
 		return; // not a player
 
-	if(IS_DEAD(self) || gameover)
-		instagib_stop_countdown(self);
-	else if (self.ammo_cells > 0 || (self.items & IT_UNLIMITED_WEAPON_AMMO) || (self.flags & FL_GODMODE))
-		instagib_stop_countdown(self);
+	if(IS_DEAD(this) || gameover)
+		instagib_stop_countdown(this);
+	else if (this.ammo_cells > 0 || (this.items & IT_UNLIMITED_WEAPON_AMMO) || (this.flags & FL_GODMODE))
+		instagib_stop_countdown(this);
 	else if(autocvar_g_rm && autocvar_g_rm_laser)
 	{
-		if(!self.instagib_needammo)
+		if(!this.instagib_needammo)
 		{
-			Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_INSTAGIB_DOWNGRADE);
-			self.instagib_needammo = true;
+			Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_INSTAGIB_DOWNGRADE);
+			this.instagib_needammo = true;
 		}
 	}
 	else
 	{
-		self.instagib_needammo = true;
-		if (self.health <= 5)
+		this.instagib_needammo = true;
+		if (this.health <= 5)
 		{
-			Damage(self, self, self, 5, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_INSTAGIB_TERMINATED);
+			Damage(this, this, this, 5, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_INSTAGIB_TERMINATED);
 		}
-		else if (self.health <= 10)
+		else if (this.health <= 10)
 		{
-			Damage(self, self, self, 5, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_1);
+			Damage(this, this, this, 5, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_1);
 		}
-		else if (self.health <= 20)
+		else if (this.health <= 20)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_2);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_2);
 		}
-		else if (self.health <= 30)
+		else if (this.health <= 30)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_3);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_3);
 		}
-		else if (self.health <= 40)
+		else if (this.health <= 40)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_4);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_4);
 		}
-		else if (self.health <= 50)
+		else if (this.health <= 50)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_5);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_5);
 		}
-		else if (self.health <= 60)
+		else if (this.health <= 60)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_6);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_6);
 		}
-		else if (self.health <= 70)
+		else if (this.health <= 70)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_7);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_7);
 		}
-		else if (self.health <= 80)
+		else if (this.health <= 80)
 		{
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_8);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_8);
 		}
-		else if (self.health <= 90)
+		else if (this.health <= 90)
 		{
-			Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_INSTAGIB_FINDAMMO);
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
-			Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_9);
+			Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_INSTAGIB_FINDAMMO);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_9);
 		}
 		else
 		{
-			Send_Notification(NOTIF_ONE_ONLY, self, MSG_MULTI, MULTI_INSTAGIB_FINDAMMO);
-			Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0');
+			Send_Notification(NOTIF_ONE_ONLY, this, MSG_MULTI, MULTI_INSTAGIB_FINDAMMO);
+			Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0');
 		}
 	}
-	self.instagib_nextthink = time + 1;
+	this.instagib_nextthink = time + 1;
 }
 
 MUTATOR_HOOKFUNCTION(mutator_instagib, MatchEnd)
@@ -180,8 +180,8 @@ MUTATOR_HOOKFUNCTION(mutator_instagib, PlayerSpawn)
 }
 
 MUTATOR_HOOKFUNCTION(mutator_instagib, PlayerPreThink)
-{
-	instagib_ammocheck();
+{SELFPARAM();
+	instagib_ammocheck(self);
 	return false;
 }
 
diff --git a/qcsrc/common/mutators/mutator/nades/nades.qc b/qcsrc/common/mutators/mutator/nades/nades.qc
index cabfd31b81..9be8f96de0 100644
--- a/qcsrc/common/mutators/mutator/nades/nades.qc
+++ b/qcsrc/common/mutators/mutator/nades/nades.qc
@@ -149,10 +149,10 @@ REGISTER_MUTATOR(nades, cvar("g_nades"));
 
 void nade_timer_think()
 {SELFPARAM();
-	self.skin = 8 - (self.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10);
-	self.nextthink = time;
-	if(!self.owner || wasfreed(self.owner))
-		remove(self);
+	this.skin = 8 - (this.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10);
+	this.nextthink = time;
+	if(!this.owner || wasfreed(this.owner))
+		remove(this);
 }
 
 void nade_burn_spawn(entity _nade)
@@ -178,8 +178,8 @@ void nade_spawn(entity _nade)
 	CSQCProjectile(_nade, true, Nades_from(_nade.nade_type).m_projectile[false], true);
 }
 
-void napalm_damage(float dist, float damage, float edgedamage, float burntime)
-{SELFPARAM();
+void napalm_damage(entity this, float dist, float damage, float edgedamage, float burntime)
+{
 	entity e;
 	float d;
 	vector p;
@@ -188,17 +188,17 @@ void napalm_damage(float dist, float damage, float edgedamage, float burntime)
 		return;
 
 	RandomSelection_Init();
-	for(e = WarpZone_FindRadius(self.origin, dist, true); e; e = e.chain)
+	for(e = WarpZone_FindRadius(this.origin, dist, true); e; e = e.chain)
 		if(e.takedamage == DAMAGE_AIM)
-		if(self.realowner != e || autocvar_g_nades_napalm_selfdamage)
-		if(!IS_PLAYER(e) || !self.realowner || DIFF_TEAM(e, self))
+		if(this.realowner != e || autocvar_g_nades_napalm_selfdamage)
+		if(!IS_PLAYER(e) || !this.realowner || DIFF_TEAM(e, this))
 		if(!STAT(FROZEN, e))
 		{
 			p = e.origin;
 			p.x += e.mins.x + random() * (e.maxs.x - e.mins.x);
 			p.y += e.mins.y + random() * (e.maxs.y - e.mins.y);
 			p.z += e.mins.z + random() * (e.maxs.z - e.mins.z);
-			d = vlen(WarpZone_UnTransformOrigin(e, self.origin) - p);
+			d = vlen(WarpZone_UnTransformOrigin(e, this.origin) - p);
 			if(d < dist)
 			{
 				e.fireball_impactvec = p;
@@ -207,11 +207,11 @@ void napalm_damage(float dist, float damage, float edgedamage, float burntime)
 		}
 	if(RandomSelection_chosen_ent)
 	{
-		d = vlen(WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, self.origin) - RandomSelection_chosen_ent.fireball_impactvec);
+		d = vlen(WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, this.origin) - RandomSelection_chosen_ent.fireball_impactvec);
 		d = damage + (edgedamage - damage) * (d / dist);
-		Fire_AddDamage(RandomSelection_chosen_ent, self.realowner, d * burntime, burntime, self.projectiledeathtype | HITTYPE_BOUNCE);
-		//trailparticles(self, particleeffectnum(EFFECT_FIREBALL_LASER), self.origin, RandomSelection_chosen_ent.fireball_impactvec);
-		Send_Effect(EFFECT_FIREBALL_LASER, self.origin, RandomSelection_chosen_ent.fireball_impactvec - self.origin, 1);
+		Fire_AddDamage(RandomSelection_chosen_ent, this.realowner, d * burntime, burntime, this.projectiledeathtype | HITTYPE_BOUNCE);
+		//trailparticles(this, particleeffectnum(EFFECT_FIREBALL_LASER), this.origin, RandomSelection_chosen_ent.fireball_impactvec);
+		Send_Effect(EFFECT_FIREBALL_LASER, this.origin, RandomSelection_chosen_ent.fireball_impactvec - this.origin, 1);
 	}
 }
 
@@ -221,45 +221,45 @@ void napalm_ball_think()
 	if(round_handler_IsActive())
 	if(!round_handler_IsRoundStarted())
 	{
-		remove(self);
+		remove(this);
 		return;
 	}
 
-	if(time > self.pushltime)
+	if(time > this.pushltime)
 	{
-		remove(self);
+		remove(this);
 		return;
 	}
 
-	vector midpoint = ((self.absmin + self.absmax) * 0.5);
+	vector midpoint = ((this.absmin + this.absmax) * 0.5);
 	if(pointcontents(midpoint) == CONTENT_WATER)
 	{
-		self.velocity = self.velocity * 0.5;
+		this.velocity = this.velocity * 0.5;
 
 		if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
-			{ self.velocity_z = 200; }
+			{ this.velocity_z = 200; }
 	}
 
-	self.angles = vectoangles(self.velocity);
+	this.angles = vectoangles(this.velocity);
 
-	napalm_damage(autocvar_g_nades_napalm_ball_radius,autocvar_g_nades_napalm_ball_damage,
+	napalm_damage(this, autocvar_g_nades_napalm_ball_radius,autocvar_g_nades_napalm_ball_damage,
 				  autocvar_g_nades_napalm_ball_damage,autocvar_g_nades_napalm_burntime);
 
-	self.nextthink = time + 0.1;
+	this.nextthink = time + 0.1;
 }
 
 
-void nade_napalm_ball()
-{SELFPARAM();
+void nade_napalm_ball(entity this)
+{
 	entity proj;
 	vector kick;
 
-	spamsound(self, CH_SHOTS, SND(FIREBALL_FIRE), VOL_BASE, ATTEN_NORM);
+	spamsound(this, CH_SHOTS, SND(FIREBALL_FIRE), VOL_BASE, ATTEN_NORM);
 
 	proj = new(grenade);
-	proj.owner = self.owner;
-	proj.realowner = self.realowner;
-	proj.team = self.owner.team;
+	proj.owner = this.owner;
+	proj.realowner = this.realowner;
+	proj.team = this.owner.team;
 	proj.bot_dodge = true;
 	proj.bot_dodgerating = autocvar_g_nades_napalm_ball_damage;
 	proj.movetype = MOVETYPE_BOUNCE;
@@ -268,7 +268,7 @@ void nade_napalm_ball()
 	setmodel(proj, MDL_Null);
 	proj.scale = 1;//0.5;
 	setsize(proj, '-4 -4 -4', '4 4 4');
-	setorigin(proj, self.origin);
+	setorigin(proj, this.origin);
 	proj.think = napalm_ball_think;
 	proj.nextthink = time;
 	proj.damageforcescale = autocvar_g_nades_napalm_ball_damageforcescale;
@@ -295,44 +295,44 @@ void napalm_fountain_think()
 	if(round_handler_IsActive())
 	if(!round_handler_IsRoundStarted())
 	{
-		remove(self);
+		remove(this);
 		return;
 	}
 
-	if(time >= self.ltime)
+	if(time >= this.ltime)
 	{
-		remove(self);
+		remove(this);
 		return;
 	}
 
-	vector midpoint = ((self.absmin + self.absmax) * 0.5);
+	vector midpoint = ((this.absmin + this.absmax) * 0.5);
 	if(pointcontents(midpoint) == CONTENT_WATER)
 	{
-		self.velocity = self.velocity * 0.5;
+		this.velocity = this.velocity * 0.5;
 
 		if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
-			{ self.velocity_z = 200; }
+			{ this.velocity_z = 200; }
 
-		UpdateCSQCProjectile(self);
+		UpdateCSQCProjectile(this);
 	}
 
-	napalm_damage(autocvar_g_nades_napalm_fountain_radius, autocvar_g_nades_napalm_fountain_damage,
+	napalm_damage(this, autocvar_g_nades_napalm_fountain_radius, autocvar_g_nades_napalm_fountain_damage,
 		autocvar_g_nades_napalm_fountain_edgedamage, autocvar_g_nades_napalm_burntime);
 
-	self.nextthink = time + 0.1;
-	if(time >= self.nade_special_time)
+	this.nextthink = time + 0.1;
+	if(time >= this.nade_special_time)
 	{
-		self.nade_special_time = time + autocvar_g_nades_napalm_fountain_delay;
-		nade_napalm_ball();
+		this.nade_special_time = time + autocvar_g_nades_napalm_fountain_delay;
+		nade_napalm_ball(this);
 	}
 }
 
-void nade_napalm_boom()
-{SELFPARAM();
+void nade_napalm_boom(entity this)
+{
 	entity fountain;
 	int c;
 	for (c = 0; c < autocvar_g_nades_napalm_ball_count; c++)
-		nade_napalm_ball();
+		nade_napalm_ball(this);
 
 
 	fountain = spawn();
@@ -428,25 +428,25 @@ void nade_ice_think()
 		nade_ice_freeze(self, e, current_freeze_time);
 }
 
-void nade_ice_boom()
-{SELFPARAM();
+void nade_ice_boom(entity this)
+{
 	entity fountain;
 	fountain = spawn();
-	fountain.owner = self.owner;
-	fountain.realowner = self.realowner;
-	fountain.origin = self.origin;
+	fountain.owner = this.owner;
+	fountain.realowner = this.realowner;
+	fountain.origin = this.origin;
 	setorigin(fountain, fountain.origin);
 	fountain.think = nade_ice_think;
 	fountain.nextthink = time;
 	fountain.ltime = time + autocvar_g_nades_ice_freeze_time;
 	fountain.pushltime = fountain.wait = fountain.ltime;
-	fountain.team = self.team;
+	fountain.team = this.team;
 	fountain.movetype = MOVETYPE_TOSS;
 	fountain.projectiledeathtype = DEATH_NADE_ICE.m_id;
 	fountain.bot_dodge = false;
 	setsize(fountain, '-16 -16 -16', '16 16 16');
 	fountain.nade_special_time = time+0.3;
-	fountain.angles = self.angles;
+	fountain.angles = this.angles;
 
 	if ( autocvar_g_nades_ice_explode )
 	{
@@ -454,8 +454,8 @@ void nade_ice_boom()
 		entity timer = new(nade_timer);
 		setmodel(timer, MDL_NADE_TIMER);
 		setattachment(timer, fountain, "");
-		timer.colormap = self.colormap;
-		timer.glowmod = self.glowmod;
+		timer.colormap = this.colormap;
+		timer.glowmod = this.glowmod;
 		timer.think = nade_timer_think;
 		timer.nextthink = time;
 		timer.wait = fountain.ltime;
@@ -466,40 +466,40 @@ void nade_ice_boom()
 		setmodel(fountain, MDL_Null);
 }
 
-void nade_translocate_boom()
-{SELFPARAM();
-	if(self.realowner.vehicle)
+void nade_translocate_boom(entity this)
+{
+	if(this.realowner.vehicle)
 		return;
 
-	vector locout = self.origin + '0 0 1' * (1 - self.realowner.mins.z - 24);
-	tracebox(locout, self.realowner.mins, self.realowner.maxs, locout, MOVE_NOMONSTERS, self.realowner);
+	vector locout = this.origin + '0 0 1' * (1 - this.realowner.mins.z - 24);
+	tracebox(locout, this.realowner.mins, this.realowner.maxs, locout, MOVE_NOMONSTERS, this.realowner);
 	locout = trace_endpos;
 
-	makevectors(self.realowner.angles);
+	makevectors(this.realowner.angles);
 
-	MUTATOR_CALLHOOK(PortalTeleport, self.realowner);
+	MUTATOR_CALLHOOK(PortalTeleport, this.realowner);
 
-	TeleportPlayer(self, self.realowner, locout, self.realowner.angles, v_forward * vlen(self.realowner.velocity), '0 0 0', '0 0 0', TELEPORT_FLAGS_TELEPORTER);
+	TeleportPlayer(this, this.realowner, locout, this.realowner.angles, v_forward * vlen(this.realowner.velocity), '0 0 0', '0 0 0', TELEPORT_FLAGS_TELEPORTER);
 }
 
-void nade_spawn_boom()
-{SELFPARAM();
+void nade_spawn_boom(entity this)
+{
 	entity spawnloc = spawn();
-	setorigin(spawnloc, self.origin);
-	setsize(spawnloc, self.realowner.mins, self.realowner.maxs);
+	setorigin(spawnloc, this.origin);
+	setsize(spawnloc, this.realowner.mins, this.realowner.maxs);
 	spawnloc.movetype = MOVETYPE_NONE;
 	spawnloc.solid = SOLID_NOT;
-	spawnloc.drawonlytoclient = self.realowner;
+	spawnloc.drawonlytoclient = this.realowner;
 	spawnloc.effects = EF_STARDUST;
 	spawnloc.cnt = autocvar_g_nades_spawn_count;
 
-	if(self.realowner.nade_spawnloc)
+	if(this.realowner.nade_spawnloc)
 	{
-		remove(self.realowner.nade_spawnloc);
-		self.realowner.nade_spawnloc = world;
+		remove(this.realowner.nade_spawnloc);
+		this.realowner.nade_spawnloc = world;
 	}
 
-	self.realowner.nade_spawnloc = spawnloc;
+	this.realowner.nade_spawnloc = spawnloc;
 }
 
 void nade_heal_think()
@@ -563,16 +563,16 @@ void nade_heal_touch()
 	}
 }
 
-void nade_heal_boom()
-{SELFPARAM();
+void nade_heal_boom(entity this)
+{
 	entity healer;
 	healer = spawn();
-	healer.owner = self.owner;
-	healer.realowner = self.realowner;
-	setorigin(healer, self.origin);
+	healer.owner = this.owner;
+	healer.realowner = this.realowner;
+	setorigin(healer, this.origin);
 	healer.healer_lifetime = autocvar_g_nades_heal_time; // save the cvar
 	healer.ltime = time + healer.healer_lifetime;
-	healer.team = self.realowner.team;
+	healer.team = this.realowner.team;
 	healer.bot_dodge = false;
 	healer.solid = SOLID_TRIGGER;
 	healer.touch = nade_heal_touch;
@@ -589,9 +589,9 @@ void nade_heal_boom()
 	healer.SendFlags |= 1;
 }
 
-void nade_monster_boom()
-{SELFPARAM();
-	entity e = spawnmonster(self.pokenade_type, 0, self.realowner, self.realowner, self.origin, false, false, 1);
+void nade_monster_boom(entity this)
+{
+	entity e = spawnmonster(this.pokenade_type, 0, this.realowner, this.realowner, this.origin, false, false, 1);
 
 	if(autocvar_g_nades_pokenade_monster_lifetime > 0)
 		e.monster_lifetime = time + autocvar_g_nades_pokenade_monster_lifetime;
@@ -603,7 +603,7 @@ void nade_boom()
 	entity expef = NULL;
 	bool nade_blast = true;
 
-	switch ( Nades_from(self.nade_type) )
+	switch ( Nades_from(this.nade_type) )
 	{
 		case NADE_TYPE_NAPALM:
 			nade_blast = autocvar_g_nades_napalm_blast;
@@ -619,7 +619,7 @@ void nade_boom()
 		case NADE_TYPE_MONSTER:
 		case NADE_TYPE_SPAWN:
 			nade_blast = false;
-			switch(self.realowner.team)
+			switch(this.realowner.team)
 			{
 				case NUM_TEAM_1: expef = EFFECT_SPAWN_RED; break;
 				case NUM_TEAM_2: expef = EFFECT_SPAWN_BLUE; break;
@@ -635,43 +635,43 @@ void nade_boom()
 
 		default:
 		case NADE_TYPE_NORMAL:
-			expef = EFFECT_NADE_EXPLODE(self.realowner.team);
+			expef = EFFECT_NADE_EXPLODE(this.realowner.team);
 			break;
 	}
 
 	if(expef)
-		Send_Effect(expef, findbetterlocation(self.origin, 8), '0 0 0', 1);
+		Send_Effect(expef, findbetterlocation(this.origin, 8), '0 0 0', 1);
 
-	sound(self, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM);
-	sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
+	sound(this, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM);
+	sound(this, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
 
-	self.event_damage = func_null; // prevent somehow calling damage in the next call
+	this.event_damage = func_null; // prevent somehow calling damage in the next call
 
 	if(nade_blast)
 	{
-		RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
-				 autocvar_g_nades_nade_radius, self, world, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy);
-		Damage_DamageInfo(self.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, self.projectiledeathtype, 0, self);
+		RadiusDamage(this, this.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
+				 autocvar_g_nades_nade_radius, this, world, autocvar_g_nades_nade_force, this.projectiledeathtype, this.enemy);
+		Damage_DamageInfo(this.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, this.projectiledeathtype, 0, this);
 	}
 
-	if(self.takedamage)
-	switch ( Nades_from(self.nade_type) )
+	if(this.takedamage)
+	switch ( Nades_from(this.nade_type) )
 	{
-		case NADE_TYPE_NAPALM: nade_napalm_boom(); break;
-		case NADE_TYPE_ICE: nade_ice_boom(); break;
-		case NADE_TYPE_TRANSLOCATE: nade_translocate_boom(); break;
-		case NADE_TYPE_SPAWN: nade_spawn_boom(); break;
-		case NADE_TYPE_HEAL: nade_heal_boom(); break;
-		case NADE_TYPE_MONSTER: nade_monster_boom(); break;
+		case NADE_TYPE_NAPALM: nade_napalm_boom(this); break;
+		case NADE_TYPE_ICE: nade_ice_boom(this); break;
+		case NADE_TYPE_TRANSLOCATE: nade_translocate_boom(this); break;
+		case NADE_TYPE_SPAWN: nade_spawn_boom(this); break;
+		case NADE_TYPE_HEAL: nade_heal_boom(this); break;
+		case NADE_TYPE_MONSTER: nade_monster_boom(this); break;
 	}
 
-	FOREACH_ENTITY_ENT(aiment, self,
+	FOREACH_ENTITY_ENT(aiment, this,
 	{
 		if(it.classname == "grapplinghook")
 			RemoveGrapplingHook(it.realowner);
 	});
 
-	remove(self);
+	remove(this);
 }
 
 void spawn_held_nade(entity player, entity nowner, float ntime, int ntype, string pntype);
@@ -740,9 +740,9 @@ void nade_touch()
 
 void nade_beep()
 {SELFPARAM();
-	sound(self, CH_SHOTS_SINGLE, SND_NADE_BEEP, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX));
-	self.think = nade_boom;
-	self.nextthink = max(self.wait, time);
+	sound(this, CH_SHOTS_SINGLE, SND_NADE_BEEP, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX));
+	this.think = nade_boom;
+	this.nextthink = max(this.wait, time);
 }
 
 void nade_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)