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