void player_clear_minigame(entity player)
{
player.active_minigame = world;
+ player.minigame_players = world;
if ( IS_PLAYER(player) )
player.movetype = MOVETYPE_WALK;
else
{
entity e;
entity p = minigame_session.minigame_players;
-
+
if ( p.minigame_players == player )
{
if ( p.list_next == world )
#define FIELD(Flags, Type,Name) if ( sf & (Flags) ) Write##Type(MSG_ENTITY, self.Name);
-#define WriteVector(to,Name) WriteCoord(to,Name##_x); WriteCoord(to,Name##_y); WriteCoord(to,Name##_z)
-#define WriteVector2D(to,Name) WriteCoord(to,Name##_x); WriteCoord(to,Name##_y)
-#define WriteFloat WriteCoord
#define MSLE(Name,Fields) \
else if ( self.classname == #Name ) { \
if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,self.owner.netname); \
// Send an entity to a client
// only use on minigame entities or entities with a minigame owner
-bool minigame_SendEntity(entity to, int sf)
+bool minigame_SendEntity(entity this, entity to, int sf)
{
- WriteByte(MSG_ENTITY, ENT_CLIENT_MINIGAME);
+ WriteHeader(MSG_ENTITY, ENT_CLIENT_MINIGAME);
WriteByte(MSG_ENTITY, sf);
-
+
if ( sf & MINIG_SF_CREATE )
{
WriteShort(MSG_ENTITY,msle_id(self.classname));
WriteString(MSG_ENTITY,self.netname);
}
-
+
entity minigame_ent = self.owner;
-
+
if ( self.classname == "minigame" )
{
minigame_ent = self;
-
+
if ( sf & MINIG_SF_CREATE )
WriteString(MSG_ENTITY,self.descriptor.netname);
-
+
if ( sf & MINIG_SF_UPDATE )
WriteLong(MSG_ENTITY,self.minigame_flags);
}
WriteByte(MSG_ENTITY,self.team);
}
MINIGAME_SIMPLELINKED_ENTITIES
-
+
minigame_ent.minigame_event(minigame_ent,"network_send",self,sf);
-
+
return true;
-
+
}
#undef FIELD
#undef MSLE
-#undef WriteFloat
// Force resend all minigame entities
void minigame_resend(entity minigame)
}
bool minigame_CheckSend()
-{
+{SELFPARAM();
entity e;
for ( e = self.owner.minigame_players; e != world; e = e.list_next )
if ( e.minigame_players == other )
}
int minigame_addplayer(entity minigame_session, entity player)
-{
+{SELFPARAM();
if ( player.active_minigame )
{
if ( player.active_minigame == minigame_session )
return 0;
minigame_rmplayer(player.active_minigame,player);
}
-
- int mgteam = minigame_session.minigame_event(minigame_session,"join",player);
-
+ entity player_pointer = new(minigame_player);
+ int mgteam = minigame_session.minigame_event(minigame_session,"join",player,player_pointer);
+
if ( mgteam )
{
- entity player_pointer = spawn();
- player_pointer.classname = "minigame_player";
player_pointer.owner = minigame_session;
player_pointer.minigame_players = player;
player_pointer.team = mgteam;
player_pointer.list_next = minigame_session.minigame_players;
minigame_session.minigame_players = player_pointer;
player.active_minigame = minigame_session;
+ player.minigame_players = player_pointer;
player_pointer.customizeentityforclient = minigame_CheckSend;
Net_LinkEntity(player_pointer, false, 0, minigame_SendEntity);
if ( !IS_OBSERVER(player) && autocvar_sv_minigames_observer )
{
- entity e = self;
- self = player;
- PutObserverInServer();
- self = e;
+ WITH(entity, self, player, PutObserverInServer());
}
if ( autocvar_sv_minigames_observer == 2 )
player.team_forced = -1;
-
+
minigame_resend(minigame_session);
}
+ else { remove(player_pointer); }
GameLogEcho(strcat(":minigame:join",(mgteam?"":"fail"),":",minigame_session.netname,":",
ftos(num_for_edict(player)),":",player.netname));
-
+
return mgteam;
}
{
if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
return world;
-
+
entity e = minigame_get_descriptor(minigame);
- if ( e )
+ if ( e )
{
- entity minig = spawn();
- minig.classname = "minigame";
+ entity minig = new(minigame);
minig.netname = strzone(strcat(e.netname,"_",ftos(num_for_edict(minig))));
minig.descriptor = e;
minig.minigame_event = e.minigame_event;
GameLogEcho(strcat(":minigame:start:",minig.netname));
if ( ! minigame_addplayer(minig,player) )
{
- dprint("Minigame ",minig.netname," rejected the first player join!\n");
+ LOG_TRACE("Minigame ",minig.netname," rejected the first player join!\n");
end_minigame(minig);
return world;
}
Net_LinkEntity(minig, false, 0, minigame_SendEntity);
-
+
if ( !minigame_sessions )
minigame_sessions = minig;
else
}
return minig;
}
-
+
return world;
}
{
if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
return world;
-
+
entity minig;
for ( minig = minigame_sessions; minig != world; minig = minig.list_next )
{
if ( minigame_addplayer(minig,player) )
return minig;
}
-
+
return world;
}
void part_minigame(entity player )
{
entity minig = player.active_minigame;
-
+
if ( minig && minig.classname == "minigame" )
minigame_rmplayer(minig,player);
}
minigame_session.owner.list_next = minigame_session.list_next;
else
minigame_sessions = minigame_session.list_next;
-
+
minigame_session.minigame_event(minigame_session,"end");
GameLogEcho(strcat(":minigame:end:",minigame_session.netname));
-
-
+
+
entity e = world;
while( (e = findentity(e, owner, minigame_session)) )
if ( e.minigame_autoclean )
{
- dprint("SV Auto-cleaned: ",ftos(num_for_edict(e)), " (",e.classname,")\n");
+ LOG_TRACE("SV Auto-cleaned: ",ftos(num_for_edict(e)), " (",e.classname,")\n");
remove(e);
}
-
+
entity p;
for ( e = minigame_session.minigame_players; e != world; e = p )
{
player_clear_minigame(e.minigame_players);
remove(e);
}
-
+
strunzone(minigame_session.netname);
remove(minigame_session);
}
}
}
-void initialize_minigames()
-{
- entity last_minig = world;
- entity minig;
- #define MINIGAME(name,nicename) \
- minig = spawn(); \
- minig.classname = "minigame_descriptor"; \
- minig.netname = #name; \
- minig.message = nicename; \
- minig.minigame_event = minigame_event_##name; \
- if ( !last_minig ) minigame_descriptors = minig; \
- else last_minig.list_next = minig; \
- last_minig = minig;
-
- REGISTERED_MINIGAMES
-
- #undef MINIGAME
-}
-
string invite_minigame(entity inviter, entity player)
{
if ( !inviter || !inviter.active_minigame )
return "You can't invite yourself";
if ( player.active_minigame == inviter.active_minigame )
return strcat(player.netname," is already playing");
-
- Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
+
+ Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
inviter.active_minigame.netname, inviter.netname );
-
+
GameLogEcho(strcat(":minigame:invite:",inviter.active_minigame.netname,":",
ftos(num_for_edict(player)),":",player.netname));
-
+
return "";
}
}
bool MinigameImpulse(int imp)
-{
+{SELFPARAM();
entity e = minigame_find_player(self);
if ( imp && self.active_minigame && e )
{
void ClientCommand_minigame(int request, int argc, string command)
-{
+{SELFPARAM();
if ( !autocvar_sv_minigames )
{
sprint(self,"Minigames are not enabled!\n");
return;
}
-
+
if (request == CMD_REQUEST_COMMAND )
{
string minig_cmd = argv(1);
}
else if ( minig_cmd == "list" )
{
- entity e;
- for ( e = minigame_descriptors; e != world; e = e.list_next )
- sprint(self,e.netname," (",e.message,") ","\n");
+ FOREACH(Minigames, true, LAMBDA(
+ {
+ sprint(self,it.netname," (",it.message,") ","\n");
+ }));
return;
}
else if ( minig_cmd == "list-sessions" )
int arg_c = tokenize_console(subcommand);
if ( self.active_minigame.minigame_event(self.active_minigame,"cmd",e,arg_c,subcommand) )
return;
-
+
}
else sprint(self,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, " 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");
-}
\ No newline at end of file
+}