+#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;
}
if ( p.minigame_players == player )
{
- if ( p.list_next == world )
+ if ( p.list_next == NULL )
{
end_minigame(minigame_session);
return;
GameLogEcho(strcat(":minigame:part:",minigame_session.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 )
{
GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
ftos(etof(player)),":",player.netname));
p.list_next = e.list_next;
- remove(e);
+ delete(e);
player_clear_minigame(player);
return;
}
}
-#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
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,etof(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;
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);
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 )
{
- WITHSELF(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(etof(player)),":",player.netname));
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 )
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);
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);
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(etof(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()
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,":",
+ 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(entity this, int imp)
{
- if (!this.active_minigame) return false;
+ if (!CS(this).active_minigame) return false;
entity e = minigame_find_player(this);
- if ( imp && this.active_minigame && e )
+ if ( imp && CS(this).active_minigame && e )
{
- return this.active_minigame.minigame_event(this.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;
}
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, 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");
}
projects / xonotic / xonotic-data.pk3dir.git / blobdiff