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