X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fgamemodes%2Fgamemode%2Fnexball%2Fnexball.qc;h=7d10f5d476493562ff9b9ac36e05934c700ace6f;hb=5eea97bc262bfaf271817ca034439ad551f691d4;hp=4a8005d6c2ad40e7991a967e29560429e206cdbc;hpb=9f1091e432a2db424bfad2482694ee8b34edbe9c;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
index 4a8005d6c..7d10f5d47 100644
--- a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
+++ b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc
@@ -1,12 +1,25 @@
 #include "nexball.qh"
 
 #ifdef IMPLEMENTATION
+#ifdef CSQC
+int autocvar_cl_eventchase_nexball = 1;
+
+REGISTER_MUTATOR(cl_nb, true);
+
+MUTATOR_HOOKFUNCTION(cl_nb, WantEventchase)
+{
+	if(autocvar_cl_eventchase_nexball && gametype == MAPINFO_TYPE_NEXBALL && !(WepSet_GetFromStat() & WEPSET(NEXBALL)))
+		return true;
+	return false;
+}
+#endif
 #ifdef SVQC
 .float metertime = _STAT(NB_METERSTART);
 
 int autocvar_g_nexball_goalleadlimit;
 #define autocvar_g_nexball_goallimit cvar("g_nexball_goallimit")
 
+bool autocvar_g_nexball_basketball_jumppad = true;
 float autocvar_g_nexball_basketball_bouncefactor;
 float autocvar_g_nexball_basketball_bouncestop;
 float autocvar_g_nexball_basketball_carrier_highspeed;
@@ -16,6 +29,7 @@ float autocvar_g_nexball_basketball_meter_minpower;
 float autocvar_g_nexball_delay_collect;
 float autocvar_g_nexball_delay_goal;
 float autocvar_g_nexball_delay_start;
+bool autocvar_g_nexball_football_jumppad = true;
 float autocvar_g_nexball_football_bouncefactor;
 float autocvar_g_nexball_football_bouncestop;
 bool autocvar_g_nexball_radar_showallplayers;
@@ -38,9 +52,9 @@ float autocvar_g_balance_nexball_secondary_lifetime;
 float autocvar_g_balance_nexball_secondary_refire;
 float autocvar_g_balance_nexball_secondary_speed;
 
-void basketball_touch();
-void football_touch();
-void ResetBall();
+void basketball_touch(entity this);
+void football_touch(entity this);
+void ResetBall(entity this);
 const int NBM_NONE = 0;
 const int NBM_FOOTBALL = 2;
 const int NBM_BASKETBALL = 4;
@@ -82,56 +96,55 @@ void ball_restart(entity this)
 {
 	if(this.owner)
 		DropBall(this, this.owner.origin, '0 0 0');
-	ResetBall();
+	ResetBall(this);
 }
 
