X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fminigames%2Fsv_minigames.qc;h=415417b465f627ec1f3420e6c35e7291d08e401b;hb=0071121b663dc3d841a2c28d27c1015899f0f402;hp=f69fc15b548c39ef99759700247db76dfdfedd5f;hpb=34ce4dd900fae362a89a911eede489d2476f9c40;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/minigames/sv_minigames.qc b/qcsrc/common/minigames/sv_minigames.qc
index f69fc15b5..415417b46 100644
--- a/qcsrc/common/minigames/sv_minigames.qc
+++ b/qcsrc/common/minigames/sv_minigames.qc
@@ -1,13 +1,14 @@
+#include "sv_minigames.qh"
 #include "minigames.qh"
 
 void player_clear_minigame(entity player)
 {
-	player.active_minigame = world;
-	player.minigame_players = world;
+	CS(player).active_minigame = NULL;
+	player.minigame_players = NULL;
 	if ( IS_PLAYER(player) )
-		player.movetype = MOVETYPE_WALK;
+		set_movetype(player, MOVETYPE_WALK);
 	else
-		player.movetype = MOVETYPE_FLY_WORLDONLY;
+		set_movetype(player, MOVETYPE_FLY_WORLDONLY);
 	player.team_forced = 0;
 }
 
@@ -18,29 +19,29 @@ void minigame_rmplayer(entity minigame_session, entity player)
 
 	if ( p.minigame_players == player )
 	{
-		if ( p.list_next == world )
+		if ( p.list_next == NULL )
 		{
 			end_minigame(minigame_session);
 			return;
 		}
 		minigame_session.minigame_event(minigame_session,"part",player);
 		GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
-			ftos(num_for_edict(player)),":",player.netname));
+			ftos(etof(player)),":",player.netname));
 		minigame_session.minigame_players = p.list_next;
-		remove ( p );
+		delete( p );
 		player_clear_minigame(player);
 	}
 	else
 	{
-		for ( e = p.list_next; e != world; e = e.list_next )
+		for ( e = p.list_next; e != NULL; e = e.list_next )
 		{
 			if ( e.minigame_players == player )
 			{
 				minigame_session.minigame_event(minigame_session,"part",player);
 				GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
-					ftos(num_for_edict(player)),":",player.netname));
+					ftos(etof(player)),":",player.netname));
 				p.list_next = e.list_next;
-				remove(e);
+				delete(e);
 				player_clear_minigame(player);
 				return;
 			}
@@ -50,10 +51,10 @@ void minigame_rmplayer(entity minigame_session, entity player)
 }
 
 
-#define FIELD(Flags, Type,Name) if ( sf & (Flags) ) Write##Type(MSG_ENTITY, self.Name);
+#define FIELD(Flags, Type,Name) if ( sf & (Flags) ) Write##Type(MSG_ENTITY, this.Name);
 #define MSLE(Name,Fields) \
-	else if ( self.classname == #Name ) { \
-		if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,self.owner.netname); \
+	else if ( this.classname == #Name ) { \
+		if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,this.owner.netname); \
 		Fields }
 
 // Send an entity to a client
@@ -65,35 +66,35 @@ bool minigame_SendEntity(entity this, entity to, int sf)
 
 	if ( sf & MINIG_SF_CREATE )
 	{
-		WriteShort(MSG_ENTITY,msle_id(self.classname));
-		WriteString(MSG_ENTITY,self.netname);
+		WriteShort(MSG_ENTITY,msle_id(this.classname));
+		WriteString(MSG_ENTITY,this.netname);
 	}
 
-	entity minigame_ent = self.owner;
+	entity minigame_ent = this.owner;
 
