qcsrc/server/command/common.qc

   1 #include "../../common/command/command.qh"
   2 #include "common.qh"
   3
   4 #include "../scores.qh"
   5
   6 #include "../../common/monsters/all.qh"
   7 #include "../../common/notifications.qh"
   8 #include "../../lib/warpzone/common.qh"
   9
  10
  11 // ====================================================
  12 //  Shared code for server commands, written by Samual
  13 //  Last updated: December 27th, 2011
  14 // ====================================================
  15
  16 // select the proper prefix for usage and other messages
  17 string GetCommandPrefix(entity caller)
  18 {
  19         if (caller) return "cmd";
  20         else return "sv_cmd";
  21 }
  22
  23 // if client return player nickname, or if server return admin nickname
  24 string GetCallerName(entity caller)
  25 {
  26         if (caller) return caller.netname;
  27         else return admin_name();  // ((autocvar_sv_adminnick != "") ? autocvar_sv_adminnick : autocvar_hostname);
  28 }
  29
  30 // verify that the client provided is acceptable for kicking
  31 float VerifyKickableEntity(entity client)
  32 {
  33         if (!IS_REAL_CLIENT(client)) return CLIENT_NOT_REAL;
  34         return CLIENT_ACCEPTABLE;
  35 }
  36
  37 // verify that the client provided is acceptable for use
  38 float VerifyClientEntity(entity client, float must_be_real, float must_be_bots)
  39 {
  40         if (!IS_CLIENT(client)) return CLIENT_DOESNT_EXIST;
  41         else if (must_be_real && !IS_REAL_CLIENT(client)) return CLIENT_NOT_REAL;
  42         else if (must_be_bots && !IS_BOT_CLIENT(client)) return CLIENT_NOT_BOT;
  43
  44         return CLIENT_ACCEPTABLE;
  45 }
  46
  47 // if the client is not acceptable, return a string to be used for error messages
  48 string GetClientErrorString_color(float clienterror, string original_input, string col)
  49 {
  50         switch (clienterror)
  51         {
  52                 case CLIENT_DOESNT_EXIST:
  53                 { return strcat(col, "Client '", original_input, col, "' doesn't exist");
  54                 }
  55                 case CLIENT_NOT_REAL:
  56                 { return strcat(col, "Client '", original_input, col, "' is not real");
  57                 }
  58                 case CLIENT_NOT_BOT:
  59                 { return strcat(col, "Client '", original_input, col, "' is not a bot");
  60                 }
  61                 default:
  62                 { return "Incorrect usage of GetClientErrorString";
  63                 }
  64         }
  65 }
  66
  67 // is this entity number even in the possible range of entities?
  68 float VerifyClientNumber(float tmp_number)
  69 {
  70         if ((tmp_number < 1) || (tmp_number > maxclients)) return false;
  71         else return true;
  72 }
  73
  74 entity GetIndexedEntity(float argc, float start_index)
  75 {
  76         entity tmp_player, selection;
  77         float tmp_number, index;
  78         string tmp_string;
  79
  80         next_token = -1;
  81         index = start_index;
  82         selection = world;
  83
  84         if (argc > start_index)
  85         {
  86                 if (substring(argv(index), 0, 1) == "#")
  87                 {
  88                         tmp_string = substring(argv(index), 1, -1);
  89                         ++index;
  90
  91                         if (tmp_string != "")  // is it all one token? like #1
  92                         {
  93                                 tmp_number = stof(tmp_string);
  94                         }
  95                         else if (argc > index)  // no, it's two tokens? # 1
  96                         {
  97                                 tmp_number = stof(argv(index));
  98                                 ++index;
  99                         }
 100                         else
 101                         {
 102                                 tmp_number = 0;
 103                         }
 104                 }
 105                 else  // maybe it's ONLY a number?
 106                 {
 107                         tmp_number = stof(argv(index));
 108                         ++index;
 109                 }
 110
 111                 if (VerifyClientNumber(tmp_number))
 112                 {
 113                         selection = edict_num(tmp_number);  // yes, it was a number
 114                 }
 115                 else  // no, maybe it's a name?
 116                 {
 117                         FOR_EACH_CLIENT(tmp_player)
 118                         if (strdecolorize(tmp_player.netname) == strdecolorize(argv(start_index))) selection = tmp_player;
 119
 120                         index = (start_index + 1);
 121                 }
 122         }
 123
 124         next_token = index;
 125         // print(strcat("start_index: ", ftos(start_index), ", next_token: ", ftos(next_token), ", edict: ", ftos(num_for_edict(selection)), ".\n"));
 126         return selection;
 127 }
 128
 129 // find a player which matches the input string, and return their entity
 130 entity GetFilteredEntity(string input)
 131 {
 132         entity tmp_player, selection;
 133         float tmp_number;
 134
 135         if (substring(input, 0, 1) == "#") tmp_number = stof(substring(input, 1, -1));
 136         else tmp_number = stof(input);
 137
 138         if (VerifyClientNumber(tmp_number))
 139         {
 140                 selection = edict_num(tmp_number);
 141         }
 142         else
 143         {
 144                 selection = world;
 145                 FOR_EACH_CLIENT(tmp_player)
 146                 if (strdecolorize(tmp_player.netname) == strdecolorize(input)) selection = tmp_player;
 147         }
 148
 149         return selection;
 150 }
 151
 152 // same thing, but instead return their edict number
 153 float GetFilteredNumber(string input)
 154 {
 155         entity selection = GetFilteredEntity(input);
 156         float output;
 157
 158         output = etof(selection);
 159
 160         return output;
 161 }
 162
 163 // switch between sprint and print depending on whether the receiver is the server or a player
 164 void print_to(entity to, string input)
 165 {
 166         if (to) sprint(to, strcat(input, "\n"));
 167         else LOG_INFO(input, "\n");
 168 }
 169
 170 // ==========================================
 171 //  Supporting functions for common commands
 172 // ==========================================
 173
 174 // used by CommonCommand_timeout() and CommonCommand_timein() to handle game pausing and messaging and such.
 175 void timeout_handler_reset()
 176 {
 177         SELFPARAM();
 178         timeout_caller = world;
 179         timeout_time = 0;
 180         timeout_leadtime = 0;
 181
 182         remove(self);
 183 }
 184
 185 void timeout_handler_think()
 186 {
 187         SELFPARAM();
 188         entity tmp_player;
 189
 190         switch (timeout_status)
 191         {
 192                 case TIMEOUT_ACTIVE:
 193                 {
 194                         if (timeout_time > 0)  // countdown is still going
 195                         {
 196                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TIMEOUT_ENDING, timeout_time);
 197
 198                                 if (timeout_time == autocvar_sv_timeout_resumetime) // play a warning sound when only <sv_timeout_resumetime> seconds are left
 199                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_PREPARE);
 200
 201                                 self.nextthink = time + TIMEOUT_SLOWMO_VALUE;       // think again in one second
 202                                 timeout_time -= 1;                                  // decrease the time counter
 203                         }
 204                         else  // time to end the timeout
 205                         {
 206                                 timeout_status = TIMEOUT_INACTIVE;
 207
 208                                 // reset the slowmo value back to normal
 209                                 cvar_set("slowmo", ftos(orig_slowmo));
 210
 211                                 // unlock the view for players so they can move around again
 212                                 FOR_EACH_REALPLAYER(tmp_player)
 213                                 tmp_player.fixangle = false;
 214
 215                                 timeout_handler_reset();
 216                         }
 217
 218                         return;
 219                 }
 220
 221                 case TIMEOUT_LEADTIME:
 222                 {
 223                         if (timeout_leadtime > 0)  // countdown is still going
 224                         {
 225                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TIMEOUT_BEGINNING, timeout_leadtime);
 226
 227                                 self.nextthink = time + 1; // think again in one second
 228                                 timeout_leadtime -= 1;     // decrease the time counter
 229                         }
 230                         else  // time to begin the timeout
 231                         {
 232                                 timeout_status = TIMEOUT_ACTIVE;
 233
 234                                 // set the slowmo value to the timeout default slowmo value
 235                                 cvar_set("slowmo", ftos(TIMEOUT_SLOWMO_VALUE));
 236
 237                                 // reset all the flood variables
 238                                 FOR_EACH_CLIENT(tmp_player)
 239                                 tmp_player.nickspamcount = tmp_player.nickspamtime = tmp_player.floodcontrol_chat =
 240                                             tmp_player.floodcontrol_chatteam = tmp_player.floodcontrol_chattell =
 241                                                     tmp_player.floodcontrol_voice = tmp_player.floodcontrol_voiceteam = 0;
 242
 243                                 // copy .v_angle to .lastV_angle for every player in order to fix their view during pause (see PlayerPreThink)
 244                                 FOR_EACH_REALPLAYER(tmp_player)
 245                                 tmp_player.lastV_angle = tmp_player.v_angle;
 246
 247                                 self.nextthink = time;  // think again next frame to handle it under TIMEOUT_ACTIVE code
 248                         }
 249
 250                         return;
 251                 }
 252
 253
 254                 case TIMEOUT_INACTIVE:
 255                 default:
 256                 {
 257                         timeout_handler_reset();
 258                         return;
 259                 }
 260         }
 261 }
 262
 263
 264 // ===================================================
 265 //  Common commands used in both sv_cmd.qc and cmd.qc
 266 // ===================================================
 267
 268 void CommonCommand_cvar_changes(float request, entity caller)
 269 {
 270         switch (request)
 271         {
 272                 case CMD_REQUEST_COMMAND:
 273                 {
 274                         print_to(caller, cvar_changes);
 275                         return;  // never fall through to usage
 276                 }
 277
 278                 default:
 279                 case CMD_REQUEST_USAGE:
 280                 {
 281                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_changes"));
 282                         print_to(caller, "  No arguments required.");
 283                         print_to(caller, "See also: ^2cvar_purechanges^7");
 284                         return;
 285                 }
 286         }
 287 }
 288
 289 void CommonCommand_cvar_purechanges(float request, entity caller)
 290 {
 291         switch (request)
 292         {
 293                 case CMD_REQUEST_COMMAND:
 294                 {
 295                         print_to(caller, cvar_purechanges);
 296                         return;  // never fall through to usage
 297                 }
 298
 299                 default:
 300                 case CMD_REQUEST_USAGE:
 301                 {
 302                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_purechanges"));
 303                         print_to(caller, "  No arguments required.");
 304                         print_to(caller, "See also: ^2cvar_changes^7");
 305                         return;
 306                 }
 307         }
 308 }
 309
 310 void CommonCommand_editmob(int request, entity caller, int argc)
 311 {
 312         SELFPARAM();
 313         switch (request)
 314         {
 315                 case CMD_REQUEST_COMMAND:
 316                 {
 317                         if (autocvar_g_campaign) { print_to(caller, "Monster editing is disabled in singleplayer"); return; }
 318                         // no checks for g_monsters here, as it may be toggled mid match which existing monsters
 319
 320                         if (caller)
 321                         {
 322                                 makevectors(self.v_angle);
 323                                 WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 100, MOVE_NORMAL, self);
 324                         }
 325
 326                         entity mon = trace_ent;
 327                         bool is_visible = IS_MONSTER(mon);
 328                         string argument = argv(2);
 329
 330                         switch (argv(1))
 331                         {
 332                                 case "name":
 333                                 {
 334                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
 335                                         if (!argument)   break;  // escape to usage
 336                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
 337                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
 338                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
 339
 340                                         string mon_oldname = mon.monster_name;
 341
 342                                         mon.monster_name = argument;
 343                                         if (mon.sprite)   WaypointSprite_UpdateSprites(mon.sprite, WP_Monster, WP_Null, WP_Null);
 344                                         print_to(caller, sprintf("Your pet '%s' is now known as '%s'", mon_oldname, mon.monster_name));
 345                                         return;
 346                                 }
 347                                 case "spawn":
 348                                 {
 349                                         if (!caller) { print_to(caller, "Only players can spawn monsters"); return; }
 350                                         if (!argv(2))   break;  // escape to usage
 351
 352                                         int moveflag, tmp_moncount = 0;
 353                                         string arg_lower = strtolower(argument);
 354                                         moveflag = (argv(3)) ? stof(argv(3)) : 1;  // follow owner if not defined
 355                                         ret_string = "Monster spawning is currently disabled by a mutator";
 356
 357                                         if (arg_lower == "list") { print_to(caller, monsterlist_reply); return; }
 358
 359                                         FOR_EACH_MONSTER(mon)
 360                                         {
 361                                                 if (mon.realowner == caller) ++tmp_moncount;
 362                                         }
 363
 364                                         if (!autocvar_g_monsters) { print_to(caller, "Monsters are disabled"); return; }
 365                                         if (autocvar_g_monsters_max <= 0 || autocvar_g_monsters_max_perplayer <= 0) { print_to(caller, "Monster spawning is disabled"); return; }
 366                                         if (!IS_PLAYER(caller)) { print_to(caller, "You must be playing to spawn a monster"); return; }
 367                                         if (MUTATOR_CALLHOOK(AllowMobSpawning)) { print_to(caller, ret_string); return; }
 368                                         if (caller.vehicle) { print_to(caller, "You can't spawn monsters while driving a vehicle"); return; }
 369                                         if (caller.frozen) { print_to(caller, "You can't spawn monsters while frozen"); return; }
 370                                         if (caller.deadflag != DEAD_NO) { print_to(caller, "You can't spawn monsters while dead"); return; }
 371                                         if (tmp_moncount >= autocvar_g_monsters_max) { print_to(caller, "The maximum monster count has been reached"); return; }
 372                                         if (tmp_moncount >= autocvar_g_monsters_max_perplayer) { print_to(caller, "You can't spawn any more monsters"); return; }
 373
 374                                         bool found = false;
 375                                         for (int i = MON_FIRST; i <= MON_LAST; ++i)
 376                                         {
 377                                                 mon = get_monsterinfo(i);
 378                                                 if (mon.netname == arg_lower) { found = true; break; }
 379                                         }
 380
 381                                         if (!found && arg_lower != "random") { print_to(caller, "Invalid monster"); return; }
 382
 383                                         totalspawned += 1;
 384                                         WarpZone_TraceBox(CENTER_OR_VIEWOFS(caller), caller.mins, caller.maxs, CENTER_OR_VIEWOFS(caller) + v_forward * 150, true, caller);
 385                                         mon = spawnmonster(arg_lower, 0, caller, caller, trace_endpos, false, false, moveflag);
 386                                         print_to(caller, strcat("Spawned ", mon.monster_name));
 387                                         return;
 388                                 }
 389                                 case "kill":
 390                                 {
 391                                         if (!caller) { print_to(caller, "Only players can kill monsters"); return; }
 392                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
 393                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
 394
 395                                         Damage(mon, world, world, mon.health + mon.max_health + 200, DEATH_KILL.m_id, mon.origin, '0 0 0');
 396                                         print_to(caller, strcat("Your pet '", mon.monster_name, "' has been brutally mutilated"));
 397                                         return;
 398                                 }
 399                                 case "skin":
 400                                 {
 401                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
 402                                         if (!argument)   break;  // escape to usage
 403                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
 404                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
 405                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
 406                                         if (mon.monsterid == MON_MAGE.monsterid) { print_to(caller, "Mage skins can't be changed"); return; }  // TODO
 407
 408                                         mon.skin = stof(argument);
 409                                         print_to(caller, strcat("Monster skin successfully changed to ", ftos(mon.skin)));
 410                                         return;
 411                                 }
 412                                 case "movetarget":
 413                                 {
 414                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
 415                                         if (!argument)   break;  // escape to usage
 416                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
 417                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
 418                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
 419
 420                                         mon.monster_moveflags = stof(argument);
 421                                         print_to(caller, strcat("Monster move target successfully changed to ", ftos(mon.monster_moveflags)));
 422                                         return;
 423                                 }
 424                                 case "butcher":
 425                                 {
 426                                         if (caller) { print_to(caller, "This command is not available to players"); return; }
 427                                         if (MUTATOR_CALLHOOK(AllowMobButcher)) { LOG_INFO(ret_string, "\n"); return; }
 428
 429                                         int tmp_remcount = 0;
 430                                         entity tmp_entity;
 431
 432                                         FOR_EACH_MONSTER(tmp_entity)
 433                                         {
 434                                                 Monster_Remove(tmp_entity);
 435                                                 ++tmp_remcount;
 436                                         }
 437
 438                                         monsters_total = monsters_killed = totalspawned = 0;
 439
 440                                         print_to(caller, (tmp_remcount) ? sprintf("Killed %d monster%s", tmp_remcount, (tmp_remcount == 1) ? "" : "s") : "No monsters to kill");
 441                                         return;
 442                                 }
 443                         }
 444                 }
 445
 446                 default:
 447                 case CMD_REQUEST_USAGE:
 448                 {
 449                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " editmob command [arguments]"));
 450                         print_to(caller, "  Where 'command' can be butcher spawn skin movetarget kill name");
 451                         print_to(caller, "  spawn, skin, movetarget and name require 'arguments'");
 452                         print_to(caller, "  spawn also takes arguments list and random");
 453                         print_to(caller, "  Monster will follow owner if third argument of spawn command is not defined");
 454                         return;
 455                 }
 456         }
 457 }
 458
 459 void CommonCommand_info(float request, entity caller, float argc)
 460 {
 461         switch (request)
 462         {
 463                 case CMD_REQUEST_COMMAND:
 464                 {
 465                         string command = builtin_cvar_string(strcat("sv_info_", argv(1)));
 466
 467                         if (command) wordwrap_sprint(command, 1000);
 468                         else print_to(caller, "ERROR: unsupported info command");
 469
 470                         return;  // never fall through to usage
 471                 }
 472
 473                 default:
 474                 case CMD_REQUEST_USAGE:
 475                 {
 476                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " info request"));
 477                         print_to(caller, "  Where 'request' is the suffixed string appended onto the request for cvar.");
 478                         return;
 479                 }
 480         }
 481 }
 482
 483 void CommonCommand_ladder(float request, entity caller)
 484 {
 485         switch (request)
 486         {
 487                 case CMD_REQUEST_COMMAND:
 488                 {
 489                         print_to(caller, ladder_reply);
 490                         return;  // never fall through to usage
 491                 }
 492
 493                 default:
 494                 case CMD_REQUEST_USAGE:
 495                 {
 496                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " ladder"));
 497                         print_to(caller, "  No arguments required.");
 498                         return;
 499                 }
 500         }
 501 }
 502
 503 void CommonCommand_lsmaps(float request, entity caller)
 504 {
 505         switch (request)
 506         {
 507                 case CMD_REQUEST_COMMAND:
 508                 {
 509                         print_to(caller, lsmaps_reply);
 510                         return;  // never fall through to usage
 511                 }
 512
 513                 default:
 514                 case CMD_REQUEST_USAGE:
 515                 {
 516                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " lsmaps"));
 517                         print_to(caller, "  No arguments required.");
 518                         return;
 519                 }
 520         }
 521 }
 522
 523 void CommonCommand_printmaplist(float request, entity caller)
 524 {
 525         switch (request)
 526         {
 527                 case CMD_REQUEST_COMMAND:
 528                 {
 529                         print_to(caller, maplist_reply);
 530                         return;  // never fall through to usage
 531                 }
 532
 533                 default:
 534                 case CMD_REQUEST_USAGE:
 535                 {
 536                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " printmaplist"));
 537                         print_to(caller, "  No arguments required.");
 538                         return;
 539                 }
 540         }
 541 }
 542
 543 void CommonCommand_rankings(float request, entity caller)
 544 {
 545         switch (request)
 546         {
 547                 case CMD_REQUEST_COMMAND:
 548                 {
 549                         print_to(caller, rankings_reply);
 550                         return;  // never fall through to usage
 551                 }
 552
 553                 default:
 554                 case CMD_REQUEST_USAGE:
 555                 {
 556                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " rankings"));
 557                         print_to(caller, "  No arguments required.");
 558                         return;
 559                 }
 560         }
 561 }
 562
 563 void CommonCommand_records(float request, entity caller)
 564 {
 565         switch (request)
 566         {
 567                 case CMD_REQUEST_COMMAND:
 568                 {
 569                         for (int i = 0; i < 10; ++i)
 570                                 if (records_reply[i] != "") print_to(caller, records_reply[i]);
 571
 572                         return;  // never fall through to usage
 573                 }
 574
 575                 default:
 576                 case CMD_REQUEST_USAGE:
 577                 {
 578                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " records"));
 579                         print_to(caller, "  No arguments required.");
 580                         return;
 581                 }
 582         }
 583 }
 584
 585 void CommonCommand_teamstatus(float request, entity caller)
 586 {
 587         switch (request)
 588         {
 589                 case CMD_REQUEST_COMMAND:
 590                 {
 591                         Score_NicePrint(caller);
 592                         return;  // never fall through to usage
 593                 }
 594
 595                 default:
 596                 case CMD_REQUEST_USAGE:
 597                 {
 598                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " teamstatus"));
 599                         print_to(caller, "  No arguments required.");
 600                         return;
 601                 }
 602         }
 603 }
 604
 605 void CommonCommand_time(float request, entity caller)
 606 {
 607         switch (request)
 608         {
 609                 case CMD_REQUEST_COMMAND:
 610                 {
 611                         print_to(caller, strcat("time = ", ftos(time)));
 612                         print_to(caller, strcat("frame start = ", ftos(gettime(GETTIME_FRAMESTART))));
 613                         print_to(caller, strcat("realtime = ", ftos(gettime(GETTIME_REALTIME))));
 614                         print_to(caller, strcat("hires = ", ftos(gettime(GETTIME_HIRES))));
 615                         print_to(caller, strcat("uptime = ", ftos(gettime(GETTIME_UPTIME))));
 616                         print_to(caller, strcat("localtime = ", strftime(true, "%a %b %e %H:%M:%S %Z %Y")));
 617                         print_to(caller, strcat("gmtime = ", strftime(false, "%a %b %e %H:%M:%S %Z %Y")));
 618                         return;
 619                 }
 620
 621                 default:
 622                 case CMD_REQUEST_USAGE:
 623                 {
 624                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " time"));
 625                         print_to(caller, "  No arguments required.");
 626                         return;
 627                 }
 628         }
 629 }
 630
 631 void CommonCommand_timein(float request, entity caller)
 632 {
 633         switch (request)
 634         {
 635                 case CMD_REQUEST_COMMAND:
 636                 {
 637                         if (!caller || autocvar_sv_timeout)
 638                         {
 639                                 if (!timeout_status) { print_to(caller, "^7Error: There is no active timeout called."); }
 640                                 else if (caller && (caller != timeout_caller))
 641                                 {
 642                                         print_to(caller, "^7Error: You are not allowed to stop the active timeout.");
 643                                 }
 644
 645                                 else  // everything should be okay, continue aborting timeout
 646                                 {
 647                                         switch (timeout_status)
 648                                         {
 649                                                 case TIMEOUT_LEADTIME:
 650                                                 {
 651                                                         timeout_status = TIMEOUT_INACTIVE;
 652                                                         timeout_time = 0;
 653                                                         timeout_handler.nextthink = time;  // timeout_handler has to take care of it immediately
 654                                                         bprint(strcat("^7The timeout was aborted by ", GetCallerName(caller), " !\n"));
 655                                                         return;
 656                                                 }
 657
 658                                                 case TIMEOUT_ACTIVE:
 659                                                 {
 660                                                         timeout_time = autocvar_sv_timeout_resumetime;
 661                                                         timeout_handler.nextthink = time;  // timeout_handler has to take care of it immediately
 662                                                         bprint(strcat("^1Attention: ^7", GetCallerName(caller), " resumed the game! Prepare for battle!\n"));
 663                                                         return;
 664                                                 }
 665
 666                                                 default: LOG_TRACE("timeout status was inactive, but this code was executed anyway?");
 667                                                         return;
 668                                         }
 669                                 }
 670                         }
 671                         else { print_to(caller, "^1Timeins are not allowed to be called, enable them with sv_timeout 1.\n"); }
 672
 673                         return;  // never fall through to usage
 674                 }
 675
 676                 default:
 677                 case CMD_REQUEST_USAGE:
 678                 {
 679                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timein"));
 680                         print_to(caller, "  No arguments required.");
 681                         return;
 682                 }
 683         }
 684 }
 685
 686 void CommonCommand_timeout(float request, entity caller)  // DEAR GOD THIS COMMAND IS TERRIBLE.
 687 {
 688         switch (request)
 689         {
 690                 case CMD_REQUEST_COMMAND:
 691                 {
 692                         if (!caller || autocvar_sv_timeout)
 693                         {
 694                                 float last_possible_timeout = ((autocvar_timelimit * 60) - autocvar_sv_timeout_leadtime - 1);
 695
 696                                 if (timeout_status) { print_to(caller, "^7Error: A timeout is already active."); }
 697                                 else if (vote_called)
 698                                 {
 699                                         print_to(caller, "^7Error: You can not call a timeout while a vote is active.");
 700                                 }
 701                                 else if (warmup_stage && !g_warmup_allow_timeout)
 702                                 {
 703                                         print_to(caller, "^7Error: You can not call a timeout in warmup-stage.");
 704                                 }
 705                                 else if (time < game_starttime)
 706                                 {
 707                                         print_to(caller, "^7Error: You can not call a timeout while the map is being restarted.");
 708                                 }
 709                                 else if (caller && (caller.allowed_timeouts < 1))
 710                                 {
 711                                         print_to(caller, "^7Error: You already used all your timeout calls for this map.");
 712                                 }
 713                                 else if (caller && !IS_PLAYER(caller))
 714                                 {
 715                                         print_to(caller, "^7Error: You must be a player to call a timeout.");
 716                                 }
 717                                 else if ((autocvar_timelimit) && (last_possible_timeout < time - game_starttime))
 718                                 {
 719                                         print_to(caller, "^7Error: It is too late to call a timeout now!");
 720                                 }
 721
 722                                 else  // everything should be okay, proceed with starting the timeout
 723                                 {
 724                                         if (caller)   caller.allowed_timeouts -= 1;
 725                                         // write a bprint who started the timeout (and how many they have left)
 726                                         bprint(GetCallerName(caller), " ^7called a timeout", (caller ? strcat(" (", ftos(caller.allowed_timeouts), " timeout(s) left)") : ""), "!\n");
 727
 728                                         timeout_status = TIMEOUT_LEADTIME;
 729                                         timeout_caller = caller;
 730                                         timeout_time = autocvar_sv_timeout_length;
 731                                         timeout_leadtime = autocvar_sv_timeout_leadtime;
 732
 733                                         timeout_handler = spawn();
 734                                         timeout_handler.think = timeout_handler_think;
 735                                         timeout_handler.nextthink = time;  // always let the entity think asap
 736
 737                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_TIMEOUT);
 738                                 }
 739                         }
 740                         else { print_to(caller, "^1Timeouts are not allowed to be called, enable them with sv_timeout 1.\n"); }
 741
 742                         return;  // never fall through to usage
 743                 }
 744
 745                 default:
 746                 case CMD_REQUEST_USAGE:
 747                 {
 748                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timeout"));
 749                         print_to(caller, "  No arguments required.");
 750                         return;
 751                 }
 752         }
 753 }
 754
 755 void CommonCommand_who(float request, entity caller, float argc)
 756 {
 757         switch (request)
 758         {
 759                 case CMD_REQUEST_COMMAND:
 760                 {
 761                         float total_listed_players, is_bot;
 762                         entity tmp_player;
 763
 764                         float privacy = (caller && autocvar_sv_status_privacy);
 765                         string separator = strreplace("%", " ", strcat((argv(1) ? argv(1) : " "), "^7"));
 766                         string tmp_netaddress, tmp_crypto_idfp;
 767
 768                         print_to(caller, strcat("List of client information", (privacy ? " (some data is hidden for privacy)" : ""), ":"));
 769                         print_to(caller, sprintf(strreplace(" ", separator, " %-4s %-20s %-5s %-3s %-9s %-16s %s "),
 770                                 "ent", "nickname", "ping", "pl", "time", "ip", "crypto_id"));
 771
 772                         total_listed_players = 0;
 773                         FOR_EACH_CLIENT(tmp_player)
 774                         {
 775                                 is_bot = (IS_BOT_CLIENT(tmp_player));
 776
 777                                 if (is_bot)
 778                                 {
 779                                         tmp_netaddress = "null/botclient";
 780                                         tmp_crypto_idfp = "null/botclient";
 781                                 }
 782                                 else if (privacy)
 783                                 {
 784                                         tmp_netaddress = "hidden";
 785                                         tmp_crypto_idfp = "hidden";
 786                                 }
 787                                 else
 788                                 {
 789                                         tmp_netaddress = tmp_player.netaddress;
 790                                         tmp_crypto_idfp = tmp_player.crypto_idfp;
 791                                 }
 792
 793                                 print_to(caller, sprintf(strreplace(" ", separator, " #%-3d %-20.20s %-5d %-3d %-9s %-16s %s "),
 794                                         etof(tmp_player),
 795                                         tmp_player.netname,
 796                                         tmp_player.ping,
 797                                         tmp_player.ping_packetloss,
 798                                         process_time(1, time - tmp_player.jointime),
 799                                         tmp_netaddress,
 800                                         tmp_crypto_idfp));
 801
 802                                 ++total_listed_players;
 803                         }
 804
 805                         print_to(caller, strcat("Finished listing ", ftos(total_listed_players), " client(s) out of ", ftos(maxclients), " slots."));
 806
 807                         return;  // never fall through to usage
 808                 }
 809
 810                 default:
 811                 case CMD_REQUEST_USAGE:
 812                 {
 813                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " who [separator]"));
 814                         print_to(caller, "  Where 'separator' is the optional string to separate the values with, default is a space.");
 815                         return;
 816                 }
 817         }
 818 }
 819
 820 /* use this when creating a new command, making sure to place it in alphabetical order... also,
 821 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
 822 void CommonCommand_(float request, entity caller)
 823 {
 824     switch(request)
 825     {
 826         case CMD_REQUEST_COMMAND:
 827         {
 828
 829             return; // never fall through to usage
 830         }
 831
 832         default:
 833         case CMD_REQUEST_USAGE:
 834         {
 835             print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " "));
 836             print_to(caller, "  No arguments required.");
 837             return;
 838         }
 839     }
 840 }
 841 */