-void nexball_setstatus()
-{SELFPARAM();
-	self.items &= ~IT_KEY1;
-	if(self.ballcarried)
+void nexball_setstatus(entity this)
+{
+	this.items &= ~IT_KEY1;
+	if(this.ballcarried)
 	{
-		if(self.ballcarried.teamtime && (self.ballcarried.teamtime < time))
+		if(this.ballcarried.teamtime && (this.ballcarried.teamtime < time))
 		{
-			bprint("The ", Team_ColoredFullName(self.team), " held the ball for too long.\n");
-			setself(self.ballcarried);
-			DropBall(self, self.owner.origin, '0 0 0');
-			ResetBall();
-			setself(this);
+			bprint("The ", Team_ColoredFullName(this.team), " held the ball for too long.\n");
+			DropBall(this.ballcarried, this.ballcarried.owner.origin, '0 0 0');
+			entity e = this.ballcarried;
+			WITHSELF(e, ResetBall(e));
 		}
 		else
-			self.items |= IT_KEY1;
+			this.items |= IT_KEY1;
 	}
 }
 
-void relocate_nexball()
-{SELFPARAM();
-	tracebox(self.origin, BALL_MINS, BALL_MAXS, self.origin, true, self);
+void relocate_nexball(entity this)
+{
+	tracebox(this.origin, BALL_MINS, BALL_MAXS, this.origin, true, this);
 	if(trace_startsolid)
 	{
 		vector o;
-		o = self.origin;
-		if(!move_out_of_solid(self))
+		o = this.origin;
+		if(!move_out_of_solid(this))
 			objerror("could not get out of solid at all!");
-		LOG_INFO("^1NOTE: this map needs FIXING. ", self.classname, " at ", vtos(o - '0 0 1'));
-		LOG_INFO(" needs to be moved out of solid, e.g. by '", ftos(self.origin.x - o.x));
-		LOG_INFO(" ", ftos(self.origin.y - o.y));
-		LOG_INFO(" ", ftos(self.origin.z - o.z), "'\n");
-		self.origin = o;
+		LOG_INFO("^1NOTE: this map needs FIXING. ", this.classname, " at ", vtos(o - '0 0 1'));
+		LOG_INFO(" needs to be moved out of solid, e.g. by '", ftos(this.origin.x - o.x));
+		LOG_INFO(" ", ftos(this.origin.y - o.y));
+		LOG_INFO(" ", ftos(this.origin.z - o.z), "'\n");
+		this.origin = o;
 	}
 }
 
-void DropOwner()
-{SELFPARAM();
+void DropOwner(entity this)
+{
 	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);
 }
 
 void GiveBall(entity plyr, entity ball)
-{SELFPARAM();
+{
 	.entity weaponentity = weaponentities[0]; // TODO: find ballstealer
 	entity ownr = ball.owner;
 	if(ownr)
@@ -166,7 +179,7 @@ void GiveBall(entity plyr, entity ball)
 
 	ball.velocity = '0 0 0';
 	ball.movetype = MOVETYPE_NONE;
-	ball.touch = func_null;
+	settouch(ball, func_null);
 	ball.effects |= EF_NOSHADOW;
 	ball.scale = 1; // scale down.
 
@@ -175,19 +188,17 @@ void GiveBall(entity plyr, entity ball)
 
 	if(autocvar_g_nexball_basketball_delay_hold)
 	{
-		ball.think = DropOwner;
+		setthink(ball, DropOwner);
 		ball.nextthink = time + autocvar_g_nexball_basketball_delay_hold;
 	}
 
 	plyr.(weaponentity).weapons = plyr.weapons;
 	plyr.(weaponentity).m_switchweapon = PS(plyr).m_weapon;
 	plyr.weapons = WEPSET(NEXBALL);
-	setself(plyr);
 	Weapon w = WEP_NEXBALL;
-	w.wr_resetplayer(w);
+	WITHSELF(plyr, w.wr_resetplayer(w, plyr));
 	PS(plyr).m_switchweapon = WEP_NEXBALL;
-	W_SwitchWeapon(WEP_NEXBALL);
-	setself(this);
+	WITHSELF(plyr, W_SwitchWeapon(plyr, WEP_NEXBALL));
 }
 
 void DropBall(entity ball, vector org, vector vel)
@@ -203,8 +214,8 @@ void DropBall(entity ball, vector org, vector vel)
 	ball.scale = ball_scale;
 	ball.velocity = vel;
 	ball.nb_droptime = time;
-	ball.touch = basketball_touch;
-	ball.think = ResetBall;
+	settouch(ball, basketball_touch);
+	setthink(ball, ResetBall);
 	ball.nextthink = min(time + autocvar_g_nexball_delay_idle, ball.teamtime);
 
 	if(ball.owner.metertime)
@@ -222,64 +233,64 @@ void DropBall(entity ball, vector org, vector vel)
 	ball.owner = world;
 }
 
-void InitBall()
-{SELFPARAM();
+void InitBall(entity this)
+{
 	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")
+		settouch(this, basketball_touch);
+	else if(this.classname == "nexball_football")
+		settouch(this, football_touch);
+	this.cnt = 0;
+	setthink(this, 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
+void ResetBall(entity this)
+{
+	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)
+		settouch(this, 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;
+		setthink(this, InitBall);
+		this.nextthink = max(time, game_starttime) + autocvar_g_nexball_delay_start;
 	}
 }
 
-void football_touch()
-{SELFPARAM();
+void football_touch(entity this)
+{
 	if(other.solid == SOLID_BSP)
 	{
 		if(time > self.lastground + 0.1)
@@ -324,14 +335,14 @@ void football_touch()
 	self.avelocity = -250 * v_forward;  // maybe there is a way to make it look better?
 }
 
-void basketball_touch()
-{SELFPARAM();
+void basketball_touch(entity this)
+{
 	if(other.ballcarried)
 	{
-		football_touch();
+		football_touch(this);
 		return;
 	}
-	if(!self.cnt && IS_PLAYER(other) && !other.frozen && !other.deadflag && (other != self.nb_dropper || time > self.nb_droptime + autocvar_g_nexball_delay_collect))
+	if(!self.cnt && IS_PLAYER(other) && !STAT(FROZEN, other) && !IS_DEAD(other) && (other != self.nb_dropper || time > self.nb_droptime + autocvar_g_nexball_delay_collect))
 	{
 		if(other.health <= 0)
 			return;
@@ -346,8 +357,8 @@ void basketball_touch()
 	}
 }
 
-void GoalTouch()
-{SELFPARAM();
+void GoalTouch(entity this)
+{
 	entity ball;
 	float isclient, pscore, otherteam;
 	string pname;
@@ -429,9 +440,9 @@ void GoalTouch()
 	WaypointSprite_Ping(ball.waypointsprite_attachedforcarrier);
 
 	ball.cnt = 1;
-	ball.think = ResetBall;
+	setthink(ball, ResetBall);
 	if(ball.classname == "nexball_basketball")
-		ball.touch = football_touch; // better than func_null: football control until the ball gets reset
+		settouch(ball, football_touch); // better than func_null: football control until the ball gets reset
 	ball.nextthink = time + autocvar_g_nexball_delay_goal * (self.team != GOAL_OUT);
 }
 
@@ -442,10 +453,10 @@ spawnfunc(nexball_team)
 {
 	if(!g_nexball)
 	{
-		remove(self);
+		remove(this);
 		return;
 	}
-	self.team = self.cnt + 1;
+	this.team = this.cnt + 1;
 }
 
 void nb_spawnteam(string teamname, float teamcolor)
@@ -498,7 +509,7 @@ void nb_spawnteams()
 	}
 }
 
-void nb_delayedinit()
+void nb_delayedinit(entity this)
 {
 	if(find(world, classname, "nexball_team") == world)
 		nb_spawnteams();
@@ -510,62 +521,62 @@ void nb_delayedinit()
 //	  spawnfuncs	   //
 //=======================//
 
-void SpawnBall()
-{SELFPARAM();
-	if(!g_nexball) { remove(self); return; }
+void SpawnBall(entity this)
+{
+	if(!g_nexball) { remove(this); return; }
 
 //	balls += 4; // using the remaining bits to count balls will leave more than the max edict count, so it's fine
 
-	if(self.model == "")
+	if(this.model == "")
 	{
-		self.model = "models/nexball/ball.md3";
-		self.scale = 1.3;
+		this.model = "models/nexball/ball.md3";
+		this.scale = 1.3;
 	}
 
-	precache_model(self.model);
-	_setmodel(self, self.model);
-	setsize(self, BALL_MINS, BALL_MAXS);
-	ball_scale = self.scale;
+	precache_model(this.model);
+	_setmodel(this, this.model);
+	setsize(this, BALL_MINS, BALL_MAXS);
+	ball_scale = this.scale;
 
-	relocate_nexball();
-	self.spawnorigin = self.origin;
+	relocate_nexball(this);
+	this.spawnorigin = this.origin;
 
-	self.effects = self.effects | EF_LOWPRECISION;
+	this.effects = this.effects | EF_LOWPRECISION;
 
-	if(cvar(strcat("g_", self.classname, "_trail")))  //nexball_basketball :p
+	if(cvar(strcat("g_", this.classname, "_trail")))  //nexball_basketball :p
 	{
-		self.glow_color = autocvar_g_nexball_trail_color;
-		self.glow_trail = true;
+		this.glow_color = autocvar_g_nexball_trail_color;
+		this.glow_trail = true;
 	}
 
-	self.movetype = MOVETYPE_FLY;
+	this.movetype = MOVETYPE_FLY;
 
 	if(!autocvar_g_nexball_sound_bounce)
-		self.noise = "";
-	else if(self.noise == "")
-		self.noise = strzone(SND(NB_BOUNCE));
+		this.noise = "";
+	else if(this.noise == "")
+		this.noise = strzone(SND(NB_BOUNCE));
 	//bounce sound placeholder (FIXME)
-	if(self.noise1 == "")
-		self.noise1 = strzone(SND(NB_DROP));
+	if(this.noise1 == "")
+		this.noise1 = strzone(SND(NB_DROP));
 	//ball drop sound placeholder (FIXME)
-	if(self.noise2 == "")
-		self.noise2 = strzone(SND(NB_STEAL));
+	if(this.noise2 == "")
+		this.noise2 = strzone(SND(NB_STEAL));
 	//stealing sound placeholder (FIXME)
-	if(self.noise) precache_sound(self.noise);
-	precache_sound(self.noise1);
-	precache_sound(self.noise2);
+	if(this.noise) precache_sound(this.noise);
+	precache_sound(this.noise1);
+	precache_sound(this.noise2);
 
-	WaypointSprite_AttachCarrier(WP_NbBall, self, RADARICON_FLAGCARRIER); // the ball's team is not set yet, no rule update needed
+	WaypointSprite_AttachCarrier(WP_NbBall, this, RADARICON_FLAGCARRIER); // the ball's team is not set yet, no rule update needed
 
-	self.reset = ball_restart;
-	self.think = InitBall;
-	self.nextthink = game_starttime + autocvar_g_nexball_delay_start;
+	this.reset = ball_restart;
+	setthink(this, InitBall);
+	this.nextthink = game_starttime + autocvar_g_nexball_delay_start;
 }
 
 spawnfunc(nexball_basketball)
 {
 	nexball_mode |= NBM_BASKETBALL;
-	self.classname = "nexball_basketball";
+	this.classname = "nexball_basketball";
 	if (!(balls & BALL_BASKET))
 	{
 		/*
@@ -576,28 +587,30 @@ spawnfunc(nexball_basketball)
 		*/
 		autocvar_g_nexball_basketball_effects_default = autocvar_g_nexball_basketball_effects_default & BALL_EFFECTMASK;
 	}
-	if(!self.effects)
-		self.effects = autocvar_g_nexball_basketball_effects_default;
-	self.solid = SOLID_TRIGGER;
+	if(!this.effects)
+		this.effects = autocvar_g_nexball_basketball_effects_default;
+	this.solid = SOLID_TRIGGER;
+	this.pushable = autocvar_g_nexball_basketball_jumppad;
 	balls |= BALL_BASKET;
-	self.bouncefactor = autocvar_g_nexball_basketball_bouncefactor;
-	self.bouncestop = autocvar_g_nexball_basketball_bouncestop;
-	SpawnBall();
+	this.bouncefactor = autocvar_g_nexball_basketball_bouncefactor;
+	this.bouncestop = autocvar_g_nexball_basketball_bouncestop;
+	SpawnBall(this);
 }
 
 spawnfunc(nexball_football)
 {
 	nexball_mode |= NBM_FOOTBALL;
-	self.classname = "nexball_football";
-	self.solid = SOLID_TRIGGER;
+	this.classname = "nexball_football";
+	this.solid = SOLID_TRIGGER;
 	balls |= BALL_FOOT;
-	self.bouncefactor = autocvar_g_nexball_football_bouncefactor;
-	self.bouncestop = autocvar_g_nexball_football_bouncestop;
-	SpawnBall();
+	this.pushable = autocvar_g_nexball_football_jumppad;
+	this.bouncefactor = autocvar_g_nexball_football_bouncefactor;
+	this.bouncestop = autocvar_g_nexball_football_bouncestop;
+	SpawnBall(this);
 }
 
-float nb_Goal_Customize()
-{SELFPARAM();
+float nb_Goal_Customize(entity this)
+{
 	entity e, wp_owner;
 	e = WaypointSprite_getviewentity(other);
 	wp_owner = self.owner;
@@ -606,61 +619,61 @@ float nb_Goal_Customize()
 	return true;
 }
 
-void SpawnGoal()
-{SELFPARAM();
-	if(!g_nexball) { remove(self); return; }
+void SpawnGoal(entity this)
+{
+	if(!g_nexball) { remove(this); return; }
 
 	EXACTTRIGGER_INIT;
 
-	if(self.team != GOAL_OUT && Team_TeamToNumber(self.team) != -1)
+	if(this.team != GOAL_OUT && Team_TeamToNumber(this.team) != -1)
 	{
-		entity wp = WaypointSprite_SpawnFixed(WP_NbGoal, (self.absmin + self.absmax) * 0.5, self, sprite, RADARICON_NONE);
-		wp.colormod = ((self.team) ? Team_ColorRGB(self.team) : '1 0.5 0');
-		self.sprite.customizeentityforclient = nb_Goal_Customize;
+		entity wp = WaypointSprite_SpawnFixed(WP_NbGoal, (this.absmin + this.absmax) * 0.5, this, sprite, RADARICON_NONE);
+		wp.colormod = ((this.team) ? Team_ColorRGB(this.team) : '1 0.5 0');
+		setcefc(this.sprite, nb_Goal_Customize);
 	}
 
-	self.classname = "nexball_goal";
-	if(self.noise == "")
-		self.noise = "ctf/respawn.wav";
-	precache_sound(self.noise);
-	self.touch = GoalTouch;
+	this.classname = "nexball_goal";
+	if(this.noise == "")
+		this.noise = "ctf/respawn.wav";
+	precache_sound(this.noise);
+	settouch(this, GoalTouch);
 }
 
 spawnfunc(nexball_redgoal)
 {
-	self.team = NUM_TEAM_1;
-	SpawnGoal();
+	this.team = NUM_TEAM_1;
+	SpawnGoal(this);
 }
 spawnfunc(nexball_bluegoal)
 {
-	self.team = NUM_TEAM_2;
-	SpawnGoal();
+	this.team = NUM_TEAM_2;
+	SpawnGoal(this);
 }
 spawnfunc(nexball_yellowgoal)
 {
-	self.team = NUM_TEAM_3;
-	SpawnGoal();
+	this.team = NUM_TEAM_3;
+	SpawnGoal(this);
 }
 spawnfunc(nexball_pinkgoal)
 {
-	self.team = NUM_TEAM_4;
-	SpawnGoal();
+	this.team = NUM_TEAM_4;
+	SpawnGoal(this);
 }
 
 spawnfunc(nexball_fault)
 {
-	self.team = GOAL_FAULT;
-	if(self.noise == "")
-		self.noise = strzone(SND(TYPEHIT));
-	SpawnGoal();
+	this.team = GOAL_FAULT;
+	if(this.noise == "")
+		this.noise = strzone(SND(TYPEHIT));
+	SpawnGoal(this);
 }
 
 spawnfunc(nexball_out)
 {
-	self.team = GOAL_OUT;
-	if(self.noise == "")
-		self.noise = strzone(SND(TYPEHIT));
-	SpawnGoal();
+	this.team = GOAL_OUT;
+	if(this.noise == "")
+		this.noise = strzone(SND(TYPEHIT));
+	SpawnGoal(this);
 }
 
 //
@@ -702,33 +715,33 @@ spawnfunc(ball_bound)
 //=======================//
 
 
-void W_Nexball_Think()
-{SELFPARAM();
+void W_Nexball_Think(entity this)
+{
 	//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()
-{SELFPARAM();
+void W_Nexball_Touch(entity this)
+{
 	entity ball, attacker;
-	attacker = self.owner;
-	//self.think = func_null;
-	//self.enemy = world;
+	attacker = this.owner;
+	//this.think = func_null;
+	//this.enemy = world;
 
-	PROJECTILE_TOUCH;
+	PROJECTILE_TOUCH(this);
 	if(attacker.team != other.team || autocvar_g_nexball_basketball_teamsteal)
-		if((ball = other.ballcarried) && !other.frozen && !other.deadflag && (IS_PLAYER(attacker)))
+		if((ball = other.ballcarried) && !STAT(FROZEN, other) && !IS_DEAD(other) && (IS_PLAYER(attacker)))
 		{
-			other.velocity = other.velocity + normalize(self.velocity) * other.damageforcescale * autocvar_g_balance_nexball_secondary_force;
+			other.velocity = other.velocity + normalize(this.velocity) * other.damageforcescale * autocvar_g_balance_nexball_secondary_force;
 			UNSET_ONGROUND(other);
 			if(!attacker.ballcarried)
 			{
@@ -745,22 +758,22 @@ void W_Nexball_Touch()
 				GiveBall(attacker, other.ballcarried);
 			}
 		}
-	remove(self);
+	remove(this);
 }
 
-void W_Nexball_Attack(float t)
-{SELFPARAM();
+void W_Nexball_Attack(entity actor, float t)
+{
 	entity ball;
 	float mul, mi, ma;
-	if(!(ball = self.ballcarried))
+	if(!(ball = actor.ballcarried))
 		return;
 
-	W_SetupShot(self, false, 4, SND(NB_SHOOT1), CH_WEAPON_A, 0);
+	W_SetupShot(actor, false, 4, SND_NB_SHOOT1, CH_WEAPON_A, 0);
 	tracebox(w_shotorg, BALL_MINS, BALL_MAXS, w_shotorg, MOVE_WORLDONLY, world);
 	if(trace_startsolid)
 	{
-		if(self.metertime)
-			self.metertime = 0; // Shot failed, hide the power meter
+		if(actor.metertime)
+			actor.metertime = 0; // Shot failed, hide the power meter
 		return;
 	}
 
@@ -778,7 +791,7 @@ void W_Nexball_Attack(float t)
 		mul = mi + (ma - mi) * mul; // range from the minimal power to the maximal power
 	}
 
-	DropBall(ball, w_shotorg, W_CalculateProjectileVelocity(self.velocity, w_shotdir * autocvar_g_balance_nexball_primary_speed * mul, false));
+	DropBall(ball, w_shotorg, W_CalculateProjectileVelocity(actor.velocity, w_shotdir * autocvar_g_balance_nexball_primary_speed * mul, false));
 
 
 	//TODO: use the speed_up cvar too ??
@@ -786,14 +799,14 @@ void W_Nexball_Attack(float t)
 
 vector trigger_push_calculatevelocity(vector org, entity tgt, float ht);
 
-void W_Nexball_Attack2()
-{SELFPARAM();
-	if(self.ballcarried.enemy)
+void W_Nexball_Attack2(entity actor)
+{
+	if(actor.ballcarried.enemy)
 	{
-		entity _ball = self.ballcarried;
-		W_SetupShot(self, false, 4, SND(NB_SHOOT1), CH_WEAPON_A, 0);
+		entity _ball = actor.ballcarried;
+		W_SetupShot(actor, false, 4, SND_NB_SHOOT1, CH_WEAPON_A, 0);
 		DropBall(_ball, w_shotorg, trigger_push_calculatevelocity(_ball.origin, _ball.enemy, 32));
-		_ball.think = W_Nexball_Think;
+		setthink(_ball, W_Nexball_Think);
 		_ball.nextthink = time;
 		return;
 	}
@@ -801,10 +814,10 @@ void W_Nexball_Attack2()
 	if(!autocvar_g_nexball_tackling)
 		return;
 
-	W_SetupShot(self, false, 2, SND(NB_SHOOT2), CH_WEAPON_A, 0);
+	W_SetupShot(actor, false, 2, SND_NB_SHOOT2, CH_WEAPON_A, 0);
 	entity missile = new(ballstealer);
 
-	missile.owner = self;
+	missile.owner = actor;
 
 	missile.movetype = MOVETYPE_FLY;
 	PROJECTILE_MAKETRIGGER(missile);
@@ -815,8 +828,8 @@ void W_Nexball_Attack2()
 
 	W_SetupProjVelocity_Basic(missile, autocvar_g_balance_nexball_secondary_speed, 0);
 	missile.angles = vectoangles(missile.velocity);
-	missile.touch = W_Nexball_Touch;
-	missile.think = SUB_Remove_self;
+	settouch(missile, W_Nexball_Touch);
+	setthink(missile, SUB_Remove);
 	missile.nextthink = time + autocvar_g_balance_nexball_secondary_lifetime; //FIXME: use a distance instead?
 
 	missile.effects = EF_BRIGHTFIELD | EF_LOWPRECISION;
@@ -825,13 +838,13 @@ void W_Nexball_Attack2()
 	CSQCProjectile(missile, true, PROJECTILE_ELECTRO, true);
 }
 
-float ball_customize()
-{SELFPARAM();
+float ball_customize(entity this)
+{
 	if(!self.owner)
 	{
 		self.effects &= ~EF_FLAME;
 		self.scale = 1;
-		self.customizeentityforclient = func_null;
+		setcefc(self, func_null);
 		return true;
 	}
 
@@ -852,48 +865,55 @@ float ball_customize()
 	return true;
 }
 
-	METHOD(BallStealer, wr_think, void(BallStealer thiswep, entity actor, .entity weaponentity, int fire))
-	{
-		if(fire & 1)
-			if(weapon_prepareattack(thiswep, actor, weaponentity, false, autocvar_g_balance_nexball_primary_refire))
-				if(autocvar_g_nexball_basketball_meter)
-				{
-					if(self.ballcarried && !self.metertime)
-						self.metertime = time;
-					else
-						weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
-				}
-				else
-				{
-					W_Nexball_Attack(-1);
-					weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
-				}
-		if(fire & 2)
-			if(weapon_prepareattack(thiswep, actor, weaponentity, true, autocvar_g_balance_nexball_secondary_refire))
-			{
-				W_Nexball_Attack2();
-				weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, autocvar_g_balance_nexball_secondary_animtime, w_ready);
-			}
+METHOD(BallStealer, wr_think, void(BallStealer thiswep, entity actor, .entity weaponentity, int fire))
+{
+    TC(BallStealer, thiswep);
+    if(fire & 1)
+        if(weapon_prepareattack(thiswep, actor, weaponentity, false, autocvar_g_balance_nexball_primary_refire))
+            if(autocvar_g_nexball_basketball_meter)
+            {
+                if(actor.ballcarried && !actor.metertime)
+                    actor.metertime = time;
+                else
+                    weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
+            }
+            else
+            {
+                W_Nexball_Attack(actor, -1);
+                weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
+            }
+    if(fire & 2)
+        if(weapon_prepareattack(thiswep, actor, weaponentity, true, autocvar_g_balance_nexball_secondary_refire))
+        {
+            W_Nexball_Attack2(actor);
+            weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, autocvar_g_balance_nexball_secondary_animtime, w_ready);
+        }
+
+    if(!(fire & 1) && actor.metertime && actor.ballcarried)
+    {
+        W_Nexball_Attack(actor, time - actor.metertime);
+        // DropBall or stealing will set metertime back to 0
+        weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
+    }
+}
 
-		if(!(fire & 1) && self.metertime && self.ballcarried)
-		{
-			W_Nexball_Attack(time - self.metertime);
-			// DropBall or stealing will set metertime back to 0
-			weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, autocvar_g_balance_nexball_primary_animtime, w_ready);
-		}
-	}
-	METHOD(BallStealer, wr_setup, void(BallStealer thiswep))
-	{
-		//weapon_setup(WEP_PORTO.m_id);
-	}
-	METHOD(BallStealer, wr_checkammo1, bool(BallStealer thiswep))
-	{
-		return true;
-	}
-	METHOD(BallStealer, wr_checkammo2, bool(BallStealer thiswep))
-	{
-		return true;
-	}
+METHOD(BallStealer, wr_setup, void(BallStealer this, entity actor))
+{
+    TC(BallStealer, this);
+    //weapon_setup(WEP_PORTO.m_id);
+}
+
+METHOD(BallStealer, wr_checkammo1, bool(BallStealer this, entity actor))
+{
+    TC(BallStealer, this);
+    return true;
+}
+
+METHOD(BallStealer, wr_checkammo2, bool(BallStealer this, entity actor))
+{
+    TC(BallStealer, this);
+    return true;
+}
 
 void nb_DropBall(entity player)
 {
@@ -908,9 +928,10 @@ MUTATOR_HOOKFUNCTION(nb, ClientDisconnect)
 }
 
 MUTATOR_HOOKFUNCTION(nb, PlayerDies)
-{SELFPARAM();
-	nb_DropBall(self);
-	return false;
+{
+	entity frag_target = M_ARGV(2, entity);
+
+	nb_DropBall(frag_target);
 }
 
 MUTATOR_HOOKFUNCTION(nb, MakePlayerObserver)
@@ -928,7 +949,7 @@ MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
 		{
 			// 'view ball'
 			self.ballcarried.velocity = self.velocity;
-			self.ballcarried.customizeentityforclient = ball_customize;
+			setcefc(self.ballcarried, ball_customize);
 
 			vector org = self.origin + self.view_ofs +
 					  v_forward * autocvar_g_nexball_viewmodel_offset.x +
@@ -950,7 +971,7 @@ MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
 				crosshair_trace(self);
 				if( trace_ent &&
 					IS_CLIENT(trace_ent) &&
-					trace_ent.deadflag == DEAD_NO &&
+					!IS_DEAD(trace_ent) &&
 					trace_ent.team == self.team &&
 					vlen(trace_ent.origin - self.origin) <= autocvar_g_nexball_safepass_maxdist )
 				{
@@ -971,9 +992,9 @@ MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
 			{
 				self.weapons = self.(weaponentity).weapons;
 				Weapon w = WEP_NEXBALL;
-				w.wr_resetplayer(w);
+				w.wr_resetplayer(w, self);
 				PS(self).m_switchweapon = self.(weaponentity).m_switchweapon;
-				W_SwitchWeapon(PS(self).m_switchweapon);
+				W_SwitchWeapon(self, PS(self).m_switchweapon);
 
 				self.(weaponentity).weapons = '0 0 0';
 			}
@@ -981,7 +1002,7 @@ MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
 
 	}
 
-	nexball_setstatus();
+	nexball_setstatus(self);
 
 	return false;
 }
@@ -994,15 +1015,16 @@ MUTATOR_HOOKFUNCTION(nb, SpectateCopy)
 
 MUTATOR_HOOKFUNCTION(nb, PlayerSpawn)
 {
-	SELFPARAM();
-	this.metertime = 0;
+	entity player = M_ARGV(0, entity);
+
+	player.metertime = 0;
 	.entity weaponentity = weaponentities[0];
-	this.(weaponentity).weapons = '0 0 0';
+	player.(weaponentity).weapons = '0 0 0';
 
 	if (nexball_mode & NBM_BASKETBALL)
-		this.weapons |= WEPSET(NEXBALL);
+		player.weapons |= WEPSET(NEXBALL);
 	else
-		this.weapons = '0 0 0';
+		player.weapons = '0 0 0';
 
 	return false;
 }
@@ -1053,6 +1075,8 @@ MUTATOR_HOOKFUNCTION(nb, WantWeapon)
 
 MUTATOR_HOOKFUNCTION(nb, DropSpecialItems)
 {
+	entity frag_target = M_ARGV(0, entity);
+
 	if(frag_target.ballcarried)
 		DropBall(frag_target.ballcarried, frag_target.origin, frag_target.velocity);
 
@@ -1087,7 +1111,7 @@ REGISTER_MUTATOR(nb, g_nexball)
 		WEP_NEXBALL.spawnflags &= ~WEP_FLAG_MUTATORBLOCKED;
 
 		ActivateTeamplay();
-		SetLimits(autocvar_g_nexball_goallimit, autocvar_g_nexball_goalleadlimit, -1, -1);
+		SetLimits(autocvar_g_nexball_goallimit, autocvar_g_nexball_goalleadlimit, autocvar_timelimit_override, -1);
 		have_team_spawns = -1; // request team spawns
 	}