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