X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fgamemodes%2Fgamemode%2Fnexball%2Fnexball.qc;h=6ef9ca5ab66fec9fcd082ff0a5333a69622b894f;hb=8cbf0e84432e075e617f43c037c645ea9846eba0;hp=14ab8b470a4229d5b71deeae20e0a70e2791e4d9;hpb=f72821fdcebe3ca01181a99727a06198de65ea08;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 14ab8b470a..6ef9ca5ab6 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;
+			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))
-			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;
+		o = this.origin;
+		if(!move_out_of_solid(this))
+			objerror(this, "could not get out of solid at all!");
+		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);
+	w.wr_resetplayer(w, plyr);
 	PS(plyr).m_switchweapon = WEP_NEXBALL;
-	W_SwitchWeapon(WEP_NEXBALL);
-	setself(this);
+	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,145 +233,145 @@ 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)
+		if(time > this.lastground + 0.1)
 		{
-			_sound(self, CH_TRIGGER, self.noise, VOL_BASE, ATTEN_NORM);
-			self.lastground = time;
+			_sound(this, CH_TRIGGER, this.noise, VOL_BASE, ATTEN_NORM);
+			this.lastground = time;
 		}
-		if(vlen(self.velocity) && !self.cnt)
-			self.nextthink = time + autocvar_g_nexball_delay_idle;
+		if(this.velocity && !this.cnt)
+			this.nextthink = time + autocvar_g_nexball_delay_idle;
 		return;
 	}
 	if (!IS_PLAYER(other))
 		return;
 	if(other.health < 1)
 		return;
-	if(!self.cnt)
-		self.nextthink = time + autocvar_g_nexball_delay_idle;
+	if(!this.cnt)
+		this.nextthink = time + autocvar_g_nexball_delay_idle;
 
-	self.pusher = other;
-	self.team = other.team;
+	this.pusher = other;
+	this.team = other.team;
 
 	if(autocvar_g_nexball_football_physics == -1)	// MrBougo try 1, before decompiling Rev's original
 	{
 		if(vlen(other.velocity))
-			self.velocity = other.velocity * 1.5 + '0 0 1' * autocvar_g_nexball_football_boost_up;
+			this.velocity = other.velocity * 1.5 + '0 0 1' * autocvar_g_nexball_football_boost_up;
 	}
 	else if(autocvar_g_nexball_football_physics == 1)	  // MrBougo's modded Rev style: partially independant of the height of the aiming point
 	{
 		makevectors(other.v_angle);
-		self.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + '0 0 1' * autocvar_g_nexball_football_boost_up;
+		this.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + '0 0 1' * autocvar_g_nexball_football_boost_up;
 	}
 	else if(autocvar_g_nexball_football_physics == 2)	  // 2nd mod try: totally independant. Really playable!
 	{
 		makevectors(other.v_angle.y * '0 1 0');
-		self.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + v_up * autocvar_g_nexball_football_boost_up;
+		this.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + v_up * autocvar_g_nexball_football_boost_up;
 	}
 	else	 // Revenant's original style (from the original mod's disassembly, acknowledged by Revenant)
 	{
 		makevectors(other.v_angle);
-		self.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + v_up * autocvar_g_nexball_football_boost_up;
+		this.velocity = other.velocity + v_forward * autocvar_g_nexball_football_boost_forward + v_up * autocvar_g_nexball_football_boost_up;
 	}
-	self.avelocity = -250 * v_forward;  // maybe there is a way to make it look better?
+	this.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) && !STAT(FROZEN, other) && !IS_DEAD(other) && (other != self.nb_dropper || time > self.nb_droptime + autocvar_g_nexball_delay_collect))
+	if(!this.cnt && IS_PLAYER(other) && !STAT(FROZEN, other) && !IS_DEAD(other) && (other != this.nb_dropper || time > this.nb_droptime + autocvar_g_nexball_delay_collect))
 	{
 		if(other.health <= 0)
 			return;
 		LogNB("caught", other);
-		GiveBall(other, self);
+		GiveBall(other, this);
 	}
 	else if(other.solid == SOLID_BSP)
 	{
-		_sound(self, CH_TRIGGER, self.noise, VOL_BASE, ATTEN_NORM);
-		if(vlen(self.velocity) && !self.cnt)
-			self.nextthink = min(time + autocvar_g_nexball_delay_idle, self.teamtime);
+		_sound(this, CH_TRIGGER, this.noise, VOL_BASE, ATTEN_NORM);
+		if(vlen(this.velocity) && !this.cnt)
+			this.nextthink = min(time + autocvar_g_nexball_delay_idle, this.teamtime);
 	}
 }
 