-	if ( self.classname == "minigame" )
+	if ( this.classname == "minigame" )
 	{
-		minigame_ent = self;
+		minigame_ent = this;
 
 		if ( sf & MINIG_SF_CREATE )
-			WriteString(MSG_ENTITY,self.descriptor.netname);
+			WriteString(MSG_ENTITY,this.descriptor.netname);
 
 		if ( sf & MINIG_SF_UPDATE )
-			WriteLong(MSG_ENTITY,self.minigame_flags);
+			WriteLong(MSG_ENTITY,this.minigame_flags);
 	}
-	else if ( self.classname == "minigame_player" )
+	else if ( this.classname == "minigame_player" )
 	{
 		if ( sf & MINIG_SF_CREATE )
 		{
-			WriteString(MSG_ENTITY,self.owner.netname);
-			WriteLong(MSG_ENTITY,num_for_edict(self.minigame_players));
+			WriteString(MSG_ENTITY,this.owner.netname);
+			WriteLong(MSG_ENTITY,etof(this.minigame_players));
 		}
 		if ( sf & MINIG_SF_UPDATE )
-			WriteByte(MSG_ENTITY,self.team);
+			WriteByte(MSG_ENTITY,this.team);
 	}
 	MINIGAME_SIMPLELINKED_ENTITIES
 
-	minigame_ent.minigame_event(minigame_ent,"network_send",self,sf);
+	minigame_ent.minigame_event(minigame_ent,"network_send",this,sf);
 
 	return true;
 
@@ -105,29 +106,29 @@ bool minigame_SendEntity(entity this, entity to, int sf)
 void minigame_resend(entity minigame)
 {
 	minigame.SendFlags = MINIG_SF_ALL;
-	entity e = world;
+	entity e = NULL;
 	while (( e = findentity(e,owner,minigame) ))
 	{
 		e.SendFlags = MINIG_SF_ALL;
 	}
 }
 
-bool minigame_CheckSend()
-{SELFPARAM();
+bool minigame_CheckSend(entity this, entity client)
+{
 	entity e;
-	for ( e = self.owner.minigame_players; e != world; e = e.list_next )
-		if ( e.minigame_players == other )
+	for ( e = this.owner.minigame_players; e != NULL; e = e.list_next )
+		if ( e.minigame_players == client )
 			return true;
 	return false;
 }
 
 int minigame_addplayer(entity minigame_session, entity player)
-{SELFPARAM();
-	if ( player.active_minigame )
+{
+	if ( CS(player).active_minigame )
 	{
-		if ( player.active_minigame == minigame_session )
+		if ( CS(player).active_minigame == minigame_session )
 			return 0;
-		minigame_rmplayer(player.active_minigame,player);
+		minigame_rmplayer(CS(player).active_minigame,player);
 	}
 	entity player_pointer = new(minigame_player);
 	int mgteam = minigame_session.minigame_event(minigame_session,"join",player,player_pointer);
@@ -139,23 +140,23 @@ int minigame_addplayer(entity minigame_session, entity player)
 		player_pointer.team = mgteam;
 		player_pointer.list_next = minigame_session.minigame_players;
 		minigame_session.minigame_players = player_pointer;
-		player.active_minigame = minigame_session;
+		CS(player).active_minigame = minigame_session;
 		player.minigame_players = player_pointer;
-		player_pointer.customizeentityforclient = minigame_CheckSend;
+		setcefc(player_pointer, minigame_CheckSend);
 		Net_LinkEntity(player_pointer, false, 0, minigame_SendEntity);
 
 		if ( !IS_OBSERVER(player) && autocvar_sv_minigames_observer )
 		{
-			WITH(entity, self, player, PutObserverInServer());
+			PutObserverInServer(player);
 		}
 		if ( autocvar_sv_minigames_observer == 2 )
 			player.team_forced = -1;
 
 		minigame_resend(minigame_session);
 	}
-	else { remove(player_pointer); }
+	else { delete(player_pointer); }
 	GameLogEcho(strcat(":minigame:join",(mgteam?"":"fail"),":",minigame_session.netname,":",
-		ftos(num_for_edict(player)),":",player.netname));
+		ftos(etof(player)),":",player.netname));
 
 	return mgteam;
 }
