qcsrc/server/command/cmd.qc

   1 #include "cmd.qh"
   2
   3 #include <server/defs.qh>
   4 #include <server/miscfunctions.qh>
   5
   6 #include <common/command/_mod.qh>
   7
   8 #include "common.qh"
   9 #include "vote.qh"
  10
  11 #include "../bot/api.qh"
  12
  13 #include "../campaign.qh"
  14 #include "../cheats.qh"
  15 #include "../client.qh"
  16 #include "../clientkill.qh"
  17 #include "../player.qh"
  18 #include "../ipban.qh"
  19 #include "../mapvoting.qh"
  20 #include "../scores.qh"
  21 #include "../teamplay.qh"
  22
  23 #include <server/mutators/_mod.qh>
  24 #include <common/gamemodes/_mod.qh>
  25
  26 #ifdef SVQC
  27         #include <common/vehicles/all.qh>
  28 #endif
  29
  30 #include <common/constants.qh>
  31 #include <common/deathtypes/all.qh>
  32 #include <common/effects/all.qh>
  33 #include <common/mapinfo.qh>
  34 #include <common/notifications/all.qh>
  35 #include <common/physics/player.qh>
  36 #include <common/teams.qh>
  37 #include <common/util.qh>
  38 #include <common/mapobjects/triggers.qh>
  39
  40 #include <common/minigames/sv_minigames.qh>
  41
  42 #include <common/monsters/_mod.qh>
  43 #include <common/monsters/sv_spawn.qh>
  44 #include <common/monsters/sv_monsters.qh>
  45
  46 #include <lib/warpzone/common.qh>
  47
  48 // =========================================================
  49 //  Server side networked commands code, reworked by Samual
  50 //  Last updated: December 28th, 2011
  51 // =========================================================
  52
  53 bool SV_ParseClientCommand_floodcheck(entity this)
  54 {
  55         entity store = IS_CLIENT(this) ? CS(this) : this; // unfortunately, we need to store these on the client initially
  56
  57         if (!timeout_status)  // not while paused
  58         {
  59                 if (time <= (store.cmd_floodtime + autocvar_sv_clientcommand_antispam_time))
  60                 {
  61                         store.cmd_floodcount += 1;
  62                         if (store.cmd_floodcount > autocvar_sv_clientcommand_antispam_count)   return false;  // too much spam, halt
  63                 }
  64                 else
  65                 {
  66                         store.cmd_floodtime = time;
  67                         store.cmd_floodcount = 1;
  68                 }
  69         }
  70         return true;  // continue, as we're not flooding yet
  71 }
  72
  73
  74 // =======================
  75 //  Command Sub-Functions
  76 // =======================
  77
  78 void ClientCommand_autoswitch(entity caller, int request, int argc)
  79 {
  80         switch (request)
  81         {
  82                 case CMD_REQUEST_COMMAND:
  83                 {
  84                         if (argv(1) != "")
  85                         {
  86                                 CS(caller).autoswitch = InterpretBoolean(argv(1));
  87                                 sprint(caller, strcat("^1autoswitch is currently turned ", (CS(caller).autoswitch ? "on" : "off"), ".\n"));
  88                                 return;
  89                         }
  90                 }
  91
  92                 default:
  93                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
  94                 case CMD_REQUEST_USAGE:
  95                 {
  96                         sprint(caller, "\nUsage:^3 cmd autoswitch selection\n");
  97                         sprint(caller, "  Where 'selection' controls if autoswitch is on or off.\n");
  98                         return;
  99                 }
 100         }
 101 }
 102
 103 void ClientCommand_clientversion(entity caller, int request, int argc)  // internal command, used only by code
 104 {
 105         switch (request)
 106         {
 107                 case CMD_REQUEST_COMMAND:
 108                 {
 109                         if (argv(1) != "")
 110                         {
 111                                 if (IS_CLIENT(caller))
 112                                 {
 113                                         CS(caller).version = ((argv(1) == "$gameversion") ? 1 : stof(argv(1)));
 114
 115                                         if (CS(caller).version < autocvar_gameversion_min || CS(caller).version > autocvar_gameversion_max)
 116                                         {
 117                                                 CS(caller).version_mismatch = true;
 118                                                 ClientKill_TeamChange(caller, -2);  // observe
 119                                         }
 120                                         else if (autocvar_g_campaign || autocvar_g_balance_teams)
 121                                         {
 122                                                 // JoinBestTeam(caller, false, true);
 123                                         }
 124                                         else if (teamplay && !autocvar_sv_spectate && !(Player_GetForcedTeamIndex(caller) > 0))
 125                                         {
 126                                                 TRANSMUTE(Observer, caller);  // really?
 127                                                 stuffcmd(caller, "menu_showteamselect\n");
 128                                         }
 129                                 }
 130
 131                                 return;
 132                         }
 133                 }
 134
 135                 default:
 136                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 137                 case CMD_REQUEST_USAGE:
 138                 {
 139                         sprint(caller, "\nUsage:^3 cmd clientversion version\n");
 140                         sprint(caller, "  Where 'version' is the game version reported by caller.\n");
 141                         return;
 142                 }
 143         }
 144 }
 145
 146 void ClientCommand_mv_getpicture(entity caller, int request, int argc)  // internal command, used only by code
 147 {
 148         switch (request)
 149         {
 150                 case CMD_REQUEST_COMMAND:
 151                 {
 152                         if (argv(1) != "")
 153                         {
 154                                 if (intermission_running) MapVote_SendPicture(caller, stof(argv(1)));
 155
 156                                 return;
 157                         }
 158                 }
 159
 160                 default:
 161                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 162                 case CMD_REQUEST_USAGE:
 163                 {
 164                         sprint(caller, "\nUsage:^3 cmd mv_getpicture mapid\n");
 165                         sprint(caller, "  Where 'mapid' is the id number of the map to request an image of on the map vote selection menu.\n");
 166                         return;
 167                 }
 168         }
 169 }
 170
 171 void ClientCommand_wpeditor(entity caller, int request, int argc)
 172 {
 173         switch (request)
 174         {
 175                 case CMD_REQUEST_COMMAND:
 176                 {
 177                         if (!autocvar_g_waypointeditor)
 178                         {
 179                                 sprint(caller, "ERROR: this command works only if the waypoint editor is on\n");
 180                                 return;
 181                         }
 182
 183                         if (argv(1) != "")
 184                         {
 185                                 if (argv(1) == "spawn")
 186                                 {
 187                                         string s = argv(2);
 188                                         if (!IS_PLAYER(caller))
 189                                                 sprint(caller, "ERROR: this command works only if you are player\n");
 190                                         else
 191                                                 waypoint_spawn_fromeditor(caller, (s == "crosshair"), (s == "jump"), (s == "crouch"), (s == "support"));
 192                                         return;
 193                                 }
 194                                 else if (argv(1) == "remove")
 195                                 {
 196                                         if (!IS_PLAYER(caller))
 197                                                 sprint(caller, "ERROR: this command works only if you are player\n");
 198                                         else
 199                                                 waypoint_remove_fromeditor(caller);
 200                                         return;
 201                                 }
 202                                 else if (argv(1) == "hardwire")
 203                                 {
 204                                         string s = argv(2);
 205                                         waypoint_start_hardwiredlink(caller, (s == "crosshair"));
 206                                         return;
 207                                 }
 208                                 else if (argv(1) == "lock")
 209                                 {
 210                                         waypoint_lock(caller);
 211                                         return;
 212                                 }
 213                                 else if (argv(1) == "unreachable")
 214                                 {
 215                                         if (!IS_PLAYER(caller))
 216                                                 sprint(caller, "ERROR: this command works only if you are player\n");
 217                                         else
 218                                                 waypoint_unreachable(caller);
 219                                         return;
 220                                 }
 221                                 else if (argv(1) == "saveall")
 222                                 {
 223                                         waypoint_saveall();
 224                                         return;
 225                                 }
 226                                 else if (argv(1) == "relinkall")
 227                                 {
 228                                         waypoint_schedulerelinkall();
 229                                         return;
 230                                 }
 231                                 else if (argv(1) == "symaxis")
 232                                 {
 233                                         if (argv(2) == "set" || argv(2) == "get")
 234                                         {
 235                                                 waypoint_getSymmetricalAxis_cmd(caller, (argv(2) == "set"), 3);
 236                                                 return;
 237                                         }
 238                                 }
 239                                 else if (argv(1) == "symorigin")
 240                                 {
 241                                         if (argv(2) == "set" || argv(2) == "get")
 242                                         {
 243                                                 waypoint_getSymmetricalOrigin_cmd(caller, (argv(2) == "set"), 3);
 244                                                 return;
 245                                         }
 246                                 }
 247                         }
 248                 }
 249
 250                 default:
 251                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 252                 case CMD_REQUEST_USAGE:
 253                 {
 254                         sprint(caller, "\nUsage:^3 cmd wpeditor action\n");
 255                         sprint(caller, "  Where 'action' can be:\n");
 256                         sprint(caller, "   ^5spawn^7: spawns a waypoint at player's position\n");
 257                         sprint(caller, "   ^5remove^7: removes player's nearest waypoint\n");
 258                         sprint(caller, "   ^5unreachable^7: reveals waypoints and items unreachable from the current position and spawnpoints without a nearest waypoint\n");
 259                         sprint(caller, "   ^5saveall^7: saves all waypoints and links to file\n");
 260                         sprint(caller, "   ^5relinkall^7: relinks all waypoints as if they were respawned\n");
 261                         sprint(caller, "   ^5spawn crosshair^7: spawns a waypoint at crosshair's position\n");
 262                         sprint(caller, "   ^7 in general useful to create special and hardwired links with ease from existing waypoints\n");
 263                         sprint(caller, "   ^7 in particular it's the only way to create custom jumppad waypoints (spawn another waypoint to create destination))\n");
 264                         sprint(caller, "   ^5spawn jump^7: spawns a jump waypoint (place it at least 60 qu before jump start, spawn another waypoint to create destination)\n");
 265                         sprint(caller, "   ^5spawn crouch^7: spawns a crouch waypoint (it links only to very close waypoints)\n");
 266                         sprint(caller, "   ^5spawn support^7: spawns a support waypoint (spawn another waypoint to create destination from which all incoming links are removed)\n");
 267                         sprint(caller, "   ^7 useful to replace links to problematic jumppad/teleport waypoints\n");
 268                         sprint(caller, "   ^5hardwire^7: marks the nearest waypoint as origin of a new hardwired link (spawn another waypoint over an existing one to create destination)\n");
 269                         sprint(caller, "   ^5hardwire crosshair^7: marks the waypoint at crosshair instead of the nearest waypoint\n");
 270                         sprint(caller, "   ^5lock^7: locks link display of the aimed waypoint (unlocks if no waypoint is found at crosshair's position)\n");
 271                         sprint(caller, "   ^5symorigin get|set\n");
 272                         sprint(caller, "   ^5symorigin get|set p1 p2 ... pX\n");
 273                         sprint(caller, "   ^5symaxis get|set p1 p2\n");
 274                         sprint(caller, "   ^7 where p1 p2 ... pX are positions (\"x y z\", z can be omitted) that you know are perfectly symmetrical"
 275                                                                 " so you can determine origin/axis of symmetry of maps without ctf flags or where flags aren't perfectly symmetrical\n");
 276                         sprint(caller, "  See 'wpeditor_menu' for a selectable list of various commands and useful settings to edit waypoints.\n");
 277                         return;
 278                 }
 279         }
 280 }
 281
 282 void ClientCommand_join(entity caller, int request)
 283 {
 284         switch (request)
 285         {
 286                 case CMD_REQUEST_COMMAND:
 287                 {
 288                         if (!game_stopped && IS_CLIENT(caller) && !IS_PLAYER(caller))
 289                         {
 290                                 if (joinAllowed(caller))
 291                                         Join(caller);
 292                                 else if(time < CS(caller).jointime + MIN_SPEC_TIME)
 293                                         CS(caller).autojoin_checked = -1;
 294                         }
 295
 296                         return;  // never fall through to usage
 297                 }
 298
 299                 default:
 300                 case CMD_REQUEST_USAGE:
 301                 {
 302                         sprint(caller, "\nUsage:^3 cmd join\n");
 303                         sprint(caller, "  No arguments required.\n");
 304                         return;
 305                 }
 306         }
 307 }
 308
 309 void ClientCommand_kill(entity caller, int request)
 310 {
 311         switch (request)
 312         {
 313                 case CMD_REQUEST_COMMAND:
 314                 {
 315                         if(IS_SPEC(caller) || IS_OBSERVER(caller))
 316                                 return; // no point warning about this, command does nothing
 317
 318                         if(GetResource(caller, RES_HEALTH) <= 0)
 319                         {
 320                                 sprint(caller, "Can't die - you are already dead!\n");
 321                                 return;
 322                         }
 323
 324                         ClientKill(caller);
 325
 326                         return;  // never fall through to usage
 327                 }
 328
 329                 default:
 330                 case CMD_REQUEST_USAGE:
 331                 {
 332                         sprint(caller, "\nUsage:^3 cmd kill\n");
 333                         sprint(caller, "  No arguments required.\n");
 334                         return;
 335                 }
 336         }
 337 }
 338
 339 void ClientCommand_physics(entity caller, int request, int argc)
 340 {
 341         switch (request)
 342         {
 343                 case CMD_REQUEST_COMMAND:
 344                 {
 345                         string command = strtolower(argv(1));
 346
 347                         if (!autocvar_g_physics_clientselect)
 348                         {
 349                                 sprint(caller, "Client physics selection is currently disabled.\n");
 350                                 return;
 351                         }
 352
 353                         if (command == "list" || command == "help")
 354                         {
 355                                 sprint(caller, strcat("Available physics sets: \n\n", autocvar_g_physics_clientselect_options, " default\n"));
 356                                 return;
 357                         }
 358
 359                         if (Physics_Valid(command) || command == "default")
 360                         {
 361                                 stuffcmd(caller, strcat("\nseta cl_physics ", command, "\n"));
 362                                 sprint(caller, strcat("^2Physics set successfully changed to ^3", command, "\n"));
 363                                 return;
 364                         }
 365                 }
 366
 367                 default:
 368                         sprint(caller, strcat("Current physics set: ^3", CS(caller).cvar_cl_physics, "\n"));
 369                 case CMD_REQUEST_USAGE:
 370                 {
 371                         sprint(caller, "\nUsage:^3 cmd physics <physics>\n");
 372                         sprint(caller, "  See 'cmd physics list' for available physics sets.\n");
 373                         sprint(caller, "  Argument 'default' resets to standard physics.\n");
 374                         return;
 375                 }
 376         }
 377 }
 378
 379 void ClientCommand_ready(entity caller, int request)  // todo: anti-spam for toggling readyness
 380 {
 381         switch (request)
 382         {
 383                 case CMD_REQUEST_COMMAND:
 384                 {
 385                         if (IS_CLIENT(caller))
 386                         {
 387                                 if (warmup_stage || sv_ready_restart || g_race_qualifying == 2)
 388                                 {
 389                                         if (!readyrestart_happened || sv_ready_restart_repeatable)
 390                                         {
 391                                                 if (time < game_starttime) // game is already restarting
 392                                                         return;
 393                                                 if (caller.ready)            // toggle
 394                                                 {
 395                                                         caller.ready = false;
 396                                                         if(IS_PLAYER(caller) || caller.caplayer == 1)
 397                                                                 bprint(playername(caller, false), "^2 is ^1NOT^2 ready\n");
 398                                                 }
 399                                                 else
 400                                                 {
 401                                                         caller.ready = true;
 402                                                         if(IS_PLAYER(caller) || caller.caplayer == 1)
 403                                                                 bprint(playername(caller, false), "^2 is ready\n");
 404                                                 }
 405
 406                                                 // cannot reset the game while a timeout is active!
 407                                                 if (!timeout_status) ReadyCount();
 408                                         }
 409                                         else
 410                                         {
 411                                                 sprint(caller, "^1Game has already been restarted\n");
 412                                         }
 413                                 }
 414                         }
 415                         return;  // never fall through to usage
 416                 }
 417
 418                 default:
 419                 case CMD_REQUEST_USAGE:
 420                 {
 421                         sprint(caller, "\nUsage:^3 cmd ready\n");
 422                         sprint(caller, "  No arguments required.\n");
 423                         return;
 424                 }
 425         }
 426 }
 427
 428 void ClientCommand_say(entity caller, int request, int argc, string command)
 429 {
 430         switch (request)
 431         {
 432                 case CMD_REQUEST_COMMAND:
 433                 {
 434                         if (argc >= 2)   Say(caller, false, NULL, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)), 1);
 435                         return;  // never fall through to usage
 436                 }
 437
 438                 default:
 439                 case CMD_REQUEST_USAGE:
 440                 {
 441                         sprint(caller, "\nUsage:^3 cmd say <message>\n");
 442                         sprint(caller, "  Where 'message' is the string of text to say.\n");
 443                         return;
 444                 }
 445         }
 446 }
 447
 448 void ClientCommand_say_team(entity caller, int request, int argc, string command)
 449 {
 450         switch (request)
 451         {
 452                 case CMD_REQUEST_COMMAND:
 453                 {
 454                         if (argc >= 2)
 455                                 Say(caller, true, NULL, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)), 1);
 456                         return;  // never fall through to usage
 457                 }
 458
 459                 default:
 460                 case CMD_REQUEST_USAGE:
 461                 {
 462                         sprint(caller, "\nUsage:^3 cmd say_team <message>\n");
 463                         sprint(caller, "  Where 'message' is the string of text to say.\n");
 464                         return;
 465                 }
 466         }
 467 }
 468
 469 .bool team_selected;
 470 void ClientCommand_selectteam(entity caller, int request, int argc)
 471 {
 472         switch (request)
 473         {
 474                 case CMD_REQUEST_COMMAND:
 475                 {
 476                         if (argv(1) == "")
 477                         {
 478                                 return;
 479                         }
 480                         if (!IS_CLIENT(caller))
 481                         {
 482                                 return;
 483                         }
 484                         if (!teamplay)
 485                         {
 486                                 sprint(caller, "^7selectteam can only be used in teamgames\n");
 487                                 return;
 488                         }
 489                         if (Player_GetForcedTeamIndex(caller) > 0)
 490                         {
 491                                 sprint(caller, "^7selectteam can not be used as your team is forced\n");
 492                                 return;
 493                         }
 494                         if (lockteams)
 495                         {
 496                                 sprint(caller, "^7The game has already begun, you must wait until the next map to be able to join a team.\n");
 497                                 return;
 498                         }
 499                         float selection;
 500                         switch (argv(1))
 501                         {
 502                                 case "red":
 503                                 {
 504                                         selection = NUM_TEAM_1;
 505                                         break;
 506                                 }
 507                                 case "blue":
 508                                 {
 509                                         selection = NUM_TEAM_2;
 510                                         break;
 511                                 }
 512                                 case "yellow":
 513                                 {
 514                                         selection = NUM_TEAM_3;
 515                                         break;
 516                                 }
 517                                 case "pink":
 518                                 {
 519                                         selection = NUM_TEAM_4;
 520                                         break;
 521                                 }
 522                                 case "auto":
 523                                 {
 524                                         selection = (-1);
 525                                         break;
 526                                 }
 527                                 default:
 528                                 {
 529                                         return;
 530                                 }
 531                         }
 532                         if (caller.team == selection && selection != -1 && !IS_DEAD(caller))
 533                         {
 534                                 sprint(caller, "^7You already are on that team.\n");
 535                                 return;
 536                         }
 537                         if (CS(caller).wasplayer && autocvar_g_changeteam_banned)
 538                         {
 539                                 sprint(caller, "^1You cannot change team, forbidden by the server.\n");
 540                                 return;
 541                         }
 542                         if ((selection != -1) && autocvar_g_balance_teams &&
 543                                 autocvar_g_balance_teams_prevent_imbalance)
 544                         {
 545                                 entity balance = TeamBalance_CheckAllowedTeams(caller);
 546                                 TeamBalance_GetTeamCounts(balance, caller);
 547                                 if ((Team_IndexToBit(Team_TeamToIndex(selection)) &
 548                                         TeamBalance_FindBestTeams(balance, caller, false)) == 0)
 549                                 {
 550                                         Send_Notification(NOTIF_ONE, caller, MSG_INFO, INFO_TEAMCHANGE_LARGERTEAM);
 551                                         TeamBalance_Destroy(balance);
 552                                         return;
 553                                 }
 554                                 TeamBalance_Destroy(balance);
 555                         }
 556                         ClientKill_TeamChange(caller, selection);
 557                         if (!IS_PLAYER(caller))
 558                         {
 559                                 caller.team_selected = true; // avoids asking again for team selection on join
 560                         }
 561                         return;
 562                 }
 563                 default:
 564                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 565                 case CMD_REQUEST_USAGE:
 566                 {
 567                         sprint(caller, "\nUsage:^3 cmd selectteam team\n");
 568                         sprint(caller, "  Where 'team' is the prefered team to try and join.\n");
 569                         sprint(caller, "  Full list of options here: \"red, blue, yellow, pink, auto\"\n");
 570                         return;
 571                 }
 572         }
 573 }
 574
 575 void ClientCommand_selfstuff(entity caller, int request, string command)
 576 {
 577         switch (request)
 578         {
 579                 case CMD_REQUEST_COMMAND:
 580                 {
 581                         if (argv(1) != "")
 582                         {
 583                                 stuffcmd(caller, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)));
 584                                 return;
 585                         }
 586                 }
 587
 588                 default:
 589                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 590                 case CMD_REQUEST_USAGE:
 591                 {
 592                         sprint(caller, "\nUsage:^3 cmd selfstuff <command>\n");
 593                         sprint(caller, "  Where 'command' is the string to be stuffed to your client.\n");
 594                         return;
 595                 }
 596         }
 597 }
 598
 599 void ClientCommand_sentcvar(entity caller, int request, int argc, string command)
 600 {
 601         switch (request)
 602         {
 603                 case CMD_REQUEST_COMMAND:
 604                 {
 605                         if (argv(1) != "")
 606                         {
 607                                 // float tokens;
 608                                 string s;
 609
 610                                 if (argc == 2)  // undefined cvar: use the default value on the server then
 611                                 {
 612                                         s = strcat(substring(command, argv_start_index(0), argv_end_index(1) - argv_start_index(0)), " \"", cvar_defstring(argv(1)), "\"");
 613                                         tokenize_console(s);
 614                                 }
 615
 616                                 GetCvars(caller, CS(caller), 1);
 617
 618                                 return;
 619                         }
 620                 }
 621
 622                 default:
 623                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 624                 case CMD_REQUEST_USAGE:
 625                 {
 626                         sprint(caller, "\nUsage:^3 cmd sentcvar <cvar>\n");
 627                         sprint(caller, "  Where 'cvar' is the cvar plus arguments to send to the server.\n");
 628                         return;
 629                 }
 630         }
 631 }
 632
 633 void ClientCommand_spectate(entity caller, int request)
 634 {
 635         switch (request)
 636         {
 637                 case CMD_REQUEST_COMMAND:
 638                 {
 639                         if (!intermission_running && IS_CLIENT(caller))
 640                         {
 641                                 if(argv(1) != "")
 642                                 {
 643                                         if(IS_SPEC(caller) || IS_OBSERVER(caller))
 644                                         {
 645                                                 entity client = GetFilteredEntity(argv(1));
 646                                                 int spec_accepted = VerifyClientEntity(client, false, false);
 647                                                 if(spec_accepted > 0 && IS_PLAYER(client))
 648                                                 {
 649                                                         Spectate(caller, client);
 650                                                 }
 651                                                 else
 652                                                         sprint(caller, "can't spectate ", argv(1), "^7\n");
 653                                         }
 654                                         else
 655                                                 sprint(caller, "cmd spectate client only works when you are spectator/observer\n");
 656                                         return;
 657                                 }
 658
 659                                 int mutator_returnvalue = MUTATOR_CALLHOOK(ClientCommand_Spectate, caller);
 660
 661                                 if (mutator_returnvalue == MUT_SPECCMD_RETURN) return;
 662
 663                                 if ((IS_PLAYER(caller) || mutator_returnvalue == MUT_SPECCMD_FORCE))
 664                                 if (autocvar_sv_spectate == 1)
 665                                         ClientKill_TeamChange(caller, -2); // observe
 666                         }
 667                         return; // never fall through to usage
 668                 }
 669
 670                 default:
 671                 case CMD_REQUEST_USAGE:
 672                 {
 673                         sprint(caller, "\nUsage:^3 cmd spectate [client]\n");
 674                         sprint(caller, "  Where 'client' can be the player to spectate.\n");
 675                         return;
 676                 }
 677         }
 678 }
 679
 680 void ClientCommand_suggestmap(entity caller, int request, int argc)
 681 {
 682         switch (request)
 683         {
 684                 case CMD_REQUEST_COMMAND:
 685                 {
 686                         if (argv(1) != "")
 687                         {
 688                                 sprint(caller, strcat(MapVote_Suggest(caller, argv(1)), "\n"));
 689                                 return;
 690                         }
 691                 }
 692
 693                 default:
 694                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 695                 case CMD_REQUEST_USAGE:
 696                 {
 697                         sprint(caller, "\nUsage:^3 cmd suggestmap map\n");
 698                         sprint(caller, "  Where 'map' is the name of the map to suggest.\n");
 699                         return;
 700                 }
 701         }
 702 }
 703
 704 void ClientCommand_tell(entity caller, int request, int argc, string command)
 705 {
 706         switch (request)
 707         {
 708                 case CMD_REQUEST_COMMAND:
 709                 {
 710                         if (argc >= 3)
 711                         {
 712                                 if(!IS_CLIENT(caller) && IS_REAL_CLIENT(caller)) // connecting
 713                                 {
 714                                         print_to(caller, "You can't ^2tell^7 a message while connecting.");
 715                                         return;
 716                                 }
 717
 718                                 entity tell_to = GetIndexedEntity(argc, 1);
 719                                 float tell_accepted = VerifyClientEntity(tell_to, true, false);
 720
 721                                 if (tell_accepted > 0)   // the target is a real client
 722                                 {
 723                                         if (tell_to != caller) // and we're allowed to send to them :D
 724                                         {
 725                                                 // workaround for argv indexes indexing ascii chars instead of utf8 chars
 726                                                 // In this case when the player name contains utf8 chars
 727                                                 // the message gets partially trimmed in the beginning.
 728                                                 // Potentially this bug affects any substring call that uses
 729                                                 // argv_start_index and argv_end_index.
 730
 731                                                 string utf8_enable_save = cvar_string("utf8_enable");
 732                                                 cvar_set("utf8_enable", "0");
 733                                                 string msg = substring(command, argv_start_index(next_token), argv_end_index(-1) - argv_start_index(next_token));
 734                                                 cvar_set("utf8_enable", utf8_enable_save);
 735
 736                                                 Say(caller, false, tell_to, msg, true);
 737                                                 return;
 738                                         }
 739                                         else { print_to(caller, "You can't ^2tell^7 a message to yourself."); return; }
 740                                 }
 741                                 else if (argv(1) == "#0")
 742                                 {
 743                                         trigger_magicear_processmessage_forallears(caller, -1, NULL, substring(command, argv_start_index(next_token), argv_end_index(-1) - argv_start_index(next_token)));
 744                                         return;
 745                                 }
 746                                 else { print_to(caller, strcat("tell: ", GetClientErrorString(tell_accepted, argv(1)), ".")); return; }
 747                         }
 748                 }
 749
 750                 default:
 751                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 752                 case CMD_REQUEST_USAGE:
 753                 {
 754                         sprint(caller, "\nUsage:^3 cmd tell client <message>\n");
 755                         sprint(caller, "  Where 'client' is the entity number or name of the player to send 'message' to.\n");
 756                         return;
 757                 }
 758         }
 759 }
 760
 761 void ClientCommand_voice(entity caller, int request, int argc, string command)
 762 {
 763         switch (request)
 764         {
 765                 case CMD_REQUEST_COMMAND:
 766                 {
 767                         if (argv(1) != "")
 768                         {
 769                                 entity e = GetVoiceMessage(argv(1));
 770                                 if (!e)
 771                                 {
 772                                         sprint(caller, sprintf("Invalid voice. Use one of: %s\n", allvoicesamples));
 773                                         return;
 774                                 }
 775                                 if (IS_DEAD(caller))
 776                                 {
 777                                         // don't warn the caller when trying to taunt while dead, just don't play any sounds!
 778                                         // we still allow them to see warnings if it's invalid, so a dead player can find out the sounds in peace
 779                                         return;
 780                                 }
 781                                 if (IS_SPEC(caller) || IS_OBSERVER(caller))
 782                                 {
 783                                         // observers/spectators have no player model of their own to play taunts from
 784                                         // again, allow them to see warnings
 785                                         return;
 786                                 }
 787                                 string msg = "";
 788                                 if (argc >= 3)
 789                                         msg = substring(command, argv_start_index(2), argv_end_index(-1) - argv_start_index(2));
 790                                 VoiceMessage(caller, e, msg);
 791
 792                                 return;
 793                         }
 794                 }
 795
 796                 default:
 797                         sprint(caller, sprintf("Incorrect parameters for ^2%s^7\n", argv(0)));
 798                 case CMD_REQUEST_USAGE:
 799                 {
 800                         sprint(caller, "\nUsage:^3 cmd voice messagetype <soundname>\n");
 801                         sprint(caller, "  'messagetype' is the type of broadcast to do, like team only or such,\n");
 802                         sprint(caller, "  and 'soundname' is the string/filename of the sound/voice message to play.\n");
 803                         return;
 804                 }
 805         }
 806 }
 807
 808 /* use this when creating a new command, making sure to place it in alphabetical order... also,
 809 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
 810 void ClientCommand_(entity caller, int request)
 811 {
 812     switch(request)
 813     {
 814         case CMD_REQUEST_COMMAND:
 815         {
 816
 817             return; // never fall through to usage
 818         }
 819
 820         default:
 821         case CMD_REQUEST_USAGE:
 822         {
 823             sprint(caller, "\nUsage:^3 cmd \n");
 824             sprint(caller, "  No arguments required.\n");
 825             return;
 826         }
 827     }
 828 }
 829 */
 830
 831
 832 // =====================================
 833 //  Macro system for networked commands
 834 // =====================================
 835
 836 // Do not hard code aliases for these, instead create them in commands.cfg... also: keep in alphabetical order, please ;)
 837 #define CLIENT_COMMANDS(ent, request, arguments, command) \
 838         CLIENT_COMMAND("autoswitch", ClientCommand_autoswitch(ent, request, arguments), "Whether or not to switch automatically when getting a better weapon") \
 839         CLIENT_COMMAND("clientversion", ClientCommand_clientversion(ent, request, arguments), "Release version of the game") \
 840         CLIENT_COMMAND("join", ClientCommand_join(ent, request), "Become a player in the game") \
 841         CLIENT_COMMAND("kill", ClientCommand_kill(ent, request), "Become a member of the dead") \
 842         CLIENT_COMMAND("minigame", ClientCommand_minigame(ent, request, arguments, command), "Start a minigame") \
 843         CLIENT_COMMAND("mv_getpicture", ClientCommand_mv_getpicture(ent, request, arguments), "Retrieve mapshot picture from the server") \
 844         CLIENT_COMMAND("physics", ClientCommand_physics(ent, request, arguments), "Change physics set") \
 845         CLIENT_COMMAND("ready", ClientCommand_ready(ent, request), "Qualify as ready to end warmup stage (or restart server if allowed)") \
 846         CLIENT_COMMAND("say", ClientCommand_say(ent, request, arguments, command), "Print a message to chat to all players") \
 847         CLIENT_COMMAND("say_team", ClientCommand_say_team(ent, request, arguments, command), "Print a message to chat to all team mates") \
 848         CLIENT_COMMAND("selectteam", ClientCommand_selectteam(ent, request, arguments), "Attempt to choose a team to join into") \
 849         CLIENT_COMMAND("selfstuff", ClientCommand_selfstuff(ent, request, command), "Stuffcmd a command to your own client") \
 850         CLIENT_COMMAND("sentcvar", ClientCommand_sentcvar(ent, request, arguments, command), "New system for sending a client cvar to the server") \
 851         CLIENT_COMMAND("spectate", ClientCommand_spectate(ent, request), "Become an observer") \
 852         CLIENT_COMMAND("suggestmap", ClientCommand_suggestmap(ent, request, arguments), "Suggest a map to the mapvote at match end") \
 853         CLIENT_COMMAND("tell", ClientCommand_tell(ent, request, arguments, command), "Send a message directly to a player") \
 854         CLIENT_COMMAND("voice", ClientCommand_voice(ent, request, arguments, command), "Send voice message via sound") \
 855         CLIENT_COMMAND("wpeditor", ClientCommand_wpeditor(ent, request, arguments), "Waypoint editor commands") \
 856         /* nothing */
 857
 858 void ClientCommand_macro_help(entity caller)
 859 {
 860         #define CLIENT_COMMAND(name, function, description) \
 861                 { sprint(caller, "  ^2", name, "^7: ", description, "\n"); }
 862
 863         CLIENT_COMMANDS(NULL, 0, 0, "");
 864 #undef CLIENT_COMMAND
 865 }
 866
 867 float ClientCommand_macro_command(int argc, entity caller, string command)
 868 {
 869         #define CLIENT_COMMAND(name, function, description) \
 870                 { if (name == strtolower(argv(0))) { function; return true; } }
 871
 872         CLIENT_COMMANDS(caller, CMD_REQUEST_COMMAND, argc, command);
 873 #undef CLIENT_COMMAND
 874
 875         return false;
 876 }
 877
 878 float ClientCommand_macro_usage(int argc, entity caller)
 879 {
 880         #define CLIENT_COMMAND(name, function, description) \
 881                 { if (name == strtolower(argv(1))) { function; return true; } }
 882
 883         CLIENT_COMMANDS(caller, CMD_REQUEST_USAGE, argc, "");
 884 #undef CLIENT_COMMAND
 885
 886         return false;
 887 }
 888
 889 void ClientCommand_macro_write_aliases(float fh)
 890 {
 891         #define CLIENT_COMMAND(name, function, description) \
 892                 { CMD_Write_Alias("qc_cmd_cmd", name, description); }
 893
 894         CLIENT_COMMANDS(NULL, 0, 0, "");
 895 #undef CLIENT_COMMAND
 896 }
 897
 898 // ======================================
 899 //  Main Function Called By Engine (cmd)
 900 // ======================================
 901 // If this function exists, server game code parses clientcommand before the engine code gets it.
 902
 903 void SV_ParseClientCommand(entity this, string command)
 904 {
 905         // If invalid UTF-8, don't even parse it
 906         string command2 = "";
 907         float len = strlen(command);
 908         float i;
 909         for (i = 0; i < len; ++i)
 910                 command2 = strcat(command2, chr2str(str2chr(command, i)));
 911         if (command != command2) return;
 912
 913         // if we're banned, don't even parse the command
 914         if (Ban_MaybeEnforceBanOnce(this)) return;
 915
 916         int argc = tokenize_console(command);
 917
 918         // Guide for working with argc arguments by example:
 919         // argc:   1    - 2      - 3     - 4
 920         // argv:   0    - 1      - 2     - 3
 921         // cmd     vote - master - login - password
 922
 923         // for floodcheck
 924         switch (strtolower(argv(0)))
 925         {
 926                 // exempt commands which are not subject to floodcheck
 927                 case "begin": break;                               // handled by engine in host_cmd.c
 928                 case "download": break;                            // handled by engine in cl_parse.c
 929                 case "mv_getpicture": break;                       // handled by server in this file
 930                 case "wpeditor": break;                            // handled by server in this file
 931                 case "pause": break;                               // handled by engine in host_cmd.c
 932                 case "prespawn": break;                            // handled by engine in host_cmd.c
 933                 case "sentcvar": break;                            // handled by server in this file
 934                 case "spawn": break;                               // handled by engine in host_cmd.c
 935                 case "color": case "topcolor": case "bottomcolor": if(teamplay) return; else break; // handled by engine in host_cmd.c
 936                 case "c2s": Net_ClientCommand(this, command); return; // handled by net.qh
 937
 938                 default:
 939                         if (SV_ParseClientCommand_floodcheck(this)) break; // "true": continue, as we're not flooding yet
 940                         else return;                                   // "false": not allowed to continue, halt // print("^1ERROR: ^7ANTISPAM CAUGHT: ", command, ".\n");
 941         }
 942
 943         /* NOTE: should this be disabled? It can be spammy perhaps, but hopefully it's okay for now */
 944         if (argv(0) == "help")
 945         {
 946                 if (argc == 1)
 947                 {
 948                         sprint(this, "\nClient networked commands:\n");
 949                         ClientCommand_macro_help(this);
 950
 951                         sprint(this, "\nCommon networked commands:\n");
 952                         CommonCommand_macro_help(this);
 953
 954                         sprint(this, "\nUsage:^3 cmd COMMAND...^7, where possible commands are listed above.\n");
 955                         sprint(this, "For help about a specific command, type cmd help COMMAND\n");
 956                         return;
 957                 }
 958                 else if (CommonCommand_macro_usage(argc, this))  // Instead of trying to call a command, we're going to see detailed information about it
 959                 {
 960                         return;
 961                 }
 962                 else if (ClientCommand_macro_usage(argc, this))  // same, but for normal commands now
 963                 {
 964                         return;
 965                 }
 966         }
 967         else if (MUTATOR_CALLHOOK(SV_ParseClientCommand, this, strtolower(argv(0)), argc, command))
 968         {
 969                 return;  // handled by a mutator
 970         }
 971         else if (CheatCommand(this, argc))
 972         {
 973                 return;  // handled by server/cheats.qc
 974         }
 975         else if (CommonCommand_macro_command(argc, this, command))
 976         {
 977                 return;                                          // handled by server/command/common.qc
 978         }
 979         else if (ClientCommand_macro_command(argc, this, command)) // continue as usual and scan for normal commands
 980         {
 981                 return;                                          // handled by one of the above ClientCommand_* functions
 982         }
 983         else
 984         {
 985                 clientcommand(this, command);
 986         }
 987 }