-void GoalTouch()
-{SELFPARAM();
+void GoalTouch(entity this)
+{
 	entity ball;
 	float isclient, pscore, otherteam;
 	string pname;
 
 	if(gameover) return;
-	if((self.spawnflags & GOAL_TOUCHPLAYER) && other.ballcarried)
+	if((this.spawnflags & GOAL_TOUCHPLAYER) && other.ballcarried)
 		ball = other.ballcarried;
 	else
 		ball = other;
 	if(ball.classname != "nexball_basketball")
 		if(ball.classname != "nexball_football")
 			return;
-	if((!ball.pusher && self.team != GOAL_OUT) || ball.cnt)
+	if((!ball.pusher && this.team != GOAL_OUT) || ball.cnt)
 		return;
 	EXACTTRIGGER_TOUCH;
 
@@ -375,13 +386,13 @@ void GoalTouch()
 	else
 		pname = "Someone (?)";
 
-	if(ball.team == self.team)		 //owngoal (regular goals)
+	if(ball.team == this.team)		 //owngoal (regular goals)
 	{
 		LogNB("owngoal", ball.pusher);
 		bprint("Boo! ", pname, "^7 scored a goal against their own team!\n");
 		pscore = -1;
 	}
-	else if(self.team == GOAL_FAULT)
+	else if(this.team == GOAL_FAULT)
 	{
 		LogNB("fault", ball.pusher);
 		if(nb_teams == 2)
@@ -390,10 +401,10 @@ void GoalTouch()
 			bprint(Team_ColoredFullName(ball.team), " loses a point due to ", pname, "^7's silliness.\n");
 		pscore = -1;
 	}
-	else if(self.team == GOAL_OUT)
+	else if(this.team == GOAL_OUT)
 	{
 		LogNB("out", ball.pusher);
-		if((self.spawnflags & GOAL_TOUCHPLAYER) && ball.owner)
+		if((this.spawnflags & GOAL_TOUCHPLAYER) && ball.owner)
 			bprint(pname, "^7 went out of bounds.\n");
 		else
 			bprint("The ball was returned.\n");
@@ -401,12 +412,12 @@ void GoalTouch()
 	}
 	else							   //score
 	{
-		LogNB(strcat("goal:", ftos(self.team)), ball.pusher);
+		LogNB(strcat("goal:", ftos(this.team)), ball.pusher);
 		bprint("Goaaaaal! ", pname, "^7 scored a point for the ", Team_ColoredFullName(ball.team), ".\n");
 		pscore = 1;
 	}
 
-	_sound(ball, CH_TRIGGER, self.noise, VOL_BASE, ATTEN_NONE);
+	_sound(ball, CH_TRIGGER, this.noise, VOL_BASE, ATTEN_NONE);
 
 	if(ball.team && pscore)
 	{
@@ -429,10 +440,10 @@ 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
-	ball.nextthink = time + autocvar_g_nexball_delay_goal * (self.team != GOAL_OUT);
+		settouch(ball, football_touch); // better than func_null: football control until the ball gets reset
+	ball.nextthink = time + autocvar_g_nexball_delay_goal * (this.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,91 +587,93 @@ 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;
+	wp_owner = this.owner;
 	if(SAME_TEAM(e, wp_owner)) { return false; }
 
 	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) && !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, 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,28 +838,28 @@ void W_Nexball_Attack2()
 	CSQCProjectile(missile, true, PROJECTILE_ELECTRO, true);
 }
 
-float ball_customize()
-{SELFPARAM();
-	if(!self.owner)
+float ball_customize(entity this)
+{
+	if(!this.owner)
 	{
-		self.effects &= ~EF_FLAME;
-		self.scale = 1;
-		self.customizeentityforclient = func_null;
+		this.effects &= ~EF_FLAME;
+		this.scale = 1;
+		setcefc(this, func_null);
 		return true;
 	}
 
-	if(other == self.owner)
+	if(other == this.owner)
 	{
-		self.scale = autocvar_g_nexball_viewmodel_scale;
-		if(self.enemy)
-			self.effects |= EF_FLAME;
+		this.scale = autocvar_g_nexball_viewmodel_scale;
+		if(this.enemy)
+			this.effects |= EF_FLAME;
 		else
-			self.effects &= ~EF_FLAME;
+			this.effects &= ~EF_FLAME;
 	}
 	else
 	{
-		self.effects &= ~EF_FLAME;
-		self.scale = 1;
+		this.effects &= ~EF_FLAME;
+		this.scale = 1;
 	}
 
 	return true;
@@ -854,50 +867,49 @@ float ball_customize()
 
 METHOD(BallStealer, wr_think, void(BallStealer thiswep, entity actor, .entity weaponentity, int fire))
 {
-    SELFPARAM();
     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(self.ballcarried && !self.metertime)
-                    self.metertime = time;
+                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(-1);
+                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();
+            W_Nexball_Attack2(actor);
             weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, autocvar_g_balance_nexball_secondary_animtime, w_ready);
         }
 
-    if(!(fire & 1) && self.metertime && self.ballcarried)
+    if(!(fire & 1) && actor.metertime && actor.ballcarried)
     {
-        W_Nexball_Attack(time - self.metertime);
+        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);
     }
 }
 
-METHOD(BallStealer, wr_setup, void(BallStealer this))
+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))
+METHOD(BallStealer, wr_checkammo1, bool(BallStealer this, entity actor))
 {
     TC(BallStealer, this);
     return true;
 }
 
