qcsrc/common/minigames/sv_minigames.qc

   1 #include "minigames.qh"
   2
   3 void player_clear_minigame(entity player)
   4 {
   5         player.active_minigame = world;
   6         player.minigame_players = world;
   7         if ( IS_PLAYER(player) )
   8                 player.movetype = MOVETYPE_WALK;
   9         else
  10                 player.movetype = MOVETYPE_FLY_WORLDONLY;
  11         player.team_forced = 0;
  12 }
  13
  14 void minigame_rmplayer(entity minigame_session, entity player)
  15 {
  16         entity e;
  17         entity p = minigame_session.minigame_players;
  18
  19         if ( p.minigame_players == player )
  20         {
  21                 if ( p.list_next == world )
  22                 {
  23                         end_minigame(minigame_session);
  24                         return;
  25                 }
  26                 minigame_session.minigame_event(minigame_session,"part",player);
  27                 GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
  28                         ftos(num_for_edict(player)),":",player.netname));
  29                 minigame_session.minigame_players = p.list_next;
  30                 remove ( p );
  31                 player_clear_minigame(player);
  32         }
  33         else
  34         {
  35                 for ( e = p.list_next; e != world; e = e.list_next )
  36                 {
  37                         if ( e.minigame_players == player )
  38                         {
  39                                 minigame_session.minigame_event(minigame_session,"part",player);
  40                                 GameLogEcho(strcat(":minigame:part:",minigame_session.netname,":",
  41                                         ftos(num_for_edict(player)),":",player.netname));
  42                                 p.list_next = e.list_next;
  43                                 remove(e);
  44                                 player_clear_minigame(player);
  45                                 return;
  46                         }
  47                         p = e;
  48                 }
  49         }
  50 }
  51
  52
  53 #define FIELD(Flags, Type,Name) if ( sf & (Flags) ) Write##Type(MSG_ENTITY, self.Name);
  54 #define WriteVector(to,Name) WriteCoord(to,Name##_x); WriteCoord(to,Name##_y); WriteCoord(to,Name##_z)
  55 #define WriteVector2D(to,Name) WriteCoord(to,Name##_x); WriteCoord(to,Name##_y)
  56 #define MSLE(Name,Fields) \
  57         else if ( self.classname == #Name ) { \
  58                 if ( sf & MINIG_SF_CREATE ) WriteString(MSG_ENTITY,self.owner.netname); \
  59                 Fields }
  60
  61 // Send an entity to a client
  62 // only use on minigame entities or entities with a minigame owner
  63 bool minigame_SendEntity(entity this, entity to, int sf)
  64 {
  65         WriteByte(MSG_ENTITY, ENT_CLIENT_MINIGAME);
  66         WriteByte(MSG_ENTITY, sf);
  67
  68         if ( sf & MINIG_SF_CREATE )
  69         {
  70                 WriteShort(MSG_ENTITY,msle_id(self.classname));
  71                 WriteString(MSG_ENTITY,self.netname);
  72         }
  73
  74         entity minigame_ent = self.owner;
  75
  76         if ( self.classname == "minigame" )
  77         {
  78                 minigame_ent = self;
  79
  80                 if ( sf & MINIG_SF_CREATE )
  81                         WriteString(MSG_ENTITY,self.descriptor.netname);
  82
  83                 if ( sf & MINIG_SF_UPDATE )
  84                         WriteLong(MSG_ENTITY,self.minigame_flags);
  85         }
  86         else if ( self.classname == "minigame_player" )
  87         {
  88                 if ( sf & MINIG_SF_CREATE )
  89                 {
  90                         WriteString(MSG_ENTITY,self.owner.netname);
  91                         WriteLong(MSG_ENTITY,num_for_edict(self.minigame_players));
  92                 }
  93                 if ( sf & MINIG_SF_UPDATE )
  94                         WriteByte(MSG_ENTITY,self.team);
  95         }
  96         MINIGAME_SIMPLELINKED_ENTITIES
  97
  98         minigame_ent.minigame_event(minigame_ent,"network_send",self,sf);
  99
 100         return true;
 101
 102 }
 103 #undef FIELD
 104 #undef MSLE
 105
 106 // Force resend all minigame entities
 107 void minigame_resend(entity minigame)
 108 {
 109         minigame.SendFlags = MINIG_SF_ALL;
 110         entity e = world;
 111         while (( e = findentity(e,owner,minigame) ))
 112         {
 113                 e.SendFlags = MINIG_SF_ALL;
 114         }
 115 }
 116
 117 bool minigame_CheckSend()
 118 {SELFPARAM();
 119         entity e;
 120         for ( e = self.owner.minigame_players; e != world; e = e.list_next )
 121                 if ( e.minigame_players == other )
 122                         return true;
 123         return false;
 124 }
 125
 126 int minigame_addplayer(entity minigame_session, entity player)
 127 {SELFPARAM();
 128         if ( player.active_minigame )
 129         {
 130                 if ( player.active_minigame == minigame_session )
 131                         return 0;
 132                 minigame_rmplayer(player.active_minigame,player);
 133         }
 134         entity player_pointer = spawn();
 135         int mgteam = minigame_session.minigame_event(minigame_session,"join",player,player_pointer);
 136
 137         if ( mgteam )
 138         {
 139                 player_pointer.classname = "minigame_player";
 140                 player_pointer.owner = minigame_session;
 141                 player_pointer.minigame_players = player;
 142                 player_pointer.team = mgteam;
 143                 player_pointer.list_next = minigame_session.minigame_players;
 144                 minigame_session.minigame_players = player_pointer;
 145                 player.active_minigame = minigame_session;
 146                 player.minigame_players = player_pointer;
 147                 player_pointer.customizeentityforclient = minigame_CheckSend;
 148                 Net_LinkEntity(player_pointer, false, 0, minigame_SendEntity);
 149
 150                 if ( !IS_OBSERVER(player) && autocvar_sv_minigames_observer )
 151                 {
 152                         WITH(entity, self, player, PutObserverInServer());
 153                 }
 154                 if ( autocvar_sv_minigames_observer == 2 )
 155                         player.team_forced = -1;
 156
 157                 minigame_resend(minigame_session);
 158         }
 159         else { remove(player_pointer); }
 160         GameLogEcho(strcat(":minigame:join",(mgteam?"":"fail"),":",minigame_session.netname,":",
 161                 ftos(num_for_edict(player)),":",player.netname));
 162
 163         return mgteam;
 164 }
 165
 166 entity start_minigame(entity player, string minigame )
 167 {
 168         if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
 169                 return world;
 170
 171         entity e = minigame_get_descriptor(minigame);
 172         if ( e )
 173         {
 174                 entity minig = spawn();
 175                 minig.classname = "minigame";
 176                 minig.netname = strzone(strcat(e.netname,"_",ftos(num_for_edict(minig))));
 177                 minig.descriptor = e;
 178                 minig.minigame_event = e.minigame_event;
 179                 minig.minigame_event(minig,"start");
 180                 GameLogEcho(strcat(":minigame:start:",minig.netname));
 181                 if ( ! minigame_addplayer(minig,player) )
 182                 {
 183                         LOG_TRACE("Minigame ",minig.netname," rejected the first player join!\n");
 184                         end_minigame(minig);
 185                         return world;
 186                 }
 187                 Net_LinkEntity(minig, false, 0, minigame_SendEntity);
 188
 189                 if ( !minigame_sessions )
 190                         minigame_sessions = minig;
 191                 else
 192                 {
 193                         minigame_sessions.owner = minig;
 194                         minig.list_next = minigame_sessions;
 195                         minigame_sessions = minig;
 196                 }
 197                 return minig;
 198         }
 199
 200         return world;
 201 }
 202
 203 entity join_minigame(entity player, string game_id )
 204 {
 205         if ( !autocvar_sv_minigames || !IS_REAL_CLIENT(player) )
 206                 return world;
 207
 208         entity minig;
 209         for ( minig = minigame_sessions; minig != world; minig = minig.list_next )
 210         {
 211                 if ( minig.netname == game_id )
 212                 if ( minigame_addplayer(minig,player) )
 213                         return minig;
 214         }
 215
 216         return world;
 217 }
 218
 219 void part_minigame(entity player )
 220 {
 221         entity minig = player.active_minigame;
 222
 223         if ( minig && minig.classname == "minigame" )
 224                 minigame_rmplayer(minig,player);
 225 }
 226
 227 void end_minigame(entity minigame_session)
 228 {
 229         if ( minigame_session.owner )
 230                 minigame_session.owner.list_next = minigame_session.list_next;
 231         else
 232                 minigame_sessions = minigame_session.list_next;
 233
 234         minigame_session.minigame_event(minigame_session,"end");
 235         GameLogEcho(strcat(":minigame:end:",minigame_session.netname));
 236
 237
 238         entity e = world;
 239         while( (e = findentity(e, owner, minigame_session)) )
 240                 if ( e.minigame_autoclean )
 241                 {
 242                         LOG_TRACE("SV Auto-cleaned: ",ftos(num_for_edict(e)), " (",e.classname,")\n");
 243                         remove(e);
 244                 }
 245
 246         entity p;
 247         for ( e = minigame_session.minigame_players; e != world; e = p )
 248         {
 249                 p = e.list_next;
 250                 player_clear_minigame(e.minigame_players);
 251                 remove(e);
 252         }
 253
 254         strunzone(minigame_session.netname);
 255         remove(minigame_session);
 256 }
 257
 258 void end_minigames()
 259 {
 260         while ( minigame_sessions )
 261         {
 262                 end_minigame(minigame_sessions);
 263         }
 264 }
 265
 266 string invite_minigame(entity inviter, entity player)
 267 {
 268         if ( !inviter || !inviter.active_minigame )
 269                 return "Invalid minigame";
 270         if ( !VerifyClientEntity(player, true, false) )
 271                 return "Invalid player";
 272         if ( inviter == player )
 273                 return "You can't invite yourself";
 274         if ( player.active_minigame == inviter.active_minigame )
 275                 return strcat(player.netname," is already playing");
 276
 277         Send_Notification(NOTIF_ONE, player, MSG_INFO, INFO_MINIGAME_INVITE,
 278                 inviter.active_minigame.netname, inviter.netname );
 279
 280         GameLogEcho(strcat(":minigame:invite:",inviter.active_minigame.netname,":",
 281                 ftos(num_for_edict(player)),":",player.netname));
 282
 283         return "";
 284 }
 285
 286 entity minigame_find_player(entity client)
 287 {
 288         if ( ! client.active_minigame )
 289                 return world;
 290         entity e;
 291         for ( e = client.active_minigame.minigame_players; e; e = e.list_next )
 292                 if ( e.minigame_players == client )
 293                         return e;
 294         return world;
 295 }
 296
 297 bool MinigameImpulse(int imp)
 298 {SELFPARAM();
 299         entity e = minigame_find_player(self);
 300         if ( imp && self.active_minigame && e )
 301         {
 302                 return self.active_minigame.minigame_event(self.active_minigame,"impulse",e,imp);
 303         }
 304         return false;
 305 }
 306
 307
 308
 309 void ClientCommand_minigame(int request, int argc, string command)
 310 {SELFPARAM();
 311         if ( !autocvar_sv_minigames )
 312         {
 313                 sprint(self,"Minigames are not enabled!\n");
 314                 return;
 315         }
 316
 317         if (request == CMD_REQUEST_COMMAND )
 318         {
 319                 string minig_cmd = argv(1);
 320                 if ( minig_cmd == "create" && argc > 2 )
 321                 {
 322                         entity minig = start_minigame(self, argv(2));
 323                         if ( minig )
 324                                 sprint(self,"Created minigame session: ",minig.netname,"\n");
 325                         else
 326                                 sprint(self,"Cannot start minigame session!\n");
 327                         return;
 328                 }
 329                 else if ( minig_cmd == "join" && argc > 2 )
 330                 {
 331                         entity minig = join_minigame(self, argv(2));
 332                         if ( minig )
 333                                 sprint(self,"Joined: ",minig.netname,"\n");
 334                         else
 335                         {
 336                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_JOIN_PREVENT_MINIGAME);
 337                                 sprint(self,"Cannot join given minigame session!\n");
 338                         }
 339                         return;
 340                 }
 341                 else if ( minig_cmd == "list" )
 342                 {
 343                         FOREACH(Minigames, true, LAMBDA(
 344                         {
 345                                 sprint(self,it.netname," (",it.message,") ","\n");
 346                         }));
 347                         return;
 348                 }
 349                 else if ( minig_cmd == "list-sessions" )
 350                 {
 351                         entity e;
 352                         for ( e = minigame_sessions; e != world; e = e.list_next )
 353                                 sprint(self,e.netname,"\n");
 354                         return;
 355                 }
 356                 else if ( minig_cmd == "end" || minig_cmd == "part" )
 357                 {
 358                         if ( self.active_minigame )
 359                         {
 360                                 part_minigame(self);
 361                                 sprint(self,"Left minigame session\n");
 362                         }
 363                         else
 364                                 sprint(self,"You aren't playing any minigame...\n");
 365                         return;
 366                 }
 367                 else if ( minig_cmd == "invite" && argc > 2 )
 368                 {
 369                         if ( self.active_minigame )
 370                         {
 371                                 entity client = GetIndexedEntity(argc, 2);
 372                                 string error = invite_minigame(self,client);
 373                                 if ( error == "" )
 374                                 {
 375                                         sprint(self,"You have invited ",client.netname,
 376                                                 " to join your game of ", self.active_minigame.descriptor.message, "\n");
 377                                 }
 378                                 else
 379                                         sprint(self,"Could not invite: ", error, ".\n");
 380                         }
 381                         else
 382                                 sprint(self,"You aren't playing any minigame...\n");
 383                         return;
 384                 }
 385                 else if ( self.active_minigame )
 386                 {
 387                         entity e = minigame_find_player(self);
 388                         string subcommand = substring(command,argv_end_index(0),-1);
 389                         int arg_c = tokenize_console(subcommand);
 390                         if ( self.active_minigame.minigame_event(self.active_minigame,"cmd",e,arg_c,subcommand) )
 391                                 return;
 392
 393                 }
 394                 else sprint(self,strcat("Wrong command:^1 ",command,"\n"));
 395         }
 396
 397         sprint(self, "\nUsage:^3 cmd minigame create <minigame>\n");
 398         sprint(self, "  Start a new minigame session\n");
 399         sprint(self, "Usage:^3 cmd minigame join <session>\n");
 400         sprint(self, "  Join an exising minigame session\n");
 401         sprint(self, "Usage:^3 cmd minigame list\n");
 402         sprint(self, "  List available minigames\n");
 403         sprint(self, "Usage:^3 cmd minigame list-sessions\n");
 404         sprint(self, "  List available minigames sessions\n");
 405         sprint(self, "Usage:^3 cmd minigame part|end\n");
 406         sprint(self, "  Leave the current minigame\n");
 407         sprint(self, "Usage:^3 cmd minigame invite <player>\n");
 408         sprint(self, "  Invite the given player to join you in a minigame\n");
 409 }