@@ -163,22 +164,22 @@ int minigame_addplayer(entity minigame_session, entity player)
 entity start_minigame(entity player, string minigame )
 {
 	if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
-		return world;
+		return NULL;
 
 	entity e = minigame_get_descriptor(minigame);
 	if ( e )
 	{
 		entity minig = new(minigame);
-		minig.netname = strzone(strcat(e.netname,"_",ftos(num_for_edict(minig))));
+		minig.netname = strzone(strcat(e.netname,"_",ftos(etof(minig))));
 		minig.descriptor = e;
 		minig.minigame_event = e.minigame_event;
 		minig.minigame_event(minig,"start");
 		GameLogEcho(strcat(":minigame:start:",minig.netname));
 		if ( ! minigame_addplayer(minig,player) )
 		{
-			LOG_TRACE("Minigame ",minig.netname," rejected the first player join!\n");
+			LOG_TRACE("Minigame ",minig.netname," rejected the first player join!");
 			end_minigame(minig);
-			return world;
+			return NULL;
 		}
 		Net_LinkEntity(minig, false, 0, minigame_SendEntity);
 
@@ -193,28 +194,28 @@ entity start_minigame(entity player, string minigame )
 		return minig;
 	}
 
-	return world;
+	return NULL;
 }
 
 entity join_minigame(entity player, string game_id )
 {
 	if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
-		return world;
+		return NULL;
 
 	entity minig;
-	for ( minig = minigame_sessions; minig != world; minig = minig.list_next )
+	for ( minig = minigame_sessions; minig != NULL; minig = minig.list_next )
 	{
 		if ( minig.netname == game_id )
 		if ( minigame_addplayer(minig,player) )
 			return minig;
 	}
 
-	return world;
+	return NULL;
 }
 
 void part_minigame(entity player )
 {
-	entity minig = player.active_minigame;
+	entity minig = CS(player).active_minigame;
 
 	if ( minig && minig.classname == "minigame" )
 		minigame_rmplayer(minig,player);
@@ -231,24 +232,24 @@ void end_minigame(entity minigame_session)
 	GameLogEcho(strcat(":minigame:end:",minigame_session.netname));
 
 
-	entity e = world;
+	entity e = NULL;
 	while( (e = findentity(e, owner, minigame_session)) )
 		if ( e.minigame_autoclean )
 		{
-			LOG_TRACE("SV Auto-cleaned: ",ftos(num_for_edict(e)), " (",e.classname,")\n");
-			remove(e);
+			LOG_TRACE("SV Auto-cleaned: ",ftos(etof(e)), " (",e.classname,")");
+			delete(e);
 		}
 
 	entity p;
-	for ( e = minigame_session.minigame_players; e != world; e = p )
+	for ( e = minigame_session.minigame_players; e != NULL; e = p )
 	{
 		p = e.list_next;
 		player_clear_minigame(e.minigame_players);
-		remove(e);
+		delete(e);
 	}
 
 	strunzone(minigame_session.netname);
-	remove(minigame_session);
+	delete(minigame_session);
 }
 
 void end_minigames()
@@ -261,52 +262,53 @@ void end_minigames()
 
 string invite_minigame(entity inviter, entity player)
 {
-	if ( !inviter || !inviter.active_minigame )
+	if ( !inviter || !CS(inviter).active_minigame )
 		return "Invalid minigame";
-	if ( !VerifyClientEntity(player, true, false) )
+	if ( VerifyClientEntity(player, true, false) <= 0 )
 		return "Invalid player";
 	if ( inviter == player )
 		return "You can't invite yourself";
-	if ( player.active_minigame == inviter.active_minigame )
+	if ( CS(player).active_minigame == CS(inviter).active_minigame )
 		return strcat(player.netname," is already playing");
 
 	Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
-		inviter.active_minigame.netname, inviter.netname );
+		CS(inviter).active_minigame.netname, inviter.netname );
 