-METHOD(BallStealer, wr_checkammo2, bool(BallStealer this))
+METHOD(BallStealer, wr_checkammo2, bool(BallStealer this, entity actor))
 {
     TC(BallStealer, this);
     return true;
@@ -910,63 +922,69 @@ void nb_DropBall(entity player)
 }
 
 MUTATOR_HOOKFUNCTION(nb, ClientDisconnect)
-{SELFPARAM();
-	nb_DropBall(self);
-	return false;
+{
+	entity player = M_ARGV(0, entity);
+
+	nb_DropBall(player);
 }
 
 MUTATOR_HOOKFUNCTION(nb, PlayerDies)
 {
+	entity frag_target = M_ARGV(2, entity);
+
 	nb_DropBall(frag_target);
-	return false;
 }
 
 MUTATOR_HOOKFUNCTION(nb, MakePlayerObserver)
-{SELFPARAM();
-	nb_DropBall(self);
+{
+	entity player = M_ARGV(0, entity);
+
+	nb_DropBall(player);
 	return false;
 }
 
 MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
-{SELFPARAM();
-	makevectors(self.v_angle);
+{
+	entity player = M_ARGV(0, entity);
+
+	makevectors(player.v_angle);
 	if(nexball_mode & NBM_BASKETBALL)
 	{
-		if(self.ballcarried)
+		if(player.ballcarried)
 		{
 			// 'view ball'
-			self.ballcarried.velocity = self.velocity;
-			self.ballcarried.customizeentityforclient = ball_customize;
+			player.ballcarried.velocity = player.velocity;
+			setcefc(player.ballcarried, ball_customize);
 
-			vector org = self.origin + self.view_ofs +
+			vector org = player.origin + player.view_ofs +
 					  v_forward * autocvar_g_nexball_viewmodel_offset.x +
 					  v_right * autocvar_g_nexball_viewmodel_offset.y +
 					  v_up * autocvar_g_nexball_viewmodel_offset.z;
-			setorigin(self.ballcarried, org);
+			setorigin(player.ballcarried, org);
 
 			// 'safe passing'
 			if(autocvar_g_nexball_safepass_maxdist)
 			{
-				if(self.ballcarried.wait < time && self.ballcarried.enemy)
+				if(player.ballcarried.wait < time && player.ballcarried.enemy)
 				{
-					//centerprint(self, sprintf("Lost lock on %s", self.ballcarried.enemy.netname));
-					self.ballcarried.enemy = world;
+					//centerprint(player, sprintf("Lost lock on %s", player.ballcarried.enemy.netname));
+					player.ballcarried.enemy = world;
 				}
 
 
-				//tracebox(self.origin + self.view_ofs, '-2 -2 -2', '2 2 2', self.origin + self.view_ofs + v_forward * autocvar_g_nexball_safepass_maxdist);
-				crosshair_trace(self);
+				//tracebox(player.origin + player.view_ofs, '-2 -2 -2', '2 2 2', player.origin + player.view_ofs + v_forward * autocvar_g_nexball_safepass_maxdist);
+				crosshair_trace(player);
 				if( trace_ent &&
 					IS_CLIENT(trace_ent) &&
 					!IS_DEAD(trace_ent) &&
-					trace_ent.team == self.team &&
-					vlen(trace_ent.origin - self.origin) <= autocvar_g_nexball_safepass_maxdist )
+					trace_ent.team == player.team &&
+					vdist(trace_ent.origin - player.origin, <=, autocvar_g_nexball_safepass_maxdist) )
 				{
 
-					//if(self.ballcarried.enemy != trace_ent)
-					//	centerprint(self, sprintf("Locked to %s", trace_ent.netname));
-					self.ballcarried.enemy = trace_ent;
-					self.ballcarried.wait = time + autocvar_g_nexball_safepass_holdtime;
+					//if(player.ballcarried.enemy != trace_ent)
+					//	centerprint(player, sprintf("Locked to %s", trace_ent.netname));
+					player.ballcarried.enemy = trace_ent;
+					player.ballcarried.wait = time + autocvar_g_nexball_safepass_holdtime;
 
 
 				}
@@ -975,42 +993,43 @@ MUTATOR_HOOKFUNCTION(nb, PlayerPreThink)
 		else
 		{
 			.entity weaponentity = weaponentities[0]; // TODO
-			if(self.(weaponentity).weapons)
+			if(player.(weaponentity).weapons)
 			{
-				self.weapons = self.(weaponentity).weapons;
+				player.weapons = player.(weaponentity).weapons;
 				Weapon w = WEP_NEXBALL;
-				w.wr_resetplayer(w);
-				PS(self).m_switchweapon = self.(weaponentity).m_switchweapon;
-				W_SwitchWeapon(PS(self).m_switchweapon);
+				w.wr_resetplayer(w, player);
+				PS(player).m_switchweapon = player.(weaponentity).m_switchweapon;
+				W_SwitchWeapon(player, PS(player).m_switchweapon);
 
-				self.(weaponentity).weapons = '0 0 0';
+				player.(weaponentity).weapons = '0 0 0';
 			}
 		}
 
 	}
 
-	nexball_setstatus();
-
-	return false;
+	nexball_setstatus(player);
 }
 
 MUTATOR_HOOKFUNCTION(nb, SpectateCopy)
 {
-	SELFPARAM();
-	this.metertime = other.metertime;
+	entity spectatee = M_ARGV(0, entity);
+	entity client = M_ARGV(1, entity);
+
+	client.metertime = spectatee.metertime;
 }
 
 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;
 }
@@ -1019,29 +1038,36 @@ MUTATOR_HOOKFUNCTION(nb, PlayerSpawn)
 .float stat_sv_maxspeed;
 
 MUTATOR_HOOKFUNCTION(nb, PlayerPhysics)
-{SELFPARAM();
-	if(self.ballcarried)
+{
+	entity player = M_ARGV(0, entity);
+
+	if(player.ballcarried)
 	{
-		self.stat_sv_airspeedlimit_nonqw *= autocvar_g_nexball_basketball_carrier_highspeed;
-		self.stat_sv_maxspeed *= autocvar_g_nexball_basketball_carrier_highspeed;
+		player.stat_sv_airspeedlimit_nonqw *= autocvar_g_nexball_basketball_carrier_highspeed;
+		player.stat_sv_maxspeed *= autocvar_g_nexball_basketball_carrier_highspeed;
 	}
-	return false;
 }
 
 MUTATOR_HOOKFUNCTION(nb, ForbidThrowCurrentWeapon)
-{SELFPARAM();
-	return PS(self).m_weapon == WEP_NEXBALL;
+{
+	entity player = M_ARGV(0, entity);
+
+	return PS(player).m_weapon == WEP_NEXBALL;
 }
 
 MUTATOR_HOOKFUNCTION(nb, ForbidDropCurrentWeapon)
-{SELFPARAM();
-	return PS(self).m_weapon == WEP_MORTAR; // TODO: what is this for?
+{
+	entity player = M_ARGV(0, entity);
+
+	return PS(player).m_weapon == WEP_MORTAR; // TODO: what is this for?
 }
 
 MUTATOR_HOOKFUNCTION(nb, FilterItem)
-{SELFPARAM();
-	if(self.classname == "droppedweapon")
-	if(self.weapon == WEP_NEXBALL.m_id)
+{
+	entity item = M_ARGV(0, entity);
+
+	if(item.classname == "droppedweapon")
+	if(item.weapon == WEP_NEXBALL.m_id)
 		return true;
 
 	return false;
@@ -1049,18 +1075,20 @@ MUTATOR_HOOKFUNCTION(nb, FilterItem)
 
 MUTATOR_HOOKFUNCTION(nb, GetTeamCount)
 {
-	ret_string = "nexball_team";
+	M_ARGV(1, string) = "nexball_team";
 	return true;
 }
 
 MUTATOR_HOOKFUNCTION(nb, WantWeapon)
 {
-	ret_float = 0; // weapon is set a few lines later, apparently
+	M_ARGV(1, float) = 0; // weapon is set a few lines later, apparently
 	return true;
 }
 
 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);
 
@@ -1069,8 +1097,7 @@ MUTATOR_HOOKFUNCTION(nb, DropSpecialItems)
 
 MUTATOR_HOOKFUNCTION(nb, SendWaypoint)
 {
-	wp_sendflags &= ~0x80;
-	return false;
+	M_ARGV(2, int) &= ~0x80;
 }
 
 REGISTER_MUTATOR(nb, g_nexball)
@@ -1095,7 +1122,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
 	}