X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fturrets%2Fsv_turrets.qc;h=1f8450f3951b07ed0595c523a7241777d6c26013;hb=5972fcfdf1ffe5bef1df9edc2de2944abbeba280;hp=a06fbcbb96392c24fdc53b5b07573a4c48167318;hpb=7bcb3a89b3271e018da4d92437dc5ba125ea8698;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/turrets/sv_turrets.qc b/qcsrc/common/turrets/sv_turrets.qc
index a06fbcbb9..1f8450f39 100644
--- a/qcsrc/common/turrets/sv_turrets.qc
+++ b/qcsrc/common/turrets/sv_turrets.qc
@@ -2,41 +2,41 @@
 #include <server/autocvars.qh>
 
 // Generic aiming
-vector turret_aim_generic()
-{SELFPARAM();
+vector turret_aim_generic(entity this)
+{
 
 	vector pre_pos, prep;
 	float distance, impact_time = 0, i, mintime;
 
-	turret_tag_fire_update();
+	turret_tag_fire_update(this);
 
-	if(self.aim_flags & TFL_AIM_SIMPLE)
-		return real_origin(self.enemy);
+	if(this.aim_flags & TFL_AIM_SIMPLE)
+		return real_origin(this.enemy);
 
-	mintime = max(self.attack_finished_single[0] - time,0) + sys_frametime;
+	mintime = max(this.attack_finished_single[0] - time,0) + sys_frametime;
 
 	// Baseline
-	pre_pos = real_origin(self.enemy);
+	pre_pos = real_origin(this.enemy);
 
 	// Lead?
-	if (self.aim_flags & TFL_AIM_LEAD)
+	if (this.aim_flags & TFL_AIM_LEAD)
 	{
-		if (self.aim_flags & TFL_AIM_SHOTTIMECOMPENSATE)	   // Need to conpensate for shot traveltime
+		if (this.aim_flags & TFL_AIM_SHOTTIMECOMPENSATE)	   // Need to conpensate for shot traveltime
 		{
 			prep = pre_pos;
 
-			distance = vlen(prep - self.tur_shotorg);
-			impact_time = distance / self.shot_speed;
+			distance = vlen(prep - this.tur_shotorg);
+			impact_time = distance / this.shot_speed;
 
-			prep = pre_pos + (self.enemy.velocity * (impact_time + mintime));
+			prep = pre_pos + (this.enemy.velocity * (impact_time + mintime));
 
-			if(self.aim_flags & TFL_AIM_ZPREDICT)
-			if(!IS_ONGROUND(self.enemy))
-			if(self.enemy.movetype == MOVETYPE_WALK || self.enemy.movetype == MOVETYPE_TOSS || self.enemy.movetype == MOVETYPE_BOUNCE)
+			if(this.aim_flags & TFL_AIM_ZPREDICT)
+			if(!IS_ONGROUND(this.enemy))
+			if(this.enemy.movetype == MOVETYPE_WALK || this.enemy.movetype == MOVETYPE_TOSS || this.enemy.movetype == MOVETYPE_BOUNCE)
 			{
 				float vz;
 				prep_z = pre_pos_z;
-				vz = self.enemy.velocity_z;
+				vz = this.enemy.velocity_z;
 				for(i = 0; i < impact_time; i += sys_frametime)
 				{
 					vz = vz - (autocvar_sv_gravity * sys_frametime);
@@ -46,13 +46,13 @@ vector turret_aim_generic()
 			pre_pos = prep;
 		}
 		else
-			pre_pos = pre_pos + self.enemy.velocity * mintime;
+			pre_pos = pre_pos + this.enemy.velocity * mintime;
 	}
 
-	if(self.aim_flags & TFL_AIM_SPLASH)
+	if(this.aim_flags & TFL_AIM_SPLASH)
 	{
-		//tracebox(pre_pos + '0 0 32',self.enemy.mins,self.enemy.maxs,pre_pos -'0 0 64',MOVE_WORLDONLY,self.enemy);
-		traceline(pre_pos + '0 0 32',pre_pos -'0 0 64',MOVE_WORLDONLY,self.enemy);
+		//tracebox(pre_pos + '0 0 32',this.enemy.mins,this.enemy.maxs,pre_pos -'0 0 64',MOVE_WORLDONLY,this.enemy);
+		traceline(pre_pos + '0 0 32',pre_pos -'0 0 64',MOVE_WORLDONLY,this.enemy);
 		if(trace_fraction != 1.0)
 			pre_pos = trace_endpos;
 	}
@@ -164,46 +164,46 @@ float turret_targetscore_generic(entity _turret, entity _target)
 }
 
 // Generic damage handling
-void turret_hide()
-{SELFPARAM();
-	self.effects   |= EF_NODRAW;
-	self.nextthink = time + self.respawntime - 0.2;
-	self.think	 = turret_respawn;
+void turret_hide(entity this)
+{
+	this.effects   |= EF_NODRAW;
+	this.nextthink = time + this.respawntime - 0.2;
+	setthink(this, turret_respawn);
 }
 
-void turret_die()
-{SELFPARAM();
-	self.deadflag		  = DEAD_DEAD;
-	self.tur_head.deadflag = self.deadflag;
+void turret_die(entity this)
+{
+	this.deadflag		  = DEAD_DEAD;
+	this.tur_head.deadflag = this.deadflag;
 
 // Unsolidify and hide real parts
-	self.solid			 = SOLID_NOT;
-	self.tur_head.solid	 = self.solid;
+	this.solid			 = SOLID_NOT;
+	this.tur_head.solid	 = this.solid;
 
-	self.event_damage		  = func_null;
-	self.takedamage			 = DAMAGE_NO;
+	this.event_damage		  = func_null;
+	this.takedamage			 = DAMAGE_NO;
 
-	self.health			 = 0;
+	this.health			 = 0;
 
 // Go boom
-	//RadiusDamage (self,self, min(self.ammo,50),min(self.ammo,50) * 0.25,250,world,min(self.ammo,50)*5,DEATH_TURRET,world);
+	//RadiusDamage (this,this, min(this.ammo,50),min(this.ammo,50) * 0.25,250,NULL,min(this.ammo,50)*5,DEATH_TURRET,NULL);
 
-	Turret tur = get_turretinfo(self.m_id);
-	if(self.damage_flags & TFL_DMG_DEATH_NORESPAWN)
+	Turret tur = get_turretinfo(this.m_id);
+	if(this.damage_flags & TFL_DMG_DEATH_NORESPAWN)
 	{
-		tur.tr_death(tur, self);
+		tur.tr_death(tur, this);
 
-		remove(self.tur_head);
-		remove(self);
+		remove(this.tur_head);
+		remove(this);
 	}
 	else
 	{
 		// Setup respawn
-		self.SendFlags	  |= TNSF_STATUS;
-		self.nextthink	 = time + 0.2;
-		self.think		 = turret_hide;
+		this.SendFlags	  |= TNSF_STATUS;
+		this.nextthink	 = time + 0.2;
+		setthink(this, turret_hide);
 
-		tur.tr_death(tur, self);
+		tur.tr_death(tur, this);
 	}
 }
 
@@ -245,57 +245,57 @@ void turret_damage(entity this, entity inflictor, entity attacker, float damage,
 		this.tur_head.event_damage = func_null;
 		this.takedamage			 = DAMAGE_NO;
 		this.nextthink = time;
-		this.think = turret_die;
+		setthink(this, turret_die);
 	}
 
 	this.SendFlags  |= TNSF_STATUS;
 }
 
-void() turret_think;
-void turret_respawn()
-{SELFPARAM();
+void turret_think(entity this);
+void turret_respawn(entity this)
+{
 	// Make sure all parts belong to the same team since
 	// this function doubles as "teamchange" function.
-	self.tur_head.team 	= self.team;
-	self.effects			   &= ~EF_NODRAW;
-	self.deadflag				= DEAD_NO;
-	self.effects				= EF_LOWPRECISION;
-	self.solid					= SOLID_BBOX;
-	self.takedamage 			= DAMAGE_AIM;
-	self.event_damage			= turret_damage;
-	self.avelocity				= '0 0 0';
-	self.tur_head.avelocity		= self.avelocity;
-	self.tur_head.angles		= self.idle_aim;
-	self.health					= self.max_health;
-	self.enemy					= world;
-	self.volly_counter			= self.shot_volly;
-	self.ammo					= self.ammo_max;
-
-	self.nextthink = time + self.ticrate;
-	self.think	 = turret_think;
-
-	self.SendFlags = TNSF_FULL_UPDATE;
-
-	Turret tur = get_turretinfo(self.m_id);
-	tur.tr_setup(tur, self);
+	this.tur_head.team 	= this.team;
+	this.effects			   &= ~EF_NODRAW;
+	this.deadflag				= DEAD_NO;
+	this.effects				= EF_LOWPRECISION;
+	this.solid					= SOLID_BBOX;
+	this.takedamage 			= DAMAGE_AIM;
+	this.event_damage			= turret_damage;
+	this.avelocity				= '0 0 0';
+	this.tur_head.avelocity		= this.avelocity;
+	this.tur_head.angles		= this.idle_aim;
+	this.health					= this.max_health;
+	this.enemy					= NULL;
+	this.volly_counter			= this.shot_volly;
+	this.ammo					= this.ammo_max;
+
+	this.nextthink = time + this.ticrate;
+	setthink(this, turret_think);
+
+	this.SendFlags = TNSF_FULL_UPDATE;
+
+	Turret tur = get_turretinfo(this.m_id);
+	tur.tr_setup(tur, this);
 }
 
 
 // Main functions
 #define cvar_base "g_turrets_unit_"
 .float clientframe;
-void turrets_setframe(float _frame, float client_only)
-{SELFPARAM();
-	if((client_only ? self.clientframe : self.frame ) != _frame)
+void turrets_setframe(entity this, float _frame, float client_only)
+{
+	if((client_only ? this.clientframe : this.frame ) != _frame)
 	{
-		self.SendFlags |= TNSF_ANIM;
-		self.anim_start_time = time;
+		this.SendFlags |= TNSF_ANIM;
+		this.anim_start_time = time;
 	}
 
 	 if(client_only)
-		self.clientframe = _frame;
+		this.clientframe = _frame;
 	else
-		self.frame = _frame;
+		this.frame = _frame;
 
 }
 
@@ -306,66 +306,66 @@ bool turret_send(entity this, entity to, float sf)
 	WriteByte(MSG_ENTITY, sf);
 	if(sf & TNSF_SETUP)
 	{
-		WriteByte(MSG_ENTITY, self.m_id);
+		WriteByte(MSG_ENTITY, this.m_id);
 
-		WriteCoord(MSG_ENTITY, self.origin_x);
-		WriteCoord(MSG_ENTITY, self.origin_y);
-		WriteCoord(MSG_ENTITY, self.origin_z);
+		WriteCoord(MSG_ENTITY, this.origin_x);
+		WriteCoord(MSG_ENTITY, this.origin_y);
+		WriteCoord(MSG_ENTITY, this.origin_z);
 
-		WriteAngle(MSG_ENTITY, self.angles_x);
-		WriteAngle(MSG_ENTITY, self.angles_y);
+		WriteAngle(MSG_ENTITY, this.angles_x);
+		WriteAngle(MSG_ENTITY, this.angles_y);
 	}
 
 	if(sf & TNSF_ANG)
 	{
-		WriteShort(MSG_ENTITY, rint(self.tur_head.angles_x));
-		WriteShort(MSG_ENTITY, rint(self.tur_head.angles_y));
+		WriteShort(MSG_ENTITY, rint(this.tur_head.angles_x));
+		WriteShort(MSG_ENTITY, rint(this.tur_head.angles_y));
 	}
 
 	if(sf & TNSF_AVEL)
 	{
-		WriteShort(MSG_ENTITY, rint(self.tur_head.avelocity_x));
-		WriteShort(MSG_ENTITY, rint(self.tur_head.avelocity_y));
+		WriteShort(MSG_ENTITY, rint(this.tur_head.avelocity_x));
+		WriteShort(MSG_ENTITY, rint(this.tur_head.avelocity_y));
 	}
 
 	if(sf & TNSF_MOVE)
 	{
-		WriteShort(MSG_ENTITY, rint(self.origin_x));
-		WriteShort(MSG_ENTITY, rint(self.origin_y));
-		WriteShort(MSG_ENTITY, rint(self.origin_z));
+		WriteShort(MSG_ENTITY, rint(this.origin_x));
+		WriteShort(MSG_ENTITY, rint(this.origin_y));
+		WriteShort(MSG_ENTITY, rint(this.origin_z));
 
-		WriteShort(MSG_ENTITY, rint(self.velocity_x));
-		WriteShort(MSG_ENTITY, rint(self.velocity_y));
-		WriteShort(MSG_ENTITY, rint(self.velocity_z));
+		WriteShort(MSG_ENTITY, rint(this.velocity_x));
+		WriteShort(MSG_ENTITY, rint(this.velocity_y));
+		WriteShort(MSG_ENTITY, rint(this.velocity_z));
 
-		WriteShort(MSG_ENTITY, rint(self.angles_y));
+		WriteShort(MSG_ENTITY, rint(this.angles_y));
 	}
 
 	if(sf & TNSF_ANIM)
 	{
-		WriteCoord(MSG_ENTITY, self.anim_start_time);
-		WriteByte(MSG_ENTITY, self.frame);
+		WriteCoord(MSG_ENTITY, this.anim_start_time);
+		WriteByte(MSG_ENTITY, this.frame);
 	}
 
 	if(sf & TNSF_STATUS)
 	{
-		WriteByte(MSG_ENTITY, self.team);
+		WriteByte(MSG_ENTITY, this.team);
 
-		if(self.health <= 0)
+		if(this.health <= 0)
 			WriteByte(MSG_ENTITY, 0);
 		else
-			WriteByte(MSG_ENTITY, ceil((self.health / self.max_health) * 255));
+			WriteByte(MSG_ENTITY, ceil((this.health / this.max_health) * 255));
 	}
 
 	return true;
 }
 
 void load_unit_settings(entity ent, bool is_reload)
-{SELFPARAM();
+{
 	string unitname = ent.netname;
 	string sbase;
 
-	if (ent == world)
+	if (ent == NULL)
 		return;
 
 	if(!ent.turret_scale_damage)	ent.turret_scale_damage = 1;
@@ -379,7 +379,7 @@ void load_unit_settings(entity ent, bool is_reload)
 	sbase = strcat(cvar_base,unitname);
 	if (is_reload)
 	{
-		ent.enemy = world;
+		ent.enemy = NULL;
 		ent.tur_head.avelocity = '0 0 0';
 
 		ent.tur_head.angles = '0 0 0';
@@ -422,31 +422,31 @@ void load_unit_settings(entity ent, bool is_reload)
 	ent.track_blendrate  = cvar(strcat(sbase,"_track_blendrate"));
 
 	if(is_reload) {
-		Turret tur = get_turretinfo(self.m_id);
-		tur.tr_setup(tur, self);
+		Turret tur = get_turretinfo(ent.m_id);
+		tur.tr_setup(tur, ent);
 	}
 }
 
-void turret_projectile_explode()
-{SELFPARAM();
+void turret_projectile_explode(entity this)
+{
 
-	self.takedamage = DAMAGE_NO;
-	self.event_damage = func_null;
+	this.takedamage = DAMAGE_NO;
+	this.event_damage = func_null;
 #ifdef TURRET_DEBUG
 	float d;
-	d = RadiusDamage (self, self.owner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, world, self.owner.shot_force, self.totalfrags, world);
-	self.owner.tur_debug_dmg_t_h = self.owner.tur_debug_dmg_t_h + d;
-	self.owner.tur_debug_dmg_t_f = self.owner.tur_debug_dmg_t_f + self.owner.shot_dmg;
+	d = RadiusDamage (this, this.owner, this.owner.shot_dmg, 0, this.owner.shot_radius, this, NULL, this.owner.shot_force, this.totalfrags, NULL);
+	this.owner.tur_debug_dmg_t_h = this.owner.tur_debug_dmg_t_h + d;
+	this.owner.tur_debug_dmg_t_f = this.owner.tur_debug_dmg_t_f + this.owner.shot_dmg;
 #else
-	RadiusDamage (self, self.realowner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, world, self.owner.shot_force, self.totalfrags, world);
+	RadiusDamage (this, this.realowner, this.owner.shot_dmg, 0, this.owner.shot_radius, this, NULL, this.owner.shot_force, this.totalfrags, NULL);
 #endif
-	remove(self);
+	remove(this);
 }
 
-void turret_projectile_touch()
+void turret_projectile_touch(entity this, entity toucher)
 {
-	PROJECTILE_TOUCH;
-	turret_projectile_explode();
+	PROJECTILE_TOUCH(this, toucher);
+	turret_projectile_explode(this);
 }
 
 void turret_projectile_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce)
@@ -455,28 +455,29 @@ void turret_projectile_damage(entity this, entity inflictor, entity attacker, fl
 	this.health	-= damage;
 	//this.realowner = attacker; // Dont change realowner, it does not make much sense for turrets
 	if(this.health <= 0)
-		WITH(entity, self, this, W_PrepareExplosionByDamage(this.owner, turret_projectile_explode));
+		W_PrepareExplosionByDamage(this, this.owner, turret_projectile_explode);
 }
 
-entity turret_projectile(string _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim)
-{SELFPARAM();
+entity turret_projectile(entity actor, Sound _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim)
+{
+    TC(Sound, _snd);
 	entity proj;
 
-	_sound (self, CH_WEAPON_A, _snd, VOL_BASE, ATTEN_NORM);
+	sound (actor, CH_WEAPON_A, _snd, VOL_BASE, ATTEN_NORM);
 	proj				 = spawn ();
-	setorigin(proj, self.tur_shotorg);
+	setorigin(proj, actor.tur_shotorg);
 	setsize(proj, '-0.5 -0.5 -0.5' * _size, '0.5 0.5 0.5' * _size);
-	proj.owner		  = self;
-	proj.realowner	  = self;
+	proj.owner		  = actor;
+	proj.realowner	  = actor;
 	proj.bot_dodge	  = true;
-	proj.bot_dodgerating = self.shot_dmg;
-	proj.think		  = turret_projectile_explode;
-	proj.touch		  = turret_projectile_touch;
+	proj.bot_dodgerating = actor.shot_dmg;
+	setthink(proj, turret_projectile_explode);
+	settouch(proj, turret_projectile_touch);
 	proj.nextthink	  = time + 9;
 	proj.movetype		= MOVETYPE_FLYMISSILE;
-	proj.velocity		= normalize(self.tur_shotdir_updated + randomvec() * self.shot_spread) * self.shot_speed;
+	proj.velocity		= normalize(actor.tur_shotdir_updated + randomvec() * actor.shot_spread) * actor.shot_speed;
 	proj.flags		  = FL_PROJECTILE;
-	proj.enemy		  = self.enemy;
+	proj.enemy		  = actor.enemy;
 	proj.totalfrags	 = _death;
 	PROJECTILE_MAKETRIGGER(proj);
 	if(_health)
@@ -498,39 +499,33 @@ entity turret_projectile(string _snd, float _size, float _health, float _death,
 ** and updated aim<->predict impact distance.
 **/
 void turret_do_updates(entity t_turret)
-{SELFPARAM();
-	vector enemy_pos;
-
-	setself(t_turret);
-
-	enemy_pos = real_origin(self.enemy);
+{
+	vector enemy_pos = real_origin(t_turret.enemy);
 
-	turret_tag_fire_update();
+	turret_tag_fire_update(t_turret);
 
-	self.tur_shotdir_updated = v_forward;
-	self.tur_dist_enemy = vlen(self.tur_shotorg - enemy_pos);
-	self.tur_dist_aimpos = vlen(self.tur_shotorg - self.tur_aimpos);
+	t_turret.tur_shotdir_updated = v_forward;
+	t_turret.tur_dist_enemy = vlen(t_turret.tur_shotorg - enemy_pos);
+	t_turret.tur_dist_aimpos = vlen(t_turret.tur_shotorg - t_turret.tur_aimpos);
 
-	/*if((self.firecheck_flags & TFL_FIRECHECK_VERIFIED) && (self.enemy))
+	/*if((t_turret.firecheck_flags & TFL_FIRECHECK_VERIFIED) && (t_turret.enemy))
 	{
-		oldpos = self.enemy.origin;
-		setorigin(self.enemy, self.tur_aimpos);
-		tracebox(self.tur_shotorg, '-1 -1 -1', '1 1 1', self.tur_shotorg + (self.tur_shotdir_updated * self.tur_dist_aimpos), MOVE_NORMAL,self);
-		setorigin(self.enemy, oldpos);
+		oldpos = t_turret.enemy.origin;
+		setorigin(t_turret.enemy, t_turret.tur_aimpos);
+		tracebox(t_turret.tur_shotorg, '-1 -1 -1', '1 1 1', t_turret.tur_shotorg + (t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos), MOVE_NORMAL,t_turret);
+		setorigin(t_turret.enemy, oldpos);
 
-		if(trace_ent == self.enemy)
-			self.tur_dist_impact_to_aimpos = 0;
+		if(trace_ent == t_turret.enemy)
+			t_turret.tur_dist_impact_to_aimpos = 0;
 		else
-			self.tur_dist_impact_to_aimpos = vlen(trace_endpos - self.tur_aimpos);
+			t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos);
 	}
 	else*/
-		tracebox(self.tur_shotorg, '-1 -1 -1','1 1 1', self.tur_shotorg + (self.tur_shotdir_updated * self.tur_dist_aimpos), MOVE_NORMAL,self);
-
-	self.tur_dist_impact_to_aimpos = vlen(trace_endpos - self.tur_aimpos) - (vlen(self.enemy.maxs - self.enemy.mins) * 0.5);
-	self.tur_impactent			 = trace_ent;
-	self.tur_impacttime			= vlen(self.tur_shotorg - trace_endpos) / self.shot_speed;
+		tracebox(t_turret.tur_shotorg, '-1 -1 -1','1 1 1', t_turret.tur_shotorg + (t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos), MOVE_NORMAL,t_turret);
 
-	setself(this);
+	t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos) - (vlen(t_turret.enemy.maxs - t_turret.enemy.mins) * 0.5);
+	t_turret.tur_impactent			 = trace_ent;
+	t_turret.tur_impacttime			= vlen(t_turret.tur_shotorg - trace_endpos) / t_turret.shot_speed;
 }
 
 /**
@@ -538,137 +533,137 @@ void turret_do_updates(entity t_turret)
 ** the units .track_type and .track_flags
 **/
 .float turret_framecounter;
-void turret_track()
-{SELFPARAM();
+void turret_track(entity this)
+{
 	vector target_angle; // This is where we want to aim
 	vector move_angle;   // This is where we can aim
 	float f_tmp;
 	vector v1, v2;
-	v1 = self.tur_head.angles;
-	v2 = self.tur_head.avelocity;
+	v1 = this.tur_head.angles;
+	v2 = this.tur_head.avelocity;
 
-	if (self.track_flags == TFL_TRACK_NO)
+	if (this.track_flags == TFL_TRACK_NO)
 		return;
 
-	if(!self.active)
-		target_angle = self.idle_aim - ('1 0 0' * self.aim_maxpitch);
-	else if (self.enemy == world)
+	if(!this.active)
+		target_angle = this.idle_aim - ('1 0 0' * this.aim_maxpitch);
+	else if (this.enemy == NULL)
 	{
-		if(time > self.lip)
-			target_angle = self.idle_aim + self.angles;
+		if(time > this.lip)
+			target_angle = this.idle_aim + this.angles;
 		else
-			target_angle = vectoangles(normalize(self.tur_aimpos - self.tur_shotorg));
+			target_angle = vectoangles(normalize(this.tur_aimpos - this.tur_shotorg));
 	}
 	else
 	{
-		target_angle = vectoangles(normalize(self.tur_aimpos - self.tur_shotorg));
+		target_angle = vectoangles(normalize(this.tur_aimpos - this.tur_shotorg));
 	}
 
-	self.tur_head.angles_x = anglemods(self.tur_head.angles_x);
-	self.tur_head.angles_y = anglemods(self.tur_head.angles_y);
+	this.tur_head.angles_x = anglemods(this.tur_head.angles_x);
+	this.tur_head.angles_y = anglemods(this.tur_head.angles_y);
 
 	// Find the diffrence between where we currently aim and where we want to aim
-	//move_angle = target_angle - (self.angles + self.tur_head.angles);
-	//move_angle = shortangle_vxy(move_angle,(self.angles + self.tur_head.angles));
+	//move_angle = target_angle - (this.angles + this.tur_head.angles);
+	//move_angle = shortangle_vxy(move_angle,(this.angles + this.tur_head.angles));
 
-	move_angle = AnglesTransform_ToAngles(AnglesTransform_LeftDivide(AnglesTransform_FromAngles(self.angles), AnglesTransform_FromAngles(target_angle))) - self.tur_head.angles;
-	move_angle = shortangle_vxy(move_angle, self.tur_head.angles);
+	move_angle = AnglesTransform_ToAngles(AnglesTransform_LeftDivide(AnglesTransform_FromAngles(this.angles), AnglesTransform_FromAngles(target_angle))) - this.tur_head.angles;
+	move_angle = shortangle_vxy(move_angle, this.tur_head.angles);
 
-	switch(self.track_type)
+	switch(this.track_type)
 	{
 		case TFL_TRACKTYPE_STEPMOTOR:
-			f_tmp = self.aim_speed * self.ticrate; // dgr/sec -> dgr/tic
-			if (self.track_flags & TFL_TRACK_PITCH)
+			f_tmp = this.aim_speed * this.ticrate; // dgr/sec -> dgr/tic
+			if (this.track_flags & TFL_TRACK_PITCH)
 			{
-				self.tur_head.angles_x += bound(-f_tmp,move_angle_x, f_tmp);
-				if(self.tur_head.angles_x > self.aim_maxpitch)
-					self.tur_head.angles_x = self.aim_maxpitch;
+				this.tur_head.angles_x += bound(-f_tmp,move_angle_x, f_tmp);
+				if(this.tur_head.angles_x > this.aim_maxpitch)
+					this.tur_head.angles_x = this.aim_maxpitch;
 
-				if(self.tur_head.angles_x  < -self.aim_maxpitch)
-					self.tur_head.angles_x = self.aim_maxpitch;
+				if(this.tur_head.angles_x  < -this.aim_maxpitch)
+					this.tur_head.angles_x = this.aim_maxpitch;
 			}
 
-			if (self.track_flags & TFL_TRACK_ROTATE)
+			if (this.track_flags & TFL_TRACK_ROTATE)
 			{
-				self.tur_head.angles_y += bound(-f_tmp, move_angle_y, f_tmp);
-				if(self.tur_head.angles_y > self.aim_maxrotate)
-					self.tur_head.angles_y = self.aim_maxrotate;
+				this.tur_head.angles_y += bound(-f_tmp, move_angle_y, f_tmp);
+				if(this.tur_head.angles_y > this.aim_maxrotate)
+					this.tur_head.angles_y = this.aim_maxrotate;
 
-				if(self.tur_head.angles_y  < -self.aim_maxrotate)
-					self.tur_head.angles_y = self.aim_maxrotate;
+				if(this.tur_head.angles_y  < -this.aim_maxrotate)
+					this.tur_head.angles_y = this.aim_maxrotate;
 			}
 
 			// CSQC
-			self.SendFlags  |= TNSF_ANG;
+			this.SendFlags  |= TNSF_ANG;
 
 			return;
 
 		case TFL_TRACKTYPE_FLUIDINERTIA:
-			f_tmp = self.aim_speed * self.ticrate; // dgr/sec -> dgr/tic
-			move_angle_x = bound(-self.aim_speed, move_angle_x * self.track_accel_pitch * f_tmp, self.aim_speed);
-			move_angle_y = bound(-self.aim_speed, move_angle_y * self.track_accel_rotate * f_tmp, self.aim_speed);
-			move_angle = (self.tur_head.avelocity * self.track_blendrate) + (move_angle * (1 - self.track_blendrate));
+			f_tmp = this.aim_speed * this.ticrate; // dgr/sec -> dgr/tic
+			move_angle_x = bound(-this.aim_speed, move_angle_x * this.track_accel_pitch * f_tmp, this.aim_speed);
+			move_angle_y = bound(-this.aim_speed, move_angle_y * this.track_accel_rotate * f_tmp, this.aim_speed);
+			move_angle = (this.tur_head.avelocity * this.track_blendrate) + (move_angle * (1 - this.track_blendrate));
 			break;
 
 		case TFL_TRACKTYPE_FLUIDPRECISE:
 
-			move_angle_y = bound(-self.aim_speed, move_angle_y, self.aim_speed);
-			move_angle_x = bound(-self.aim_speed, move_angle_x, self.aim_speed);
+			move_angle_y = bound(-this.aim_speed, move_angle_y, this.aim_speed);
+			move_angle_x = bound(-this.aim_speed, move_angle_x, this.aim_speed);
 
 			break;
 	}
 
 	//  pitch
-	if (self.track_flags & TFL_TRACK_PITCH)
+	if (this.track_flags & TFL_TRACK_PITCH)
 	{
-		self.tur_head.avelocity_x = move_angle_x;
-		if((self.tur_head.angles_x + self.tur_head.avelocity_x * self.ticrate) > self.aim_maxpitch)
+		this.tur_head.avelocity_x = move_angle_x;
+		if((this.tur_head.angles_x + this.tur_head.avelocity_x * this.ticrate) > this.aim_maxpitch)
 		{
-			self.tur_head.avelocity_x = 0;
-			self.tur_head.angles_x = self.aim_maxpitch;
+			this.tur_head.avelocity_x = 0;
+			this.tur_head.angles_x = this.aim_maxpitch;
 
-			self.SendFlags  |= TNSF_ANG;
+			this.SendFlags  |= TNSF_ANG;
 		}
 
-		if((self.tur_head.angles_x + self.tur_head.avelocity_x * self.ticrate) < -self.aim_maxpitch)
+		if((this.tur_head.angles_x + this.tur_head.avelocity_x * this.ticrate) < -this.aim_maxpitch)
 		{
-			self.tur_head.avelocity_x = 0;
-			self.tur_head.angles_x = -self.aim_maxpitch;
+			this.tur_head.avelocity_x = 0;
+			this.tur_head.angles_x = -this.aim_maxpitch;
 
-			self.SendFlags  |= TNSF_ANG;
+			this.SendFlags  |= TNSF_ANG;
 		}
 	}
 
 	//  rot
-	if (self.track_flags & TFL_TRACK_ROTATE)
+	if (this.track_flags & TFL_TRACK_ROTATE)
 	{
-		self.tur_head.avelocity_y = move_angle_y;
+		this.tur_head.avelocity_y = move_angle_y;
 
-		if((self.tur_head.angles_y + self.tur_head.avelocity_y * self.ticrate) > self.aim_maxrotate)
+		if((this.tur_head.angles_y + this.tur_head.avelocity_y * this.ticrate) > this.aim_maxrotate)
 		{
-			self.tur_head.avelocity_y = 0;
-			self.tur_head.angles_y = self.aim_maxrotate;
+			this.tur_head.avelocity_y = 0;
+			this.tur_head.angles_y = this.aim_maxrotate;
 
-			self.SendFlags  |= TNSF_ANG;
+			this.SendFlags  |= TNSF_ANG;
 		}
 
-		if((self.tur_head.angles_y + self.tur_head.avelocity_y * self.ticrate) < -self.aim_maxrotate)
+		if((this.tur_head.angles_y + this.tur_head.avelocity_y * this.ticrate) < -this.aim_maxrotate)
 		{
-			self.tur_head.avelocity_y = 0;
-			self.tur_head.angles_y = -self.aim_maxrotate;
+			this.tur_head.avelocity_y = 0;
+			this.tur_head.angles_y = -this.aim_maxrotate;
 
-			self.SendFlags  |= TNSF_ANG;
+			this.SendFlags  |= TNSF_ANG;
 		}
 	}
 
-	self.SendFlags  |= TNSF_AVEL;
+	this.SendFlags  |= TNSF_AVEL;
 
 	// Force a angle update every 10'th frame
-	self.turret_framecounter += 1;
-	if(self.turret_framecounter >= 10)
+	this.turret_framecounter += 1;
+	if(this.turret_framecounter >= 10)
 	{
-		self.SendFlags |= TNSF_ANG;
-		self.turret_framecounter = 0;
+		this.SendFlags |= TNSF_ANG;
+		this.turret_framecounter = 0;
 	}
 }
 
@@ -709,7 +704,7 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl
 		return -1;
 
 	if(MUTATOR_CALLHOOK(TurretValidateTarget, e_turret, e_target, validate_flags))
-		return ret_float;
+		return M_ARGV(3, float);
 
 	if (validate_flags & TFL_TARGETSELECT_NO)
 		return -4;
@@ -835,37 +830,37 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl
 	return 1;
 }
 
-entity turret_select_target()
-{SELFPARAM();
+entity turret_select_target(entity this)
+{
 	entity e;		// target looper entity
 	float  score;	// target looper entity score
 	entity e_enemy;  // currently best scoreing target
 	float  m_score;  // currently best scoreing target's score
 
 	m_score = 0;
-	if(self.enemy && self.enemy.takedamage && turret_validate_target(self,self.enemy,self.target_validate_flags) > 0)
+	if(this.enemy && this.enemy.takedamage && turret_validate_target(this,this.enemy,this.target_validate_flags) > 0)
 	{
-		e_enemy = self.enemy;
-		m_score = self.turret_score_target(self,e_enemy) * self.target_select_samebias;
+		e_enemy = this.enemy;
+		m_score = this.turret_score_target(this,e_enemy) * this.target_select_samebias;
 	}
 	else
-		e_enemy = self.enemy = world;
+		e_enemy = this.enemy = NULL;
 
-	e = findradius(self.origin, self.target_range);
+	e = findradius(this.origin, this.target_range);
 
 	// Nothing to aim at?
 	if (!e)
-		return world;
+		return NULL;
 
 	while (e)
 	{
 		if(e.takedamage)
 		{
-			float f = turret_validate_target(self, e, self.target_select_flags);
+			float f = turret_validate_target(this, e, this.target_select_flags);
 			//dprint("F is: ", ftos(f), "\n");
 			if ( f > 0)
 			{
-				score = self.turret_score_target(self,e);
+				score = this.turret_score_target(this,e);
 				if ((score > m_score) && (score > 0))
 				{
 					e_enemy = e;
@@ -902,213 +897,212 @@ entity turret_select_target()
 /**
 ** Preforms pre-fire checks based on the uints firecheck_flags
 **/
-float turret_firecheck()
-{SELFPARAM();
+bool turret_firecheck(entity this)
+{
 	// This one just dont care =)
-	if (self.firecheck_flags & TFL_FIRECHECK_NO)
-		return 1;
+	if (this.firecheck_flags & TFL_FIRECHECK_NO)
+		return true;
 
-	if (self.enemy == world)
-		return 0;
+	if (this.enemy == NULL)
+		return false;
 
 	// Ready?
-	if (self.firecheck_flags & TFL_FIRECHECK_REFIRE)
-		if (self.attack_finished_single[0] > time) return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_REFIRE)
+		if (this.attack_finished_single[0] > time) return false;
 
 	// Special case: volly fire turret that has to fire a full volly if a shot was fired.
-	if (self.shoot_flags & TFL_SHOOT_VOLLYALWAYS)
-		if (self.volly_counter != self.shot_volly)
-			if(self.ammo >= self.shot_dmg)
-				return 1;
+	if (this.shoot_flags & TFL_SHOOT_VOLLYALWAYS)
+		if (this.volly_counter != this.shot_volly)
+			if(this.ammo >= this.shot_dmg)
+				return true;
 
 	// Lack of zombies makes shooting dead things unnecessary :P
-	if (self.firecheck_flags & TFL_FIRECHECK_DEAD)
-		if (IS_DEAD(self.enemy))
-			return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_DEAD)
+		if (IS_DEAD(this.enemy))
+			return false;
 
 	// Own ammo?
-	if (self.firecheck_flags & TFL_FIRECHECK_AMMO_OWN)
-		if (self.ammo < self.shot_dmg)
-			return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_AMMO_OWN)
+		if (this.ammo < this.shot_dmg)
+			return false;
 
 	// Other's ammo? (support-supply units)
-	if (self.firecheck_flags & TFL_FIRECHECK_AMMO_OTHER)
-		if (self.enemy.ammo >= self.enemy.ammo_max)
-			return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_AMMO_OTHER)
+		if (this.enemy.ammo >= this.enemy.ammo_max)
+			return false;
 
 	// Target of opertunity?
-	if(turret_validate_target(self, self.tur_impactent, self.target_validate_flags) > 0)
+	if(turret_validate_target(this, this.tur_impactent, this.target_validate_flags) > 0)
 	{
-		self.enemy = self.tur_impactent;
-		return 1;
+		this.enemy = this.tur_impactent;
+		return true;
 	}
 
-	if (self.firecheck_flags & TFL_FIRECHECK_DISTANCES)
+	if (this.firecheck_flags & TFL_FIRECHECK_DISTANCES)
 	{
 		// To close?
-		if (self.tur_dist_aimpos < self.target_range_min)
-			if(turret_validate_target(self, self.tur_impactent, self.target_validate_flags) > 0)
-				return 1; // Target of opertunity?
+		if (this.tur_dist_aimpos < this.target_range_min)
+			if(turret_validate_target(this, this.tur_impactent, this.target_validate_flags) > 0)
+				return true; // Target of opertunity?
 			else
-				return 0;
+				return false;
 	}
 
 	// Try to avoid FF?
-	if (self.firecheck_flags & TFL_FIRECHECK_AFF)
-		if (self.tur_impactent.team == self.team)
-			return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_AFF)
+		if (this.tur_impactent.team == this.team)
+			return false;
 
 	// aim<->predicted impact
-	if (self.firecheck_flags & TFL_FIRECHECK_AIMDIST)
-		if (self.tur_dist_impact_to_aimpos > self.aim_firetolerance_dist)
-			return 0;
+	if (this.firecheck_flags & TFL_FIRECHECK_AIMDIST)
+		if (this.tur_dist_impact_to_aimpos > this.aim_firetolerance_dist)
+			return false;
 
 	// Volly status
-	if (self.shot_volly > 1)
-		if (self.volly_counter == self.shot_volly)
-			if (self.ammo < (self.shot_dmg * self.shot_volly))
-				return 0;
+	if (this.shot_volly > 1)
+		if (this.volly_counter == this.shot_volly)
+			if (this.ammo < (this.shot_dmg * this.shot_volly))
+				return false;
 
-	/*if(self.firecheck_flags & TFL_FIRECHECK_VERIFIED)
-		if(self.tur_impactent != self.enemy)
-			return 0;*/
+	/*if(this.firecheck_flags & TFL_FIRECHECK_VERIFIED)
+		if(this.tur_impactent != this.enemy)
+			return false;*/
 
-	return 1;
+	return true;
 }
 
-bool turret_checkfire()
-{SELFPARAM();
-	bool ret = false; // dummy
-	if(MUTATOR_CALLHOOK(Turret_CheckFire, ret))
-		return ret_bool;
+bool turret_checkfire(entity this)
+{
+	if(MUTATOR_CALLHOOK(Turret_CheckFire, this))
+		return M_ARGV(1, bool);
 
-	return self.turret_firecheckfunc();
+	return this.turret_firecheckfunc(this);
 }
 
-void turret_fire()
-{SELFPARAM();
+void turret_fire(entity this)
+{
 	if (autocvar_g_turrets_nofire != 0)
 		return;
 
-	if(MUTATOR_CALLHOOK(TurretFire, self))
+	if(MUTATOR_CALLHOOK(TurretFire, this))
 		return;
 
-	Turret info = get_turretinfo(self.m_id);
-	info.tr_attack(info, self);
+	Turret info = get_turretinfo(this.m_id);
+	info.tr_attack(info, this);
 
-	self.attack_finished_single[0] = time + self.shot_refire;
-	self.ammo -= self.shot_dmg;
-	self.volly_counter = self.volly_counter - 1;
+	this.attack_finished_single[0] = time + this.shot_refire;
+	this.ammo -= this.shot_dmg;
+	this.volly_counter = this.volly_counter - 1;
 
-	if (self.volly_counter <= 0)
+	if (this.volly_counter <= 0)
 	{
-		self.volly_counter = self.shot_volly;
+		this.volly_counter = this.shot_volly;
 
-		if (self.shoot_flags & TFL_SHOOT_CLEARTARGET)
-			self.enemy = world;
+		if (this.shoot_flags & TFL_SHOOT_CLEARTARGET)
+			this.enemy = NULL;
 
-		if (self.shot_volly > 1)
-			self.attack_finished_single[0] = time + self.shot_volly_refire;
+		if (this.shot_volly > 1)
+			this.attack_finished_single[0] = time + this.shot_volly_refire;
 	}
 
 #ifdef TURRET_DEBUG
-	if (self.enemy) paint_target3(self.tur_aimpos, 64, self.tur_debug_rvec, self.tur_impacttime + 0.25);
+	if (this.enemy) paint_target3(this.tur_aimpos, 64, this.tur_debug_rvec, this.tur_impacttime + 0.25);
 #endif
 }
 
-void turret_think()
-{SELFPARAM();
-	self.nextthink = time + self.ticrate;
+void turret_think(entity this)
+{
+	this.nextthink = time + this.ticrate;
 
-	MUTATOR_CALLHOOK(TurretThink, self);
+	MUTATOR_CALLHOOK(TurretThink, this);
 
 #ifdef TURRET_DEBUG
-	if (self.tur_debug_tmr1 < time)
+	if (this.tur_debug_tmr1 < time)
 	{
-		if (self.enemy) paint_target (self.enemy,128,self.tur_debug_rvec,0.9);
-		paint_target(self,256,self.tur_debug_rvec,0.9);
-		self.tur_debug_tmr1 = time + 1;
+		if (this.enemy) paint_target (this.enemy,128,this.tur_debug_rvec,0.9);
+		paint_target(this,256,this.tur_debug_rvec,0.9);
+		this.tur_debug_tmr1 = time + 1;
 	}
 #endif
 
 	// Handle ammo
-	if (!(self.spawnflags & TSF_NO_AMMO_REGEN))
-	if (self.ammo < self.ammo_max)
-		self.ammo = min(self.ammo + self.ammo_recharge, self.ammo_max);
+	if (!(this.spawnflags & TSF_NO_AMMO_REGEN))
+	if (this.ammo < this.ammo_max)
+		this.ammo = min(this.ammo + this.ammo_recharge, this.ammo_max);
 
 	// Inactive turrets needs to run the think loop,
 	// So they can handle animation and wake up if need be.
-	if(!self.active)
+	if(!this.active)
 	{
-		turret_track();
+		turret_track(this);
 		return;
 	}
 
 	// This is typicaly used for zaping every target in range
 	// turret_fusionreactor uses this to recharge friendlys.
-	if (self.shoot_flags & TFL_SHOOT_HITALLVALID)
+	if (this.shoot_flags & TFL_SHOOT_HITALLVALID)
 	{
-		// Do a self.turret_fire for every valid target.
-		entity e = findradius(self.origin,self.target_range);
+		// Do a this.turret_fire for every valid target.
+		entity e = findradius(this.origin,this.target_range);
 		while (e)
 		{
 			if(e.takedamage)
 			{
-				if (turret_validate_target(self,e,self.target_validate_flags))
+				if (turret_validate_target(this,e,this.target_validate_flags))
 				{
-					self.enemy = e;
+					this.enemy = e;
 
-					turret_do_updates(self);
+					turret_do_updates(this);
 
-					if (turret_checkfire())
-						turret_fire();
+					if (turret_checkfire(this))
+						turret_fire(this);
 				}
 			}
 
 			e = e.chain;
 		}
-		self.enemy = world;
+		this.enemy = NULL;
 	}
-	else if(self.shoot_flags & TFL_SHOOT_CUSTOM)
+	else if(this.shoot_flags & TFL_SHOOT_CUSTOM)
 	{
 		// This one is doing something.. oddball. assume its handles what needs to be handled.
 
 		// Predict?
-		if(!(self.aim_flags & TFL_AIM_NO))
-			self.tur_aimpos = turret_aim_generic();
+		if(!(this.aim_flags & TFL_AIM_NO))
+			this.tur_aimpos = turret_aim_generic(this);
 
 		// Turn & pitch?
-		if(!(self.track_flags & TFL_TRACK_NO))
-			turret_track();
+		if(!(this.track_flags & TFL_TRACK_NO))
+			turret_track(this);
 
-		turret_do_updates(self);
+		turret_do_updates(this);
 
 		// Fire?
-		if (turret_checkfire())
-			turret_fire();
+		if (turret_checkfire(this))
+			turret_fire(this);
 	}
 	else
 	{
 		// Special case for volly always. if it fired once it must compleate the volly.
-		if(self.shoot_flags & TFL_SHOOT_VOLLYALWAYS)
-			if(self.volly_counter != self.shot_volly)
+		if(this.shoot_flags & TFL_SHOOT_VOLLYALWAYS)
+			if(this.volly_counter != this.shot_volly)
 			{
 				// Predict or whatnot
-				if(!(self.aim_flags & TFL_AIM_NO))
-					self.tur_aimpos = turret_aim_generic();
+				if(!(this.aim_flags & TFL_AIM_NO))
+					this.tur_aimpos = turret_aim_generic(this);
 
 				// Turn & pitch
-				if(!(self.track_flags & TFL_TRACK_NO))
-					turret_track();
+				if(!(this.track_flags & TFL_TRACK_NO))
+					turret_track(this);
 
-				turret_do_updates(self);
+				turret_do_updates(this);
 
 				// Fire!
-				if (turret_checkfire())
-					turret_fire();
+				if (turret_checkfire(this))
+					turret_fire(this);
 
-				Turret tur = get_turretinfo(self.m_id);
-				tur.tr_think(tur, self);
+				Turret tur = get_turretinfo(this.m_id);
+				tur.tr_think(tur, this);
 
 				return;
 			}
@@ -1117,100 +1111,99 @@ void turret_think()
 
 		// g_turrets_targetscan_maxdelay forces a target re-scan at least this often
 		float do_target_scan = 0;
-		if((self.target_select_time + autocvar_g_turrets_targetscan_maxdelay) < time)
+		if((this.target_select_time + autocvar_g_turrets_targetscan_maxdelay) < time)
 			do_target_scan = 1;
 
 		// Old target (if any) invalid?
-		if(self.target_validate_time < time)
-		if (turret_validate_target(self, self.enemy, self.target_validate_flags) <= 0)
+		if(this.target_validate_time < time)
+		if (turret_validate_target(this, this.enemy, this.target_validate_flags) <= 0)
 		{
-			self.enemy = world;
-			self.target_validate_time = time + 0.5;
+			this.enemy = NULL;
+			this.target_validate_time = time + 0.5;
 			do_target_scan = 1;
 		}
 
 		// But never more often then g_turrets_targetscan_mindelay!
-		if (self.target_select_time + autocvar_g_turrets_targetscan_mindelay > time)
+		if (this.target_select_time + autocvar_g_turrets_targetscan_mindelay > time)
 			do_target_scan = 0;
 
 		if(do_target_scan)
 		{
-			self.enemy = turret_select_target();
-			self.target_select_time = time;
+			this.enemy = turret_select_target(this);
+			this.target_select_time = time;
 		}
 
 		// No target, just go to idle, do any custom stuff and bail.
-		if (self.enemy == world)
+		if (this.enemy == NULL)
 		{
 			// Turn & pitch
-			if(!(self.track_flags & TFL_TRACK_NO))
-				turret_track();
+			if(!(this.track_flags & TFL_TRACK_NO))
+				turret_track(this);
 
-			Turret tur = get_turretinfo(self.m_id);
-			tur.tr_think(tur, self);
+			Turret tur = get_turretinfo(this.m_id);
+			tur.tr_think(tur, this);
 
 			// And bail.
 			return;
 		}
 		else
-			self.lip = time + autocvar_g_turrets_aimidle_delay; // Keep track of the last time we had a target.
+			this.lip = time + autocvar_g_turrets_aimidle_delay; // Keep track of the last time we had a target.
 
 		// Predict?
-		if(!(self.aim_flags & TFL_AIM_NO))
-			self.tur_aimpos = turret_aim_generic();
+		if(!(this.aim_flags & TFL_AIM_NO))
+			this.tur_aimpos = turret_aim_generic(this);
 
 		// Turn & pitch?
-		if(!(self.track_flags & TFL_TRACK_NO))
-			turret_track();
+		if(!(this.track_flags & TFL_TRACK_NO))
+			turret_track(this);
 
-		turret_do_updates(self);
+		turret_do_updates(this);
 
 		// Fire?
-		if (turret_checkfire())
-			turret_fire();
+		if (turret_checkfire(this))
+			turret_fire(this);
 	}
 
-	Turret tur = get_turretinfo(self.m_id);
-	tur.tr_think(tur, self);
+	Turret tur = get_turretinfo(this.m_id);
+	tur.tr_think(tur, this);
 }
 
 /*
 	When .used a turret switch team to activator.team.
-	If activator is world, the turret go inactive.
+	If activator is NULL, the turret go inactive.
 */
-void turret_use()
-{SELFPARAM();
-	LOG_TRACE("Turret ",self.netname, " used by ", activator.classname, "\n");
+void turret_use(entity this, entity actor, entity trigger)
+{
+	LOG_TRACE("Turret ",this.netname, " used by ", actor.classname, "\n");
 
-	self.team = activator.team;
+	this.team = actor.team;
 
-	if(self.team == 0)
-		self.active = ACTIVE_NOT;
+	if(this.team == 0)
+		this.active = ACTIVE_NOT;
 	else
-		self.active = ACTIVE_ACTIVE;
+		this.active = ACTIVE_ACTIVE;
 
 }
 
-void turret_link()
-{SELFPARAM();
-	Net_LinkEntity(self, true, 0, turret_send);
-	self.think	 = turret_think;
-	self.nextthink = time;
-	self.tur_head.effects = EF_NODRAW;
+void turret_link(entity this)
+{
+	Net_LinkEntity(this, true, 0, turret_send);
+	setthink(this, turret_think);
+	this.nextthink = time;
+	this.tur_head.effects = EF_NODRAW;
 }
 
-void turrets_manager_think()
+void turrets_manager_think(entity this)
 {
-	SELFPARAM();
 	this.nextthink = time + 1;
 
 	if (autocvar_g_turrets_reloadcvars == 1)
 	{
-		FOREACH_ENTITY(IS_TURRET(it), LAMBDA(
+		FOREACH_ENTITY(IS_TURRET(it), {
 			load_unit_settings(it, true);
 			Turret tur = get_turretinfo(it.m_id);
 			tur.tr_think(tur, it);
-		));
+		});
 		cvar_set("g_turrets_reloadcvars", "0");
 	}
 }
@@ -1244,8 +1237,8 @@ void turret_initparams(entity tur)
 	#undef TRY
 }
 
-float turret_initialize(Turret tur)
-{SELFPARAM();
+bool turret_initialize(entity this, Turret tur)
+{
 	if(!autocvar_g_turrets)
 		return false;
 
@@ -1253,144 +1246,144 @@ float turret_initialize(Turret tur)
 		return false; // invalid turret
 
 	// if tur_head exists, we can assume this turret re-spawned
-	if(!self.tur_head) {
+	if(!this.tur_head) {
 		tur.tr_precache(tur);
 	}
 
-	entity e = find(world, classname, "turret_manager");
+	entity e = find(NULL, classname, "turret_manager");
 	if(!e)
 	{
 		e = new(turret_manager);
-		e.think = turrets_manager_think;
+		setthink(e, turrets_manager_think);
 		e.nextthink = time + 2;
 	}
 
-	if(!(self.spawnflags & TSF_SUSPENDED))
-		builtin_droptofloor();
-
-	self.netname = tur.netname;
-	load_unit_settings(self, 0);
-
-	if(!self.team || !teamplay)		{ self.team = MAX_SHOT_DISTANCE; }
-	if(!self.ticrate)				{ self.ticrate = ((self.turret_flags & TUR_FLAG_SUPPORT) ? 0.2 : 0.1); }
-	if(!self.health)				{ self.health = 1000; }
-	if(!self.shot_refire)			{ self.shot_refire = 1; }
-	if(!self.tur_shotorg)			{ self.tur_shotorg = '50 0 50'; }
-	if(!self.turret_flags)			{ self.turret_flags = TUR_FLAG_SPLASH | TUR_FLAG_MEDPROJ | TUR_FLAG_PLAYER; }
-	if(!self.damage_flags)			{ self.damage_flags = TFL_DMG_YES | TFL_DMG_RETALIATE | TFL_DMG_AIMSHAKE; }
-	if(!self.aim_flags)				{ self.aim_flags = TFL_AIM_LEAD | TFL_AIM_SHOTTIMECOMPENSATE; }
-	if(!self.track_type)			{ self.track_type = TFL_TRACKTYPE_STEPMOTOR; }
-	if(!self.track_flags)			{ self.track_flags = TFL_TRACK_PITCH | TFL_TRACK_ROTATE; }
-	if(!self.ammo_flags)			{ self.ammo_flags = TFL_AMMO_ENERGY | TFL_AMMO_RECHARGE; }
-	if(!self.target_select_flags)	{ self.target_select_flags = TFL_TARGETSELECT_LOS | TFL_TARGETSELECT_TEAMCHECK | TFL_TARGETSELECT_RANGELIMITS | TFL_TARGETSELECT_ANGLELIMITS; }
-	if(!self.firecheck_flags)		{ self.firecheck_flags = TFL_FIRECHECK_DEAD | TFL_FIRECHECK_DISTANCES | TFL_FIRECHECK_LOS
+	if(!(this.spawnflags & TSF_SUSPENDED))
+		droptofloor(this);
+
+	this.netname = tur.netname;
+	load_unit_settings(this, 0);
+
+	if(!this.team || !teamplay)		{ this.team = MAX_SHOT_DISTANCE; }
+	if(!this.ticrate)				{ this.ticrate = ((this.turret_flags & TUR_FLAG_SUPPORT) ? 0.2 : 0.1); }
+	if(!this.health)				{ this.health = 1000; }
+	if(!this.shot_refire)			{ this.shot_refire = 1; }
+	if(!this.tur_shotorg)			{ this.tur_shotorg = '50 0 50'; }
+	if(!this.turret_flags)			{ this.turret_flags = TUR_FLAG_SPLASH | TUR_FLAG_MEDPROJ | TUR_FLAG_PLAYER; }
+	if(!this.damage_flags)			{ this.damage_flags = TFL_DMG_YES | TFL_DMG_RETALIATE | TFL_DMG_AIMSHAKE; }
+	if(!this.aim_flags)				{ this.aim_flags = TFL_AIM_LEAD | TFL_AIM_SHOTTIMECOMPENSATE; }
+	if(!this.track_type)			{ this.track_type = TFL_TRACKTYPE_STEPMOTOR; }
+	if(!this.track_flags)			{ this.track_flags = TFL_TRACK_PITCH | TFL_TRACK_ROTATE; }
+	if(!this.ammo_flags)			{ this.ammo_flags = TFL_AMMO_ENERGY | TFL_AMMO_RECHARGE; }
+	if(!this.target_select_flags)	{ this.target_select_flags = TFL_TARGETSELECT_LOS | TFL_TARGETSELECT_TEAMCHECK | TFL_TARGETSELECT_RANGELIMITS | TFL_TARGETSELECT_ANGLELIMITS; }
+	if(!this.firecheck_flags)		{ this.firecheck_flags = TFL_FIRECHECK_DEAD | TFL_FIRECHECK_DISTANCES | TFL_FIRECHECK_LOS
 														   | TFL_FIRECHECK_AIMDIST | TFL_FIRECHECK_TEAMCHECK | TFL_FIRECHECK_AMMO_OWN | TFL_FIRECHECK_REFIRE; }
 
-	if(self.track_type != TFL_TRACKTYPE_STEPMOTOR)
+	if(this.track_type != TFL_TRACKTYPE_STEPMOTOR)
 	{
 		// Fluid / Ineria mode. Looks mutch nicer.
 		// Can reduce aim preformance alot, needs a bit diffrent aimspeed
 
-		self.aim_speed = bound(0.1, ((!self.aim_speed) ? 180 : self.aim_speed), 1000);
+		this.aim_speed = bound(0.1, ((!this.aim_speed) ? 180 : this.aim_speed), 1000);
 
-		if(!self.track_accel_pitch)		{ self.track_accel_pitch = 0.5; }
-		if(!self.track_accel_rotate)	{ self.track_accel_rotate = 0.5; }
-		if(!self.track_blendrate)		{ self.track_blendrate = 0.35; }
+		if(!this.track_accel_pitch)		{ this.track_accel_pitch = 0.5; }
+		if(!this.track_accel_rotate)	{ this.track_accel_rotate = 0.5; }
+		if(!this.track_blendrate)		{ this.track_blendrate = 0.35; }
 	}
 
-	turret_initparams(self);
+	turret_initparams(this);
 
-	self.turret_flags = TUR_FLAG_ISTURRET | (tur.spawnflags);
+	this.turret_flags = TUR_FLAG_ISTURRET | (tur.spawnflags);
 
-	if(self.turret_flags & TUR_FLAG_SPLASH)
-		self.aim_flags |= TFL_AIM_SPLASH;
+	if(this.turret_flags & TUR_FLAG_SPLASH)
+		this.aim_flags |= TFL_AIM_SPLASH;
 
-	if(self.turret_flags & TUR_FLAG_MISSILE)
-		self.target_select_flags |= TFL_TARGETSELECT_MISSILES;
+	if(this.turret_flags & TUR_FLAG_MISSILE)
+		this.target_select_flags |= TFL_TARGETSELECT_MISSILES;
 
-	if(self.turret_flags & TUR_FLAG_PLAYER)
-		self.target_select_flags |= TFL_TARGETSELECT_PLAYERS;
+	if(this.turret_flags & TUR_FLAG_PLAYER)
+		this.target_select_flags |= TFL_TARGETSELECT_PLAYERS;
 
-	if(self.spawnflags & TSL_NO_RESPAWN)
-		self.damage_flags |= TFL_DMG_DEATH_NORESPAWN;
+	if(this.spawnflags & TSL_NO_RESPAWN)
+		this.damage_flags |= TFL_DMG_DEATH_NORESPAWN;
 
-	if (self.turret_flags & TUR_FLAG_SUPPORT)
-		self.turret_score_target = turret_targetscore_support;
+	if (this.turret_flags & TUR_FLAG_SUPPORT)
+		this.turret_score_target = turret_targetscore_support;
 	else
-		self.turret_score_target = turret_targetscore_generic;
+		this.turret_score_target = turret_targetscore_generic;
 
 	++turret_count;
 
-	_setmodel(self, tur.model);
-	setsize(self, tur.mins, tur.maxs);
-
-	self.m_id					= tur.m_id;
-	self.classname				= "turret_main";
-	self.active					= ACTIVE_ACTIVE;
-	self.effects				= EF_NODRAW;
-	self.netname				= tur.turret_name;
-	self.ticrate				= bound(sys_frametime, self.ticrate, 60);
-	self.max_health				= self.health;
-	self.target_validate_flags	= self.target_select_flags;
-	self.ammo					= self.ammo_max;
-	self.ammo_recharge		   *= self.ticrate;
-	self.solid					= SOLID_BBOX;
-	self.takedamage				= DAMAGE_AIM;
-	self.movetype				= MOVETYPE_NOCLIP;
-	self.view_ofs				= '0 0 0';
-	self.turret_firecheckfunc	= turret_firecheck;
-	self.event_damage			= turret_damage;
-	self.use					= turret_use;
-	self.bot_attack				= true;
-	self.nextthink				= time + 1;
-	self.nextthink			   += turret_count * sys_frametime;
-
-	self.tur_head = new(turret_head);
-	_setmodel(self.tur_head, tur.head_model);
-	setsize(self.tur_head, '0 0 0', '0 0 0');
-	setorigin(self.tur_head, '0 0 0');
-	setattachment(self.tur_head, self, "tag_head");
-
-	self.tur_head.netname		= self.tur_head.classname;
-	self.tur_head.team			= self.team;
-	self.tur_head.owner			= self;
-	self.tur_head.takedamage	= DAMAGE_NO;
-	self.tur_head.solid			= SOLID_NOT;
-	self.tur_head.movetype		= self.movetype;
-
-	if(!self.tur_defend)
-	if(self.target != "")
+	_setmodel(this, tur.model);
+	setsize(this, tur.mins, tur.maxs);
+
+	this.m_id					= tur.m_id;
+	this.classname				= "turret_main";
+	this.active					= ACTIVE_ACTIVE;
+	this.effects				= EF_NODRAW;
+	this.netname				= tur.turret_name;
+	this.ticrate				= bound(sys_frametime, this.ticrate, 60);
+	this.max_health				= this.health;
+	this.target_validate_flags	= this.target_select_flags;
+	this.ammo					= this.ammo_max;
+	this.ammo_recharge		   *= this.ticrate;
+	this.solid					= SOLID_BBOX;
+	this.takedamage				= DAMAGE_AIM;
+	this.movetype				= MOVETYPE_NOCLIP;
+	this.view_ofs				= '0 0 0';
+	this.turret_firecheckfunc	= turret_firecheck;
+	this.event_damage			= turret_damage;
+	this.use					= turret_use;
+	this.bot_attack				= true;
+	this.nextthink				= time + 1;
+	this.nextthink			   += turret_count * sys_frametime;
+
+	this.tur_head = new(turret_head);
+	_setmodel(this.tur_head, tur.head_model);
+	setsize(this.tur_head, '0 0 0', '0 0 0');
+	setorigin(this.tur_head, '0 0 0');
+	setattachment(this.tur_head, this, "tag_head");
+
+	this.tur_head.netname		= this.tur_head.classname;
+	this.tur_head.team			= this.team;
+	this.tur_head.owner			= this;
+	this.tur_head.takedamage	= DAMAGE_NO;
+	this.tur_head.solid			= SOLID_NOT;
+	this.tur_head.movetype		= this.movetype;
+
+	if(!this.tur_defend)
+	if(this.target != "")
 	{
-		self.tur_defend = find(world, targetname, self.target);
-		if (self.tur_defend == world)
+		this.tur_defend = find(NULL, targetname, this.target);
+		if (this.tur_defend == NULL)
 		{
-			self.target = "";
+			this.target = "";
 			LOG_TRACE("Turret has invalid defendpoint!\n");
 		}
 	}
 
-	if (self.tur_defend)
-		self.idle_aim = self.tur_head.angles + angleofs(self.tur_head, self.tur_defend);
+	if (this.tur_defend)
+		this.idle_aim = this.tur_head.angles + angleofs(this.tur_head, this.tur_defend);
 	else
-		self.idle_aim = '0 0 0';
+		this.idle_aim = '0 0 0';
 
 #ifdef TURRET_DEBUG
-	self.tur_debug_start = self.nextthink;
-	while(vdist(self.tur_debug_rvec, <, 2))
-		self.tur_debug_rvec = randomvec() * 4;
+	this.tur_debug_start = this.nextthink;
+	while(vdist(this.tur_debug_rvec, <, 2))
+		this.tur_debug_rvec = randomvec() * 4;
 
-	self.tur_debug_rvec_x = fabs(self.tur_debug_rvec_x);
-	self.tur_debug_rvec_y = fabs(self.tur_debug_rvec_y);
-	self.tur_debug_rvec_z = fabs(self.tur_debug_rvec_z);
+	this.tur_debug_rvec_x = fabs(this.tur_debug_rvec_x);
+	this.tur_debug_rvec_y = fabs(this.tur_debug_rvec_y);
+	this.tur_debug_rvec_z = fabs(this.tur_debug_rvec_z);
 #endif
 
-	turret_link();
-	turret_respawn();
-	turret_tag_fire_update();
+	turret_link(this);
+	turret_respawn(this);
+	turret_tag_fire_update(this);
 
-	tur.tr_setup(tur, self);
+	tur.tr_setup(tur, this);
 
-	if(MUTATOR_CALLHOOK(TurretSpawn, self))
+	if(MUTATOR_CALLHOOK(TurretSpawn, this))
 		return false;
 
 	return true;