qcsrc/server/command/common.qc

   1 // ====================================================
   2 //  Shared code for server commands, written by Samual
   3 //  Last updated: December 27th, 2011
   4 // ====================================================
   5
   6 // select the proper prefix for usage and other messages
   7 string GetCommandPrefix(entity caller)
   8 {
   9         if(caller)
  10                 return "cmd";
  11         else
  12                 return "sv_cmd";
  13 }
  14
  15 // if client return player nickname, or if server return admin nickname
  16 string GetCallerName(entity caller)
  17 {
  18         if(caller)
  19                 return caller.netname;
  20         else
  21                 return admin_name(); //((autocvar_sv_adminnick != "") ? autocvar_sv_adminnick : autocvar_hostname);
  22 }
  23
  24 // verify that the client provided is acceptable for use
  25 float VerifyClientEntity(entity client, float must_be_real, float must_be_bots)
  26 {
  27         if not(client.flags & FL_CLIENT)
  28                 return CLIENT_DOESNT_EXIST;
  29         else if(must_be_real && (clienttype(client) != CLIENTTYPE_REAL))
  30                 return CLIENT_NOT_REAL;
  31         else if(must_be_bots && (clienttype(client) != CLIENTTYPE_BOT))
  32                 return CLIENT_NOT_BOT;
  33
  34         return CLIENT_ACCEPTABLE;
  35 }
  36
  37 // if the client is not acceptable, return a string to be used for error messages
  38 string GetClientErrorString(float clienterror, string original_input)
  39 {
  40         switch(clienterror)
  41         {
  42                 case CLIENT_DOESNT_EXIST: { return strcat("Client '", original_input, "' doesn't exist"); }
  43                 case CLIENT_NOT_REAL: { return strcat("Client '", original_input, "' is not real"); }
  44                 case CLIENT_NOT_BOT: { return strcat("Client '", original_input, "' is not a bot"); }
  45                 default: { return "Incorrect usage of GetClientErrorString"; }
  46         }
  47 }
  48
  49 // is this entity number even in the possible range of entities?
  50 float VerifyClientNumber(float tmp_number)
  51 {
  52         if((tmp_number < 1) || (tmp_number > maxclients))
  53                 return FALSE;
  54         else
  55                 return TRUE;
  56 }
  57
  58 entity GetIndexedEntity(float argc, float start_index)
  59 {
  60         entity tmp_player, selection;
  61         float tmp_number, index;
  62         string tmp_string;
  63
  64         next_token = -1;
  65         index = start_index;
  66
  67         if(argc > start_index)
  68         {
  69                 if(substring(argv(index), 0, 1) == "#")
  70                 {
  71                         tmp_string = substring(argv(index), 1, -1);
  72                         ++index;
  73
  74                         if(tmp_string != "") // is it all one token? like #1
  75                         {
  76                                 tmp_number = stof(tmp_string);
  77                         }
  78                         else if(argc > index) // no, it's two tokens? # 1
  79                         {
  80                                 tmp_number = stof(argv(index));
  81                                 ++index;
  82                         }
  83                 }
  84                 else // maybe it's ONLY a number?
  85                 {
  86                         tmp_number = stof(argv(index));
  87                         ++index;
  88                 }
  89
  90                 if(VerifyClientNumber(tmp_number))
  91                 {
  92                         selection = edict_num(tmp_number); // yes, it was a number
  93                 }
  94                 else // no, maybe it's a name?
  95                 {
  96                         FOR_EACH_CLIENT(tmp_player)
  97                                 if (strdecolorize(tmp_player.netname) == strdecolorize(argv(start_index)))
  98                                         selection = tmp_player;
  99
 100                         index = (start_index + 1);
 101                 }
 102         }
 103
 104         next_token = index;
 105         print(strcat("start_index: ", ftos(start_index), ", next_token: ", ftos(next_token), ", edict: ", ftos(num_for_edict(selection)), ".\n"));
 106         return selection;
 107 }
 108
 109 // find a player which matches the input string, and return their entity
 110 entity GetFilteredEntity(string input)
 111 {
 112         entity tmp_player, selection;
 113         float tmp_number;
 114
 115         if(substring(input, 0, 1) == "#")
 116                 tmp_number = stof(substring(input, 1, -1));
 117         else
 118                 tmp_number = stof(input);
 119
 120         if(VerifyClientNumber(tmp_number))
 121         {
 122                 selection = edict_num(tmp_number);
 123         }
 124         else
 125         {
 126                 FOR_EACH_CLIENT(tmp_player)
 127                         if (strdecolorize(tmp_player.netname) == strdecolorize(input))
 128                                 selection = tmp_player;
 129         }
 130
 131         return selection;
 132 }
 133
 134 // same thing, but instead return their edict number
 135 float GetFilteredNumber(string input)
 136 {
 137         entity selection = GetFilteredEntity(input);
 138         float output;
 139
 140         if(selection) { output = num_for_edict(selection); }
 141
 142         return output;
 143 }
 144
 145 // switch between sprint and print depending on whether the reciever is the server or a player
 146 void print_to(entity to, string input)
 147 {
 148     if(to)
 149         sprint(to, strcat(input, "\n"));
 150     else
 151         print(input, "\n");
 152 }
 153
 154 // ==========================================
 155 //  Supporting functions for common commands
 156 // ==========================================
 157
 158 // used by CommonCommand_timeout() and CommonCommand_timein() to handle game pausing and messaging and such.
 159 void timeout_handler_reset()
 160 {
 161         entity tmp_player;
 162
 163         timeout_caller = world;
 164         timeout_time = 0;
 165         timeout_leadtime = 0;
 166
 167         FOR_EACH_REALPLAYER(tmp_player)
 168                 Send_CSQC_Centerprint_Generic_Expire(tmp_player, CPID_TIMEOUT_COUNTDOWN);
 169
 170         remove(self);
 171 }
 172
 173 void timeout_handler_think()
 174 {
 175         entity tmp_player;
 176
 177         switch(timeout_status)
 178         {
 179                 case TIMEOUT_ACTIVE:
 180                 {
 181                         if(timeout_time > 0) // countdown is still going
 182                         {
 183                                 FOR_EACH_REALPLAYER(tmp_player)
 184                                         Send_CSQC_Centerprint_Generic(tmp_player, CPID_TIMEOUT_COUNTDOWN, "Timeout ends in %d seconds!", 1, timeout_time);
 185
 186                                 if(timeout_time == autocvar_sv_timeout_resumetime) // play a warning sound when only <sv_timeout_resumetime> seconds are left
 187                                         Announce("prepareforbattle");
 188
 189                                 self.nextthink = time + TIMEOUT_SLOWMO_VALUE; // think again in one second
 190                                 timeout_time -= 1; // decrease the time counter
 191                         }
 192                         else // time to end the timeout
 193                         {
 194                                 timeout_status = TIMEOUT_INACTIVE;
 195
 196                                 // reset the slowmo value back to normal
 197                                 cvar_set("slowmo", ftos(orig_slowmo));
 198
 199                                 // unlock the view for players so they can move around again
 200                                 FOR_EACH_REALPLAYER(tmp_player)
 201                                         tmp_player.fixangle = FALSE;
 202
 203                                 timeout_handler_reset();
 204                         }
 205
 206                         return;
 207                 }
 208
 209                 case TIMEOUT_LEADTIME:
 210                 {
 211                         if(timeout_leadtime > 0) // countdown is still going
 212                         {
 213                                 // centerprint the information to every player
 214                                 FOR_EACH_REALPLAYER(tmp_player)
 215                                         Send_CSQC_Centerprint_Generic(tmp_player, CPID_TIMEOUT_COUNTDOWN, "Timeout begins in %d seconds!", 1, timeout_leadtime);
 216
 217                                 self.nextthink = time + 1; // think again in one second
 218                                 timeout_leadtime -= 1; // decrease the time counter
 219                         }
 220                         else // time to begin the timeout
 221                         {
 222                                 timeout_status = TIMEOUT_ACTIVE;
 223
 224                                 // set the slowmo value to the timeout default slowmo value
 225                                 cvar_set("slowmo", ftos(TIMEOUT_SLOWMO_VALUE));
 226
 227                                 // reset all the flood variables
 228                                 FOR_EACH_CLIENT(tmp_player)
 229                                         tmp_player.nickspamcount = tmp_player.nickspamtime = tmp_player.floodcontrol_chat =
 230                                         tmp_player.floodcontrol_chatteam = tmp_player.floodcontrol_chattell =
 231                                         tmp_player.floodcontrol_voice = tmp_player.floodcontrol_voiceteam = 0;
 232
 233                                 // copy .v_angle to .lastV_angle for every player in order to fix their view during pause (see PlayerPreThink)
 234                                 FOR_EACH_REALPLAYER(tmp_player)
 235                                         tmp_player.lastV_angle = tmp_player.v_angle;
 236
 237                                 self.nextthink = time; // think again next frame to handle it under TIMEOUT_ACTIVE code
 238                         }
 239
 240                         return;
 241                 }
 242
 243
 244                 case TIMEOUT_INACTIVE:
 245                 default:
 246                 {
 247                         timeout_handler_reset();
 248                         return;
 249                 }
 250         }
 251 }
 252
 253
 254
 255 // ===================================================
 256 //  Common commands used in both sv_cmd.qc and cmd.qc
 257 // ===================================================
 258
 259 void CommonCommand_cvar_changes(float request, entity caller)
 260 {
 261         switch(request)
 262         {
 263                 case CMD_REQUEST_COMMAND:
 264                 {
 265                         print_to(caller, cvar_changes);
 266                         return; // never fall through to usage
 267                 }
 268
 269                 default:
 270                 case CMD_REQUEST_USAGE:
 271                 {
 272                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_changes"));
 273                         print_to(caller, "  No arguments required.");
 274                         print_to(caller, "See also: ^2cvar_purechanges^7");
 275                         return;
 276                 }
 277         }
 278 }
 279
 280 void CommonCommand_cvar_purechanges(float request, entity caller)
 281 {
 282         switch(request)
 283         {
 284                 case CMD_REQUEST_COMMAND:
 285                 {
 286                         print_to(caller, cvar_purechanges);
 287                         return; // never fall through to usage
 288                 }
 289
 290                 default:
 291                 case CMD_REQUEST_USAGE:
 292                 {
 293                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_purechanges"));
 294                         print_to(caller, "  No arguments required.");
 295                         print_to(caller, "See also: ^2cvar_changes^7");
 296                         return;
 297                 }
 298         }
 299 }
 300
 301 void CommonCommand_info(float request, entity caller, float argc) // legacy
 302 {
 303         switch(request)
 304         {
 305                 case CMD_REQUEST_COMMAND:
 306                 {
 307                         string command = builtin_cvar_string(strcat("sv_info_", argv(1)));
 308
 309                         if(command)
 310                                 wordwrap_sprint(command, 1000);
 311                         else
 312                                 print_to(caller, "ERROR: unsupported info command");
 313
 314                         return; // never fall through to usage
 315                 }
 316
 317                 default:
 318                 case CMD_REQUEST_USAGE:
 319                 {
 320                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " info request"));
 321                         print_to(caller, "  Where 'request' is the suffixed string appended onto the request for cvar.");
 322                         return;
 323                 }
 324         }
 325 }
 326
 327 void CommonCommand_ladder(float request, entity caller)
 328 {
 329         switch(request)
 330         {
 331                 case CMD_REQUEST_COMMAND:
 332                 {
 333                         print_to(caller, ladder_reply);
 334                         return; // never fall through to usage
 335                 }
 336
 337                 default:
 338                 case CMD_REQUEST_USAGE:
 339                 {
 340                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " ladder"));
 341                         print_to(caller, "  No arguments required.");
 342                         return;
 343                 }
 344         }
 345 }
 346
 347 void CommonCommand_lsmaps(float request, entity caller)
 348 {
 349         switch(request)
 350         {
 351                 case CMD_REQUEST_COMMAND:
 352                 {
 353                         print_to(caller, lsmaps_reply);
 354                         return; // never fall through to usage
 355                 }
 356
 357                 default:
 358                 case CMD_REQUEST_USAGE:
 359                 {
 360                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " lsmaps"));
 361                         print_to(caller, "  No arguments required.");
 362                         return;
 363                 }
 364         }
 365 }
 366
 367 void CommonCommand_lsnewmaps(float request, entity caller)
 368 {
 369         switch(request)
 370         {
 371                 case CMD_REQUEST_COMMAND:
 372                 {
 373                         print_to(caller, lsnewmaps_reply);
 374                         return; // never fall through to usage
 375                 }
 376
 377                 default:
 378                 case CMD_REQUEST_USAGE:
 379                 {
 380                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " lsnewmaps"));
 381                         print_to(caller, "  No arguments required.");
 382                         return;
 383                 }
 384         }
 385 }
 386
 387 void CommonCommand_printmaplist(float request, entity caller)
 388 {
 389         switch(request)
 390         {
 391                 case CMD_REQUEST_COMMAND:
 392                 {
 393                         print_to(caller, maplist_reply);
 394                         return; // never fall through to usage
 395                 }
 396
 397                 default:
 398                 case CMD_REQUEST_USAGE:
 399                 {
 400                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " printmaplist"));
 401                         print_to(caller, "  No arguments required.");
 402                         return;
 403                 }
 404         }
 405 }
 406
 407 /*
 408 void GameCommand_rankings(float request) // this is OLD.... jeez.
 409 {
 410         switch(request)
 411         {
 412                 case CMD_REQUEST_COMMAND:
 413                 {
 414                         strunzone(rankings_reply);
 415                         rankings_reply = strzone(getrankings());
 416                         print(rankings_reply);
 417                         return;
 418                 }
 419
 420                 default:
 421                 case CMD_REQUEST_USAGE:
 422                 {
 423                         print("\nUsage:^3 sv_cmd rankings");
 424                         print("  No arguments required.");
 425                         return;
 426                 }
 427         }
 428 }
 429 */
 430
 431 void CommonCommand_rankings(float request, entity caller)
 432 {
 433         switch(request)
 434         {
 435                 case CMD_REQUEST_COMMAND:
 436                 {
 437                         print_to(caller, rankings_reply);
 438                         return; // never fall through to usage
 439                 }
 440
 441                 default:
 442                 case CMD_REQUEST_USAGE:
 443                 {
 444                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " rankings"));
 445                         print_to(caller, "  No arguments required.");
 446                         return;
 447                 }
 448         }
 449 }
 450
 451 void CommonCommand_records(float request, entity caller)
 452 {
 453         switch(request)
 454         {
 455                 case CMD_REQUEST_COMMAND:
 456                 {
 457                         float i;
 458
 459                         for(i = 0; i < 10; ++i)
 460                                 print_to(caller, records_reply[i]);
 461
 462                         return; // never fall through to usage
 463                 }
 464
 465                 default:
 466                 case CMD_REQUEST_USAGE:
 467                 {
 468                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " records"));
 469                         print_to(caller, "  No arguments required.");
 470                         return;
 471                 }
 472         }
 473 }
 474
 475 void CommonCommand_teamstatus(float request, entity caller)
 476 {
 477         switch(request)
 478         {
 479                 case CMD_REQUEST_COMMAND:
 480                 {
 481                         Score_NicePrint(caller);
 482                         return; // never fall through to usage
 483                 }
 484
 485                 default:
 486                 case CMD_REQUEST_USAGE:
 487                 {
 488                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " teamstatus"));
 489                         print_to(caller, "  No arguments required.");
 490                         return;
 491                 }
 492         }
 493 }
 494
 495 void CommonCommand_time(float request, entity caller)
 496 {
 497         switch(request)
 498         {
 499                 case CMD_REQUEST_COMMAND:
 500                 {
 501                         print_to(caller, strcat("time = ", ftos(time)));
 502                         print_to(caller, strcat("frame start = ", ftos(gettime(GETTIME_FRAMESTART))));
 503                         print_to(caller, strcat("realtime = ", ftos(gettime(GETTIME_REALTIME))));
 504                         print_to(caller, strcat("hires = ", ftos(gettime(GETTIME_HIRES))));
 505                         print_to(caller, strcat("uptime = ", ftos(gettime(GETTIME_UPTIME))));
 506                         print_to(caller, strcat("localtime = ", strftime(TRUE, "%a %b %e %H:%M:%S %Z %Y")));
 507                         print_to(caller, strcat("gmtime = ", strftime(FALSE, "%a %b %e %H:%M:%S %Z %Y")));
 508                         return;
 509                 }
 510
 511                 default:
 512                 case CMD_REQUEST_USAGE:
 513                 {
 514                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " time"));
 515                         print_to(caller, "  No arguments required.");
 516                         return;
 517                 }
 518         }
 519 }
 520
 521 void CommonCommand_timein(float request, entity caller)
 522 {
 523         switch(request)
 524         {
 525                 case CMD_REQUEST_COMMAND:
 526                 {
 527                         if(!caller || autocvar_sv_timeout)
 528                         {
 529                                 if not(timeout_status) { print_to(caller, "^7Error: There is no active timeout called."); }
 530                                 else if(caller && (caller != timeout_caller)) { print_to(caller, "^7Error: You are not allowed to stop the active timeout."); }
 531
 532                                 else // everything should be okay, continue aborting timeout
 533                                 {
 534                                         switch(timeout_status)
 535                                         {
 536                                                 case TIMEOUT_LEADTIME:
 537                                                 {
 538                                                         timeout_status = TIMEOUT_INACTIVE;
 539                                                         timeout_time = 0;
 540                                                         timeout_handler.nextthink = time; // timeout_handler has to take care of it immediately
 541                                                         bprint(strcat("^7The timeout was aborted by ", GetCallerName(caller), " !\n"));
 542                                                         return;
 543                                                 }
 544
 545                                                 case TIMEOUT_ACTIVE:
 546                                                 {
 547                                                         timeout_time = autocvar_sv_timeout_resumetime;
 548                                                         timeout_handler.nextthink = time; // timeout_handler has to take care of it immediately
 549                                                         bprint(strcat("^1Attention: ^7", GetCallerName(caller), " resumed the game! Prepare for battle!\n"));
 550                                                         return;
 551                                                 }
 552
 553                                                 default: dprint("timeout status was inactive, but this code was executed anyway?"); return;
 554                                         }
 555                                 }
 556                         }
 557                         else { print_to(caller, "^1Timeins are not allowed to be called, enable them with sv_timeout 1.\n"); }
 558
 559                         return; // never fall through to usage
 560                 }
 561
 562                 default:
 563                 case CMD_REQUEST_USAGE:
 564                 {
 565                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timein"));
 566                         print_to(caller, "  No arguments required.");
 567                         return;
 568                 }
 569         }
 570 }
 571
 572 void CommonCommand_timeout(float request, entity caller) // DEAR GOD THIS COMMAND IS TERRIBLE.
 573 {
 574         switch(request)
 575         {
 576                 case CMD_REQUEST_COMMAND:
 577                 {
 578                         if(!caller || autocvar_sv_timeout)
 579                         {
 580                                 float last_possible_timeout = ((autocvar_timelimit * 60) - autocvar_sv_timeout_leadtime - 1);
 581
 582                                 if(timeout_status) { print_to(caller, "^7Error: A timeout is already active."); }
 583                                 else if(vote_called) { print_to(caller, "^7Error: You can not call a timeout while a vote is active."); }
 584                                 else if(inWarmupStage && !g_warmup_allow_timeout) { print_to(caller, "^7Error: You can not call a timeout in warmup-stage."); }
 585                                 else if(time < game_starttime) { print_to(caller, "^7Error: You can not call a timeout while the map is being restarted."); }
 586                                 else if(caller && (caller.allowed_timeouts < 1)) { print_to(caller, "^7Error: You already used all your timeout calls for this map."); }
 587                                 else if(caller && (caller.classname != "player")) { print_to(caller, "^7Error: You must be a player to call a timeout."); }
 588                                 else if((autocvar_timelimit) && (last_possible_timeout < time - game_starttime)) { print_to(caller, "^7Error: It is too late to call a timeout now!"); }
 589
 590                                 else // everything should be okay, proceed with starting the timeout
 591                                 {
 592                                         if(caller) { caller.allowed_timeouts -= 1; }
 593
 594                                         bprint(GetCallerName(caller), " ^7called a timeout", (caller ? strcat(" (", ftos(caller.allowed_timeouts), " timeout(s) left)") : string_null), "!\n"); // write a bprint who started the timeout (and how many they have left)
 595
 596                                         timeout_status = TIMEOUT_LEADTIME;
 597                                         timeout_caller = caller;
 598                                         timeout_time = autocvar_sv_timeout_length;
 599                                         timeout_leadtime = autocvar_sv_timeout_leadtime;
 600
 601                                         timeout_handler = spawn();
 602                                         timeout_handler.think = timeout_handler_think;
 603                                         timeout_handler.nextthink = time; // always let the entity think asap
 604
 605                                         Announce("timeoutcalled");
 606                                 }
 607                         }
 608                         else { print_to(caller, "^1Timeouts are not allowed to be called, enable them with sv_timeout 1.\n"); }
 609
 610                         return; // never fall through to usage
 611                 }
 612
 613                 default:
 614                 case CMD_REQUEST_USAGE:
 615                 {
 616                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timeout"));
 617                         print_to(caller, "  No arguments required.");
 618                         return;
 619                 }
 620         }
 621 }
 622
 623 void CommonCommand_who(float request, entity caller, float argc)
 624 {
 625         switch(request)
 626         {
 627                 case CMD_REQUEST_COMMAND:
 628                 {
 629                         float total_listed_players, tmp_hours, tmp_minutes, tmp_seconds, is_bot;
 630                         entity tmp_player;
 631
 632                         float privacy = (caller && autocvar_sv_status_privacy);
 633                         string separator = strreplace("%", " ", strcat((argv(1) ? argv(1) : " "), "^7"));
 634                         string tmp_netaddress, tmp_crypto_idfp;
 635
 636                         print_to(caller, strcat("List of client information", (privacy ? " (some data is hidden for privacy)" : string_null), ":"));
 637                         print_to(caller, sprintf(strreplace(" ", separator, " %-4s %-20s %-5s %-3s %-9s %-16s %s "),
 638                                 "ent", "nickname", "ping", "pl", "time", "ip", "crypto_id"));
 639
 640                         FOR_EACH_CLIENT(tmp_player)
 641                         {
 642                                 is_bot = (clienttype(tmp_player) == CLIENTTYPE_BOT);
 643
 644                                 if(is_bot)
 645                                 {
 646                                         tmp_netaddress = "null/botclient";
 647                                         tmp_crypto_idfp = "null/botclient";
 648                                 }
 649                                 else if(privacy)
 650                                 {
 651                                         tmp_netaddress = "hidden";
 652                                         tmp_crypto_idfp = "hidden";
 653                                 }
 654                                 else
 655                                 {
 656                                         tmp_netaddress = tmp_player.netaddress;
 657                                         tmp_crypto_idfp = tmp_player.crypto_idfp;
 658                                 }
 659
 660                                 tmp_hours = tmp_minutes = tmp_seconds = 0;
 661
 662                                 tmp_seconds = floor(time - tmp_player.jointime);
 663                                 tmp_minutes = floor(tmp_seconds / 60);
 664                                 tmp_hours = floor(tmp_minutes / 60);
 665
 666                                 if(tmp_minutes) { tmp_seconds -= (tmp_minutes * 60); }
 667                                 if(tmp_hours) { tmp_minutes -= (tmp_hours * 60); }
 668
 669                                 print_to(caller, sprintf(strreplace(" ", separator, " #%-3d %-20.20s %-5d %-3d %-9s %-16s %s "),
 670                                         num_for_edict(tmp_player),
 671                                         tmp_player.netname,
 672                                         tmp_player.ping,
 673                                         tmp_player.ping_packetloss,
 674                                         sprintf("%02d:%02d:%02d", tmp_hours, tmp_minutes, tmp_seconds),
 675                                         tmp_netaddress,
 676                                         tmp_crypto_idfp));
 677
 678                                 ++total_listed_players;
 679                         }
 680
 681                         print_to(caller, strcat("Finished listing ", ftos(total_listed_players), " client(s) out of ", ftos(maxclients), " slots."));
 682
 683                         return; // never fall through to usage
 684                 }
 685
 686                 default:
 687                 case CMD_REQUEST_USAGE:
 688                 {
 689                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " who [separator]"));
 690                         print_to(caller, "  Where 'separator' is the optional string to separate the values with, default is a space.");
 691                         return;
 692                 }
 693         }
 694 }
 695
 696 /* use this when creating a new command, making sure to place it in alphabetical order... also,
 697 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
 698 void CommonCommand_(float request, entity caller)
 699 {
 700         switch(request)
 701         {
 702                 case CMD_REQUEST_COMMAND:
 703                 {
 704
 705                         return; // never fall through to usage
 706                 }
 707
 708                 default:
 709                 case CMD_REQUEST_USAGE:
 710                 {
 711                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " "));
 712                         print_to(caller, "  No arguments required.");
 713                         return;
 714                 }
 715         }
 716 }
 717 */
 718
 719
 720 // ==================================
 721 //  Macro system for common commands
 722 // ==================================
 723
 724 // Do not hard code aliases for these, instead create them in commands.cfg... also: keep in alphabetical order, please ;)
 725 #define COMMON_COMMANDS(request,caller,arguments,command) \
 726         COMMON_COMMAND("cvar_changes", CommonCommand_cvar_changes(request, caller), "Prints a list of all changed server cvars") \
 727         COMMON_COMMAND("cvar_purechanges", CommonCommand_cvar_purechanges(request, caller), "Prints a list of all changed gameplay cvars") \
 728         COMMON_COMMAND("info", CommonCommand_info(request, caller, arguments), "Request for unique server information set up by admin") \
 729         COMMON_COMMAND("ladder", CommonCommand_ladder(request, caller), "Get information about top players if supported") \
 730         COMMON_COMMAND("lsmaps", CommonCommand_lsmaps(request, caller), "List maps which can be used with the current game mode") \
 731         COMMON_COMMAND("lsnewmaps", CommonCommand_lsnewmaps(request, caller), "List maps which have no records or are seemingly unplayed yet") \
 732         COMMON_COMMAND("printmaplist", CommonCommand_printmaplist(request, caller), "Display full server maplist reply") \
 733         COMMON_COMMAND("rankings", CommonCommand_rankings(request, caller), "Print information about rankings") \
 734         COMMON_COMMAND("records", CommonCommand_records(request, caller), "List top 10 records for the current map") \
 735         COMMON_COMMAND("teamstatus", CommonCommand_teamstatus(request, caller), "Show information about player and team scores") \
 736         COMMON_COMMAND("time", CommonCommand_time(request, caller), "Print different formats/readouts of time") \
 737         COMMON_COMMAND("timein", CommonCommand_timein(request, caller), "Resume the game from being paused with a timeout") \
 738         COMMON_COMMAND("timeout", CommonCommand_timeout(request, caller), "Call a timeout which pauses the game for certain amount of time unless unpaused") \
 739         COMMON_COMMAND("vote", VoteCommand(request, caller, arguments, command), "Request an action to be voted upon by players") \
 740         COMMON_COMMAND("who", CommonCommand_who(request, caller, arguments), "Display detailed client information about all players") \
 741         /* nothing */
 742
 743 void CommonCommand_macro_help(entity caller)
 744 {
 745         #define COMMON_COMMAND(name,function,description) \
 746                 { print_to(caller, strcat("  ^2", name, "^7: ", description)); }
 747
 748         COMMON_COMMANDS(0, caller, 0, "")
 749         #undef COMMON_COMMAND
 750
 751         return;
 752 }
 753
 754 float CommonCommand_macro_command(float argc, entity caller, string command)
 755 {
 756         #define COMMON_COMMAND(name,function,description) \
 757                 { if(name == strtolower(argv(0))) { function; return TRUE; } }
 758
 759         COMMON_COMMANDS(CMD_REQUEST_COMMAND, caller, argc, command)
 760         #undef COMMON_COMMAND
 761
 762         return FALSE;
 763 }
 764
 765 float CommonCommand_macro_usage(float argc, entity caller)
 766 {
 767         #define COMMON_COMMAND(name,function,description) \
 768                 { if(name == strtolower(argv(1))) { function; return TRUE; } }
 769
 770         COMMON_COMMANDS(CMD_REQUEST_USAGE, caller, argc, "")
 771         #undef COMMON_COMMAND
 772
 773         return FALSE;
 774 }
 775
 776 void CommonCommand_macro_write_aliases(float fh)
 777 {
 778         #define COMMON_COMMAND(name,function,description) \
 779                 { CMD_Write_Alias("qc_cmd_svcmd", name, description); }
 780
 781         COMMON_COMMANDS(0, world, 0, "")
 782         #undef COMMON_COMMAND
 783
 784         return;
 785 }