-	GameLogEcho(strcat(":minigame:invite:",inviter.active_minigame.netname,":",
-		ftos(num_for_edict(player)),":",player.netname));
+	GameLogEcho(strcat(":minigame:invite:",CS(inviter).active_minigame.netname,":",
+		ftos(etof(player)),":",player.netname));
 
 	return "";
 }
 
 entity minigame_find_player(entity client)
 {
-	if ( ! client.active_minigame )
-		return world;
+	if ( ! CS(client).active_minigame )
+		return NULL;
 	entity e;
-	for ( e = client.active_minigame.minigame_players; e; e = e.list_next )
+	for ( e = CS(client).active_minigame.minigame_players; e; e = e.list_next )
 		if ( e.minigame_players == client )
 			return e;
-	return world;
+	return NULL;
 }
 
-bool MinigameImpulse(int imp)
-{SELFPARAM();
-	entity e = minigame_find_player(self);
-	if ( imp && self.active_minigame && e )
+bool MinigameImpulse(entity this, int imp)
+{
+	if (!CS(this).active_minigame) return false;
+	entity e = minigame_find_player(this);
+	if ( imp && CS(this).active_minigame && e )
 	{
-		return self.active_minigame.minigame_event(self.active_minigame,"impulse",e,imp);
+		return CS(this).active_minigame.minigame_event(CS(this).active_minigame,"impulse",e,imp);
 	}
 	return false;
 }
 
 
 
-void ClientCommand_minigame(int request, int argc, string command)
-{SELFPARAM();
+void ClientCommand_minigame(entity caller, int request, int argc, string command)
+{
 	if ( !autocvar_sv_minigames )
 	{
-		sprint(self,"Minigames are not enabled!\n");
+		sprint(caller,"Minigames are not enabled!\n");
 		return;
 	}
 
@@ -315,91 +317,88 @@ void ClientCommand_minigame(int request, int argc, string command)
 		string minig_cmd = argv(1);
 		if ( minig_cmd == "create" && argc > 2 )
 		{
-			entity minig = start_minigame(self, argv(2));
+			entity minig = start_minigame(caller, argv(2));
 			if ( minig )
-				sprint(self,"Created minigame session: ",minig.netname,"\n");
+				sprint(caller,"Created minigame session: ",minig.netname,"\n");
 			else
-				sprint(self,"Cannot start minigame session!\n");
+				sprint(caller,"Cannot start minigame session!\n");
 			return;
 		}
 		else if ( minig_cmd == "join" && argc > 2 )
 		{
-			entity minig = join_minigame(self, argv(2));
+			entity minig = join_minigame(caller, argv(2));
 			if ( minig )
-				sprint(self,"Joined: ",minig.netname,"\n");
+				sprint(caller,"Joined: ",minig.netname,"\n");
 			else
 			{
-				Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_JOIN_PREVENT_MINIGAME);
-				sprint(self,"Cannot join given minigame session!\n");
+				Send_Notification(NOTIF_ONE, caller, MSG_CENTER, CENTER_JOIN_PREVENT_MINIGAME);
+				sprint(caller,"Cannot join given minigame session!\n");
 			}
 			return;
 		}
 		else if ( minig_cmd == "list" )
 		{
-			FOREACH(Minigames, true, LAMBDA(
-			{
-				sprint(self,it.netname," (",it.message,") ","\n");
-			}));
+			FOREACH(Minigames, true, sprint(caller, it.netname, " (", it.message, ") ", "\n"));
 			return;
 		}
 		else if ( minig_cmd == "list-sessions" )
 		{
 			entity e;
-			for ( e = minigame_sessions; e != world; e = e.list_next )
-				sprint(self,e.netname,"\n");
+			for ( e = minigame_sessions; e != NULL; e = e.list_next )
+				sprint(caller,e.netname,"\n");
 			return;
 		}
 		else if ( minig_cmd == "end" || minig_cmd == "part" )
 		{
-			if ( self.active_minigame )
+			if ( CS(caller).active_minigame )
 			{
-				part_minigame(self);
-				sprint(self,"Left minigame session\n");
+				part_minigame(caller);
+				sprint(caller,"Left minigame session\n");
 			}
 			else
-				sprint(self,"You aren't playing any minigame...\n");
+				sprint(caller,"You aren't playing any minigame...\n");
 			return;
 		}
 		else if ( minig_cmd == "invite" && argc > 2 )
 		{
-			if ( self.active_minigame )
+			if ( CS(caller).active_minigame )
 			{
 				entity client = GetIndexedEntity(argc, 2);
-				string error = invite_minigame(self,client);
+				string error = invite_minigame(caller,client);
 				if ( error == "" )
 				{
-					sprint(self,"You have invited ",client.netname,
-						" to join your game of ", self.active_minigame.descriptor.message, "\n");
+					sprint(caller,"You have invited ",client.netname,
+						" to join your game of ", CS(caller).active_minigame.descriptor.message, "\n");
 				}
 				else
-					sprint(self,"Could not invite: ", error, ".\n");
+					sprint(caller,"Could not invite: ", error, ".\n");
 			}
 			else
-				sprint(self,"You aren't playing any minigame...\n");
+				sprint(caller,"You aren't playing any minigame...\n");
 			return;
 		}
-		else if ( self.active_minigame )
+		else if ( CS(caller).active_minigame )
 		{
-			entity e = minigame_find_player(self);
+			entity e = minigame_find_player(caller);
 			string subcommand = substring(command,argv_end_index(0),-1);
 			int arg_c = tokenize_console(subcommand);
-			if ( self.active_minigame.minigame_event(self.active_minigame,"cmd",e,arg_c,subcommand) )
+			if ( CS(caller).active_minigame.minigame_event(CS(caller).active_minigame,"cmd",e,arg_c,subcommand) )
 				return;
 
 		}
-		else sprint(self,strcat("Wrong command:^1 ",command,"\n"));
+		else sprint(caller,strcat("Wrong command:^1 ",command,"\n"));
 	}
 
-	sprint(self, "\nUsage:^3 cmd minigame create <minigame>\n");
-	sprint(self, "  Start a new minigame session\n");
-	sprint(self, "Usage:^3 cmd minigame join <session>\n");
-	sprint(self, "  Join an exising minigame session\n");
-	sprint(self, "Usage:^3 cmd minigame list\n");
-	sprint(self, "  List available minigames\n");
-	sprint(self, "Usage:^3 cmd minigame list-sessions\n");
-	sprint(self, "  List available minigames sessions\n");
-	sprint(self, "Usage:^3 cmd minigame part|end\n");
-	sprint(self, "  Leave the current minigame\n");
-	sprint(self, "Usage:^3 cmd minigame invite <player>\n");
-	sprint(self, "  Invite the given player to join you in a minigame\n");
+	sprint(caller, "\nUsage:^3 cmd minigame create <minigame>\n");
+	sprint(caller, "  Start a new minigame session\n");
+	sprint(caller, "Usage:^3 cmd minigame join <session>\n");
+	sprint(caller, "  Join an exising minigame session\n");
+	sprint(caller, "Usage:^3 cmd minigame list\n");
+	sprint(caller, "  List available minigames\n");
+	sprint(caller, "Usage:^3 cmd minigame list-sessions\n");
+	sprint(caller, "  List available minigames sessions\n");
+	sprint(caller, "Usage:^3 cmd minigame part|end\n");
+	sprint(caller, "  Leave the current minigame\n");
+	sprint(caller, "Usage:^3 cmd minigame invite <player>\n");
+	sprint(caller, "  Invite the given player to join you in a minigame\n");
 }