host_cmd.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22
  23 int current_skill;
  24 cvar_t sv_cheats = {0, "sv_cheats", "0", "enables cheat commands in any game, and cheat impulses in dpmod"};
  25 qboolean allowcheats = false;
  26
  27 /*
  28 ==================
  29 Host_Quit_f
  30 ==================
  31 */
  32
  33 void Host_Quit_f (void)
  34 {
  35         Sys_Quit ();
  36 }
  37
  38
  39 /*
  40 ==================
  41 Host_Status_f
  42 ==================
  43 */
  44 void Host_Status_f (void)
  45 {
  46         client_t *client;
  47         int seconds, minutes, hours = 0, j, players;
  48         void (*print) (const char *fmt, ...);
  49
  50         if (cmd_source == src_command)
  51         {
  52                 if (!sv.active)
  53                 {
  54                         Cmd_ForwardToServer ();
  55                         return;
  56                 }
  57                 print = Con_Printf;
  58         }
  59         else
  60                 print = SV_ClientPrintf;
  61
  62         for (players = 0, j = 0;j < svs.maxclients;j++)
  63                 if (svs.clients[j].active)
  64                         players++;
  65         print ("host:     %s\n", Cvar_VariableString ("hostname"));
  66         print ("version:  %s build %s\n", gamename, buildstring);
  67         print ("protocol: %i (%s)\n", Protocol_NumberForEnum(sv.protocol), Protocol_NameForEnum(sv.protocol));
  68         print ("map:      %s\n", sv.name);
  69         print ("players:  %i active (%i max)\n\n", players, svs.maxclients);
  70         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
  71         {
  72                 if (!client->active)
  73                         continue;
  74                 seconds = (int)(realtime - client->connecttime);
  75                 minutes = seconds / 60;
  76                 if (minutes)
  77                 {
  78                         seconds -= (minutes * 60);
  79                         hours = minutes / 60;
  80                         if (hours)
  81                                 minutes -= (hours * 60);
  82                 }
  83                 else
  84                         hours = 0;
  85                 print ("#%-2u %-16.16s  %3i  %2i:%02i:%02i\n", j+1, client->name, (int)client->edict->fields.server->frags, hours, minutes, seconds);
  86                 print ("   %s\n", client->netconnection ? client->netconnection->address : "botclient");
  87         }
  88 }
  89
  90
  91 /*
  92 ==================
  93 Host_God_f
  94
  95 Sets client to godmode
  96 ==================
  97 */
  98 void Host_God_f (void)
  99 {
 100         if (cmd_source == src_command)
 101         {
 102                 Cmd_ForwardToServer ();
 103                 return;
 104         }
 105
 106         if (!allowcheats)
 107         {
 108                 SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
 109                 return;
 110         }
 111
 112         host_client->edict->fields.server->flags = (int)host_client->edict->fields.server->flags ^ FL_GODMODE;
 113         if (!((int)host_client->edict->fields.server->flags & FL_GODMODE) )
 114                 SV_ClientPrint("godmode OFF\n");
 115         else
 116                 SV_ClientPrint("godmode ON\n");
 117 }
 118
 119 void Host_Notarget_f (void)
 120 {
 121         if (cmd_source == src_command)
 122         {
 123                 Cmd_ForwardToServer ();
 124                 return;
 125         }
 126
 127         if (!allowcheats)
 128         {
 129                 SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
 130                 return;
 131         }
 132
 133         host_client->edict->fields.server->flags = (int)host_client->edict->fields.server->flags ^ FL_NOTARGET;
 134         if (!((int)host_client->edict->fields.server->flags & FL_NOTARGET) )
 135                 SV_ClientPrint("notarget OFF\n");
 136         else
 137                 SV_ClientPrint("notarget ON\n");
 138 }
 139
 140 qboolean noclip_anglehack;
 141
 142 void Host_Noclip_f (void)
 143 {
 144         if (cmd_source == src_command)
 145         {
 146                 Cmd_ForwardToServer ();
 147                 return;
 148         }
 149
 150         if (!allowcheats)
 151         {
 152                 SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
 153                 return;
 154         }
 155
 156         if (host_client->edict->fields.server->movetype != MOVETYPE_NOCLIP)
 157         {
 158                 noclip_anglehack = true;
 159                 host_client->edict->fields.server->movetype = MOVETYPE_NOCLIP;
 160                 SV_ClientPrint("noclip ON\n");
 161         }
 162         else
 163         {
 164                 noclip_anglehack = false;
 165                 host_client->edict->fields.server->movetype = MOVETYPE_WALK;
 166                 SV_ClientPrint("noclip OFF\n");
 167         }
 168 }
 169
 170 /*
 171 ==================
 172 Host_Fly_f
 173
 174 Sets client to flymode
 175 ==================
 176 */
 177 void Host_Fly_f (void)
 178 {
 179         if (cmd_source == src_command)
 180         {
 181                 Cmd_ForwardToServer ();
 182                 return;
 183         }
 184
 185         if (!allowcheats)
 186         {
 187                 SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
 188                 return;
 189         }
 190
 191         if (host_client->edict->fields.server->movetype != MOVETYPE_FLY)
 192         {
 193                 host_client->edict->fields.server->movetype = MOVETYPE_FLY;
 194                 SV_ClientPrint("flymode ON\n");
 195         }
 196         else
 197         {
 198                 host_client->edict->fields.server->movetype = MOVETYPE_WALK;
 199                 SV_ClientPrint("flymode OFF\n");
 200         }
 201 }
 202
 203
 204 /*
 205 ==================
 206 Host_Ping_f
 207
 208 ==================
 209 */
 210 void Host_Ping_f (void)
 211 {
 212         int i;
 213         client_t *client;
 214         void (*print) (const char *fmt, ...);
 215
 216         if (cmd_source == src_command)
 217         {
 218                 if (!sv.active)
 219                 {
 220                         Cmd_ForwardToServer ();
 221                         return;
 222                 }
 223                 print = Con_Printf;
 224         }
 225         else
 226                 print = SV_ClientPrintf;
 227
 228         print("Client ping times:\n");
 229         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
 230         {
 231                 if (!client->active)
 232                         continue;
 233                 print("%4i %s\n", (int)floor(client->ping*1000+0.5), client->name);
 234         }
 235 }
 236
 237 /*
 238 ===============================================================================
 239
 240 SERVER TRANSITIONS
 241
 242 ===============================================================================
 243 */
 244
 245 /*
 246 ======================
 247 Host_Map_f
 248
 249 handle a
 250 map <servername>
 251 command from the console.  Active clients are kicked off.
 252 ======================
 253 */
 254 void Host_Map_f (void)
 255 {
 256         char level[MAX_QPATH];
 257
 258         if (Cmd_Argc() != 2)
 259         {
 260                 Con_Print("map <levelname> : start a new game (kicks off all players)\n");
 261                 return;
 262         }
 263
 264         if (cmd_source != src_command)
 265                 return;
 266
 267         cls.demonum = -1;               // stop demo loop in case this fails
 268
 269         CL_Disconnect ();
 270         Host_ShutdownServer();
 271
 272         // remove console or menu
 273         key_dest = key_game;
 274         key_consoleactive = 0;
 275
 276         svs.serverflags = 0;                    // haven't completed an episode yet
 277         allowcheats = sv_cheats.integer != 0;
 278         strcpy(level, Cmd_Argv(1));
 279         SV_SpawnServer(level);
 280         if (sv.active && cls.state == ca_disconnected)
 281         {
 282                 SV_VM_Begin();
 283                 CL_EstablishConnection("local:1");
 284                 SV_VM_End();
 285         }
 286 }
 287
 288 /*
 289 ==================
 290 Host_Changelevel_f
 291
 292 Goes to a new map, taking all clients along
 293 ==================
 294 */
 295 void Host_Changelevel_f (void)
 296 {
 297         char level[MAX_QPATH];
 298
 299         if (Cmd_Argc() != 2)
 300         {
 301                 Con_Print("changelevel <levelname> : continue game on a new level\n");
 302                 return;
 303         }
 304         // HACKHACKHACK
 305         if (!sv.active) {
 306                 Host_Map_f();
 307                 return;
 308         }
 309         if (cls.demoplayback)
 310         {
 311                 Con_Print("Only the server may changelevel\n");
 312                 return;
 313         }
 314         if (cmd_source != src_command)
 315                 return;
 316
 317         // remove console or menu
 318         key_dest = key_game;
 319         key_consoleactive = 0;
 320
 321         SV_VM_Begin();
 322         SV_SaveSpawnparms ();
 323         SV_VM_End();
 324         allowcheats = sv_cheats.integer != 0;
 325         strcpy(level, Cmd_Argv(1));
 326         SV_SpawnServer(level);
 327         if (sv.active && cls.state == ca_disconnected)
 328         {
 329                 SV_VM_Begin();
 330                 CL_EstablishConnection("local:1");
 331                 SV_VM_End();
 332         }
 333 }
 334
 335 /*
 336 ==================
 337 Host_Restart_f
 338
 339 Restarts the current server for a dead player
 340 ==================
 341 */
 342 void Host_Restart_f (void)
 343 {
 344         char mapname[MAX_QPATH];
 345
 346         if (Cmd_Argc() != 1)
 347         {
 348                 Con_Print("restart : restart current level\n");
 349                 return;
 350         }
 351         if (!sv.active || cls.demoplayback)
 352         {
 353                 Con_Print("Only the server may restart\n");
 354                 return;
 355         }
 356         if (cmd_source != src_command)
 357                 return;
 358
 359         // remove console or menu
 360         key_dest = key_game;
 361         key_consoleactive = 0;
 362
 363         allowcheats = sv_cheats.integer != 0;
 364         strcpy(mapname, sv.name);
 365         SV_SpawnServer(mapname);
 366         if (sv.active && cls.state == ca_disconnected)
 367         {
 368                 SV_VM_Begin();
 369                 CL_EstablishConnection("local:1");
 370                 SV_VM_End();
 371         }
 372 }
 373
 374 /*
 375 ==================
 376 Host_Reconnect_f
 377
 378 This command causes the client to wait for the signon messages again.
 379 This is sent just before a server changes levels
 380 ==================
 381 */
 382 void Host_Reconnect_f (void)
 383 {
 384         if (cmd_source == src_command)
 385         {
 386                 Con_Print("reconnect is not valid from the console\n");
 387                 return;
 388         }
 389         if (Cmd_Argc() != 1)
 390         {
 391                 Con_Print("reconnect : wait for signon messages again\n");
 392                 return;
 393         }
 394         if (!cls.signon)
 395         {
 396                 //Con_Print("reconnect: no signon, ignoring reconnect\n");
 397                 return;
 398         }
 399         cls.signon = 0;         // need new connection messages
 400 }
 401
 402 /*
 403 =====================
 404 Host_Connect_f
 405
 406 User command to connect to server
 407 =====================
 408 */
 409 void Host_Connect_f (void)
 410 {
 411         if (Cmd_Argc() != 2)
 412         {
 413                 Con_Print("connect <serveraddress> : connect to a multiplayer game\n");
 414                 return;
 415         }
 416         if( sv.active ) {
 417                 SV_VM_Begin();
 418                 CL_EstablishConnection(Cmd_Argv(1));
 419                 SV_VM_End();
 420         } else {
 421                 CL_EstablishConnection(Cmd_Argv(1));
 422         }
 423 }
 424
 425
 426 /*
 427 ===============================================================================
 428
 429 LOAD / SAVE GAME
 430
 431 ===============================================================================
 432 */
 433
 434 #define SAVEGAME_VERSION        5
 435
 436 /*
 437 ===============
 438 Host_SavegameComment
 439
 440 Writes a SAVEGAME_COMMENT_LENGTH character comment describing the current
 441 ===============
 442 */
 443 void Host_SavegameComment (char *text)
 444 {
 445         int             i;
 446         char    kills[20];
 447
 448         for (i=0 ; i<SAVEGAME_COMMENT_LENGTH ; i++)
 449                 text[i] = ' ';
 450         // LordHavoc: added min() to prevent overflow
 451         memcpy (text, cl.levelname, min(strlen(cl.levelname), SAVEGAME_COMMENT_LENGTH));
 452         sprintf (kills,"kills:%3i/%3i", cl.stats[STAT_MONSTERS], cl.stats[STAT_TOTALMONSTERS]);
 453         memcpy (text+22, kills, strlen(kills));
 454         // convert space to _ to make stdio happy
 455         // LordHavoc: convert control characters to _ as well
 456         for (i=0 ; i<SAVEGAME_COMMENT_LENGTH ; i++)
 457                 if (text[i] <= ' ')
 458                         text[i] = '_';
 459         text[SAVEGAME_COMMENT_LENGTH] = '\0';
 460 }
 461
 462
 463 /*
 464 ===============
 465 Host_Savegame_f
 466 ===============
 467 */
 468 void Host_Savegame_f (void)
 469 {
 470         char    name[MAX_QPATH];
 471         qfile_t *f;
 472         int             i;
 473         char    comment[SAVEGAME_COMMENT_LENGTH+1];
 474
 475         if (cmd_source != src_command)
 476                 return;
 477
 478         if (cls.state != ca_connected || !sv.active)
 479         {
 480                 Con_Print("Not playing a local game.\n");
 481                 return;
 482         }
 483
 484         if (cl.intermission)
 485         {
 486                 Con_Print("Can't save in intermission.\n");
 487                 return;
 488         }
 489
 490         for (i = 0;i < svs.maxclients;i++)
 491         {
 492                 if (svs.clients[i].active)
 493                 {
 494                         if (i > 0)
 495                         {
 496                                 Con_Print("Can't save multiplayer games.\n");
 497                                 return;
 498                         }
 499                         if (svs.clients[i].edict->fields.server->deadflag)
 500                         {
 501                                 Con_Print("Can't savegame with a dead player\n");
 502                                 return;
 503                         }
 504                 }
 505         }
 506
 507         if (Cmd_Argc() != 2)
 508         {
 509                 Con_Print("save <savename> : save a game\n");
 510                 return;
 511         }
 512
 513         if (strstr(Cmd_Argv(1), ".."))
 514         {
 515                 Con_Print("Relative pathnames are not allowed.\n");
 516                 return;
 517         }
 518
 519         strlcpy (name, Cmd_Argv(1), sizeof (name));
 520         FS_DefaultExtension (name, ".sav", sizeof (name));
 521
 522         Con_Printf("Saving game to %s...\n", name);
 523         f = FS_Open (name, "wb", false, false);
 524         if (!f)
 525         {
 526                 Con_Print("ERROR: couldn't open.\n");
 527                 return;
 528         }
 529
 530         FS_Printf(f, "%i\n", SAVEGAME_VERSION);
 531         Host_SavegameComment (comment);
 532         FS_Printf(f, "%s\n", comment);
 533         for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
 534                 FS_Printf(f, "%f\n", svs.clients[0].spawn_parms[i]);
 535         FS_Printf(f, "%d\n", current_skill);
 536         FS_Printf(f, "%s\n", sv.name);
 537         FS_Printf(f, "%f\n",sv.time);
 538
 539         // write the light styles
 540         for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
 541         {
 542                 if (sv.lightstyles[i][0])
 543                         FS_Printf(f, "%s\n", sv.lightstyles[i]);
 544                 else
 545                         FS_Print(f,"m\n");
 546         }
 547
 548         SV_VM_Begin();
 549
 550         PRVM_ED_WriteGlobals (f);
 551         for (i=0 ; i<prog->num_edicts ; i++)
 552                 PRVM_ED_Write (f, PRVM_EDICT_NUM(i));
 553
 554         SV_VM_End();
 555
 556         FS_Close (f);
 557         Con_Print("done.\n");
 558 }
 559
 560
 561 /*
 562 ===============
 563 Host_Loadgame_f
 564 ===============
 565 */
 566 void Host_Loadgame_f (void)
 567 {
 568         char filename[MAX_QPATH];
 569         char mapname[MAX_QPATH];
 570         float time;
 571         const char *start;
 572         const char *t;
 573         const char *oldt;
 574         char *text;
 575         prvm_edict_t *ent;
 576         int i;
 577         int entnum;
 578         int version;
 579         float spawn_parms[NUM_SPAWN_PARMS];
 580
 581         if (cmd_source != src_command)
 582                 return;
 583
 584         if (Cmd_Argc() != 2)
 585         {
 586                 Con_Print("load <savename> : load a game\n");
 587                 return;
 588         }
 589
 590         strcpy (filename, Cmd_Argv(1));
 591         FS_DefaultExtension (filename, ".sav", sizeof (filename));
 592
 593         Con_Printf("Loading game from %s...\n", filename);
 594
 595         cls.demonum = -1;               // stop demo loop in case this fails
 596
 597         t = text = (char *)FS_LoadFile (filename, tempmempool, false, NULL);
 598         if (!text)
 599         {
 600                 Con_Print("ERROR: couldn't open.\n");
 601                 return;
 602         }
 603
 604         // version
 605         COM_ParseToken(&t, false);
 606         version = atoi(com_token);
 607         if (version != SAVEGAME_VERSION)
 608         {
 609                 Mem_Free(text);
 610                 Con_Printf("Savegame is version %i, not %i\n", version, SAVEGAME_VERSION);
 611                 return;
 612         }
 613
 614         // description
 615         // this is a little hard to parse, as : is a separator in COM_ParseToken,
 616         // so use the console parser instead
 617         COM_ParseTokenConsole(&t);
 618
 619         for (i = 0;i < NUM_SPAWN_PARMS;i++)
 620         {
 621                 COM_ParseToken(&t, false);
 622                 spawn_parms[i] = atof(com_token);
 623         }
 624         // skill
 625         COM_ParseToken(&t, false);
 626 // this silliness is so we can load 1.06 save files, which have float skill values
 627         current_skill = (int)(atof(com_token) + 0.5);
 628         Cvar_SetValue ("skill", (float)current_skill);
 629
 630         // mapname
 631         COM_ParseToken(&t, false);
 632         strcpy (mapname, com_token);
 633
 634         // time
 635         COM_ParseToken(&t, false);
 636         time = atof(com_token);
 637
 638         allowcheats = sv_cheats.integer != 0;
 639
 640         SV_SpawnServer (mapname);
 641         if (!sv.active)
 642         {
 643                 Mem_Free(text);
 644                 Con_Print("Couldn't load map\n");
 645                 return;
 646         }
 647         sv.paused = true;               // pause until all clients connect
 648         sv.loadgame = true;
 649
 650 // load the light styles
 651
 652         for (i = 0;i < MAX_LIGHTSTYLES;i++)
 653         {
 654                 // light style
 655                 oldt = t;
 656                 COM_ParseToken(&t, false);
 657                 // if this is a 64 lightstyle savegame produced by Quake, stop now
 658                 // we have to check this because darkplaces saves 256 lightstyle savegames
 659                 if (com_token[0] == '{')
 660                 {
 661                         t = oldt;
 662                         break;
 663                 }
 664                 strlcpy(sv.lightstyles[i], com_token, sizeof(sv.lightstyles[i]));
 665         }
 666
 667         // now skip everything before the first opening brace
 668         // (this is for forward compatibility, so that older versions (at
 669         // least ones with this fix) can load savegames with extra data before the
 670         // first brace, as might be produced by a later engine version)
 671         for(;;)
 672         {
 673                 oldt = t;
 674                 COM_ParseToken(&t, false);
 675                 if (com_token[0] == '{')
 676                 {
 677                         t = oldt;
 678                         break;
 679                 }
 680         }
 681
 682 // load the edicts out of the savegame file
 683         SV_VM_Begin();
 684         // -1 is the globals
 685         entnum = -1;
 686         for (;;)
 687         {
 688                 start = t;
 689                 while (COM_ParseToken(&t, false))
 690                         if (!strcmp(com_token, "}"))
 691                                 break;
 692                 if (!COM_ParseToken(&start, false))
 693                 {
 694                         // end of file
 695                         break;
 696                 }
 697                 if (strcmp(com_token,"{"))
 698                 {
 699                         Mem_Free(text);
 700                         Host_Error ("First token isn't a brace");
 701                 }
 702
 703                 if (entnum == -1)
 704                 {
 705                         // parse the global vars
 706                         PRVM_ED_ParseGlobals (start);
 707                 }
 708                 else
 709                 {
 710                         // parse an edict
 711                         if (entnum >= MAX_EDICTS)
 712                         {
 713                                 Mem_Free(text);
 714                                 Host_Error("Host_PerformLoadGame: too many edicts in save file (reached MAX_EDICTS %i)", MAX_EDICTS);
 715                         }
 716                         while (entnum >= prog->max_edicts)
 717                                 //SV_IncreaseEdicts();
 718                                 PRVM_MEM_IncreaseEdicts();
 719                         ent = PRVM_EDICT_NUM(entnum);
 720                         memset (ent->fields.server, 0, prog->progs->entityfields * 4);
 721                         ent->priv.server->free = false;
 722                         PRVM_ED_ParseEdict (start, ent);
 723
 724                         // link it into the bsp tree
 725                         if (!ent->priv.server->free)
 726                                 SV_LinkEdict (ent, false);
 727                 }
 728
 729                 entnum++;
 730         }
 731
 732         prog->num_edicts = entnum;
 733         sv.time = time;
 734
 735         for (i = 0;i < NUM_SPAWN_PARMS;i++)
 736                 svs.clients[0].spawn_parms[i] = spawn_parms[i];
 737
 738         // make sure we're connected to loopback
 739         if (cls.state == ca_disconnected || !(cls.state == ca_connected && cls.netcon != NULL && LHNETADDRESS_GetAddressType(&cls.netcon->peeraddress) == LHNETADDRESSTYPE_LOOP))
 740                 CL_EstablishConnection("local:1");
 741
 742         SV_VM_End();
 743 }
 744
 745 //============================================================================
 746
 747 /*
 748 ======================
 749 Host_Name_f
 750 ======================
 751 */
 752 cvar_t cl_name = {CVAR_SAVE, "_cl_name", "player", "internal storage cvar for current player name (changed by name command)"};
 753 void Host_Name_f (void)
 754 {
 755         int i, j;
 756         char newName[sizeof(host_client->name)];
 757
 758         if (Cmd_Argc () == 1)
 759         {
 760                 Con_Printf("\"name\" is \"%s\"\n", cl_name.string);
 761                 return;
 762         }
 763
 764         if (Cmd_Argc () == 2)
 765                 strlcpy (newName, Cmd_Argv(1), sizeof (newName));
 766         else
 767                 strlcpy (newName, Cmd_Args(), sizeof (newName));
 768
 769         for (i = 0, j = 0;newName[i];i++)
 770                 if (newName[i] != '\r' && newName[i] != '\n')
 771                         newName[j++] = newName[i];
 772         newName[j] = 0;
 773
 774         if (cmd_source == src_command)
 775         {
 776                 Cvar_Set ("_cl_name", newName);
 777                 if (cls.state == ca_connected)
 778                         Cmd_ForwardToServer ();
 779                 return;
 780         }
 781
 782         if (sv.time < host_client->nametime)
 783         {
 784                 SV_ClientPrintf("You can't change name more than once every 5 seconds!\n");
 785                 return;
 786         }
 787
 788         host_client->nametime = sv.time + 5;
 789
 790         // point the string back at updateclient->name to keep it safe
 791         strlcpy (host_client->name, newName, sizeof (host_client->name));
 792         host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
 793         if (strcmp(host_client->old_name, host_client->name))
 794         {
 795                 if (host_client->spawned)
 796                         SV_BroadcastPrintf("%s changed name to %s\n", host_client->old_name, host_client->name);
 797                 strcpy(host_client->old_name, host_client->name);
 798                 // send notification to all clients
 799                 MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
 800                 MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
 801                 MSG_WriteString (&sv.reliable_datagram, host_client->name);
 802         }
 803 }
 804
 805 /*
 806 ======================
 807 Host_Playermodel_f
 808 ======================
 809 */
 810 cvar_t cl_playermodel = {CVAR_SAVE, "_cl_playermodel", "", "internal storage cvar for current player model in Nexuiz (changed by playermodel command)"};
 811 // the old cl_playermodel in cl_main has been renamed to __cl_playermodel
 812 void Host_Playermodel_f (void)
 813 {
 814         int i, j;
 815         char newPath[sizeof(host_client->playermodel)];
 816
 817         if (Cmd_Argc () == 1)
 818         {
 819                 Con_Printf("\"playermodel\" is \"%s\"\n", cl_playermodel.string);
 820                 return;
 821         }
 822
 823         if (Cmd_Argc () == 2)
 824                 strlcpy (newPath, Cmd_Argv(1), sizeof (newPath));
 825         else
 826                 strlcpy (newPath, Cmd_Args(), sizeof (newPath));
 827
 828         for (i = 0, j = 0;newPath[i];i++)
 829                 if (newPath[i] != '\r' && newPath[i] != '\n')
 830                         newPath[j++] = newPath[i];
 831         newPath[j] = 0;
 832
 833         if (cmd_source == src_command)
 834         {
 835                 Cvar_Set ("_cl_playermodel", newPath);
 836                 if (cls.state == ca_connected)
 837                         Cmd_ForwardToServer ();
 838                 return;
 839         }
 840
 841         /*
 842         if (sv.time < host_client->nametime)
 843         {
 844                 SV_ClientPrintf("You can't change playermodel more than once every 5 seconds!\n");
 845                 return;
 846         }
 847
 848         host_client->nametime = sv.time + 5;
 849         */
 850
 851         // point the string back at updateclient->name to keep it safe
 852         strlcpy (host_client->playermodel, newPath, sizeof (host_client->playermodel));
 853         if( eval_playermodel )
 854                 PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
 855         if (strcmp(host_client->old_model, host_client->playermodel))
 856         {
 857                 strcpy(host_client->old_model, host_client->playermodel);
 858                 /*// send notification to all clients
 859                 MSG_WriteByte (&sv.reliable_datagram, svc_updatepmodel);
 860                 MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
 861                 MSG_WriteString (&sv.reliable_datagram, host_client->playermodel);*/
 862         }
 863 }
 864
 865 /*
 866 ======================
 867 Host_Playerskin_f
 868 ======================
 869 */
 870 cvar_t cl_playerskin = {CVAR_SAVE, "_cl_playerskin", "", "internal storage cvar for current player skin in Nexuiz (changed by playerskin command)"};
 871 void Host_Playerskin_f (void)
 872 {
 873         int i, j;
 874         char newPath[sizeof(host_client->playerskin)];
 875
 876         if (Cmd_Argc () == 1)
 877         {
 878                 Con_Printf("\"playerskin\" is \"%s\"\n", cl_playerskin.string);
 879                 return;
 880         }
 881
 882         if (Cmd_Argc () == 2)
 883                 strlcpy (newPath, Cmd_Argv(1), sizeof (newPath));
 884         else
 885                 strlcpy (newPath, Cmd_Args(), sizeof (newPath));
 886
 887         for (i = 0, j = 0;newPath[i];i++)
 888                 if (newPath[i] != '\r' && newPath[i] != '\n')
 889                         newPath[j++] = newPath[i];
 890         newPath[j] = 0;
 891
 892         if (cmd_source == src_command)
 893         {
 894                 Cvar_Set ("_cl_playerskin", newPath);
 895                 if (cls.state == ca_connected)
 896                         Cmd_ForwardToServer ();
 897                 return;
 898         }
 899
 900         /*
 901         if (sv.time < host_client->nametime)
 902         {
 903                 SV_ClientPrintf("You can't change playermodel more than once every 5 seconds!\n");
 904                 return;
 905         }
 906
 907         host_client->nametime = sv.time + 5;
 908         */
 909
 910         // point the string back at updateclient->name to keep it safe
 911         strlcpy (host_client->playerskin, newPath, sizeof (host_client->playerskin));
 912         if( eval_playerskin )
 913                 PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
 914         if (strcmp(host_client->old_skin, host_client->playerskin))
 915         {
 916                 if (host_client->spawned)
 917                         SV_BroadcastPrintf("%s changed skin to %s\n", host_client->name, host_client->playerskin);
 918                 strcpy(host_client->old_skin, host_client->playerskin);
 919                 /*// send notification to all clients
 920                 MSG_WriteByte (&sv.reliable_datagram, svc_updatepskin);
 921                 MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
 922                 MSG_WriteString (&sv.reliable_datagram, host_client->playerskin);*/
 923         }
 924 }
 925
 926 void Host_Version_f (void)
 927 {
 928         Con_Printf("Version: %s build %s\n", gamename, buildstring);
 929 }
 930
 931 void Host_Say(qboolean teamonly)
 932 {
 933         client_t *save;
 934         int j, quoted;
 935         const char *p1;
 936         char *p2;
 937         // LordHavoc: long say messages
 938         char text[1024];
 939         qboolean fromServer = false;
 940
 941         if (cmd_source == src_command)
 942         {
 943                 if (cls.state == ca_dedicated)
 944                 {
 945                         fromServer = true;
 946                         teamonly = false;
 947                 }
 948                 else
 949                 {
 950                         Cmd_ForwardToServer ();
 951                         return;
 952                 }
 953         }
 954
 955         if (Cmd_Argc () < 2)
 956                 return;
 957
 958         if (!teamplay.integer)
 959                 teamonly = false;
 960
 961 // turn on color set 1
 962         p1 = Cmd_Args();
 963         quoted = false;
 964         if (*p1 == '\"')
 965         {
 966                 quoted = true;
 967                 p1++;
 968         }
 969         if (!fromServer)
 970                 dpsnprintf (text, sizeof(text), "%c%s" STRING_COLOR_DEFAULT_STR ": %s", 1, host_client->name, p1);
 971         else
 972                 dpsnprintf (text, sizeof(text), "%c<%s" STRING_COLOR_DEFAULT_STR "> %s", 1, hostname.string, p1);
 973         p2 = text + strlen(text);
 974         while ((const char *)p2 > (const char *)text && (p2[-1] == '\r' || p2[-1] == '\n' || (p2[-1] == '\"' && quoted)))
 975         {
 976                 if (p2[-1] == '\"' && quoted)
 977                         quoted = false;
 978                 p2[-1] = 0;
 979                 p2--;
 980         }
 981         strlcat(text, "\n", sizeof(text));
 982
 983         // note: save is not a valid edict if fromServer is true
 984         save = host_client;
 985         for (j = 0, host_client = svs.clients;j < svs.maxclients;j++, host_client++)
 986                 if (host_client->spawned && (!teamonly || host_client->edict->fields.server->team == save->edict->fields.server->team))
 987                         SV_ClientPrint(text);
 988         host_client = save;
 989
 990         if (cls.state == ca_dedicated)
 991                 Con_Print(&text[1]);
 992 }
 993
 994
 995 void Host_Say_f(void)
 996 {
 997         Host_Say(false);
 998 }
 999
1000
1001 void Host_Say_Team_f(void)
1002 {
1003         Host_Say(true);
1004 }
1005
1006
1007 void Host_Tell_f(void)
1008 {
1009         client_t *save;
1010         int j;
1011         const char *p1, *p2;
1012         char text[MAX_INPUTLINE]; // LordHavoc: FIXME: temporary buffer overflow fix (was 64)
1013         qboolean fromServer = false;
1014
1015         if (cmd_source == src_command)
1016         {
1017                 if (cls.state == ca_dedicated)
1018                         fromServer = true;
1019                 else
1020                 {
1021                         Cmd_ForwardToServer ();
1022                         return;
1023                 }
1024         }
1025
1026         if (Cmd_Argc () < 3)
1027                 return;
1028
1029         if (!fromServer)
1030                 sprintf (text, "%s: ", host_client->name);
1031         else
1032                 sprintf (text, "<%s> ", hostname.string);
1033
1034         p1 = Cmd_Args();
1035         p2 = p1 + strlen(p1);
1036         // remove the target name
1037         while (p1 < p2 && *p1 != ' ')
1038                 p1++;
1039         while (p1 < p2 && *p1 == ' ')
1040                 p1++;
1041         // remove trailing newlines
1042         while (p2 > p1 && (p2[-1] == '\n' || p2[-1] == '\r'))
1043                 p2--;
1044         // remove quotes if present
1045         if (*p1 == '"')
1046         {
1047                 p1++;
1048                 if (p2[-1] == '"')
1049                         p2--;
1050                 else if (fromServer)
1051                         Con_Print("Host_Tell: missing end quote\n");
1052                 else
1053                         SV_ClientPrint("Host_Tell: missing end quote\n");
1054         }
1055         while (p2 > p1 && (p2[-1] == '\n' || p2[-1] == '\r'))
1056                 p2--;
1057         for (j = (int)strlen(text);j < (int)(sizeof(text) - 2) && p1 < p2;)
1058                 text[j++] = *p1++;
1059         text[j++] = '\n';
1060         text[j++] = 0;
1061
1062         save = host_client;
1063         for (j = 0, host_client = svs.clients;j < svs.maxclients;j++, host_client++)
1064                 if (host_client->spawned && !strcasecmp(host_client->name, Cmd_Argv(1)))
1065                         SV_ClientPrint(text);
1066         host_client = save;
1067 }
1068
1069
1070 /*
1071 ==================
1072 Host_Color_f
1073 ==================
1074 */
1075 cvar_t cl_color = {CVAR_SAVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"};
1076 void Host_Color_f(void)
1077 {
1078         int             top, bottom;
1079         int             playercolor;
1080         mfunction_t *f;
1081         func_t  SV_ChangeTeam;
1082
1083         if (Cmd_Argc() == 1)
1084         {
1085                 Con_Printf("\"color\" is \"%i %i\"\n", cl_color.integer >> 4, cl_color.integer & 15);
1086                 Con_Print("color <0-15> [0-15]\n");
1087                 return;
1088         }
1089
1090         if (Cmd_Argc() == 2)
1091                 top = bottom = atoi(Cmd_Argv(1));
1092         else
1093         {
1094                 top = atoi(Cmd_Argv(1));
1095                 bottom = atoi(Cmd_Argv(2));
1096         }
1097
1098         top &= 15;
1099         // LordHavoc: allow skin colormaps 14 and 15 (was 13)
1100         if (top > 15)
1101                 top = 15;
1102         bottom &= 15;
1103         // LordHavoc: allow skin colormaps 14 and 15 (was 13)
1104         if (bottom > 15)
1105                 bottom = 15;
1106
1107         playercolor = top*16 + bottom;
1108
1109         if (cmd_source == src_command)
1110         {
1111                 Cvar_SetValue ("_cl_color", playercolor);
1112                 if (cls.state == ca_connected)
1113                         Cmd_ForwardToServer ();
1114                 return;
1115         }
1116
1117         if (host_client->edict && (f = PRVM_ED_FindFunction ("SV_ChangeTeam")) && (SV_ChangeTeam = (func_t)(f - prog->functions)))
1118         {
1119                 Con_DPrint("Calling SV_ChangeTeam\n");
1120                 prog->globals.server->time = sv.time;
1121                 prog->globals.generic[OFS_PARM0] = playercolor;
1122                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1123                 PRVM_ExecuteProgram (SV_ChangeTeam, "QC function SV_ChangeTeam is missing");
1124         }
1125         else
1126         {
1127                 prvm_eval_t *val;
1128                 if (host_client->edict)
1129                 {
1130                         if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
1131                                 val->_float = playercolor;
1132                         host_client->edict->fields.server->team = bottom + 1;
1133                 }
1134                 host_client->colors = playercolor;
1135                 if (host_client->old_colors != host_client->colors)
1136                 {
1137                         host_client->old_colors = host_client->colors;
1138                         // send notification to all clients
1139                         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1140                         MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
1141                         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1142                 }
1143         }
1144 }
1145
1146 cvar_t cl_rate = {CVAR_SAVE, "_cl_rate", "10000", "internal storage cvar for current rate (changed by rate command)"};
1147 void Host_Rate_f(void)
1148 {
1149         int rate;
1150
1151         if (Cmd_Argc() != 2)
1152         {
1153                 Con_Printf("\"rate\" is \"%i\"\n", cl_rate.integer);
1154                 Con_Print("rate <500-25000>\n");
1155                 return;
1156         }
1157
1158         rate = atoi(Cmd_Argv(1));
1159
1160         if (cmd_source == src_command)
1161         {
1162                 Cvar_SetValue ("_cl_rate", bound(NET_MINRATE, rate, NET_MAXRATE));
1163                 if (cls.state == ca_connected)
1164                         Cmd_ForwardToServer ();
1165                 return;
1166         }
1167
1168         host_client->rate = rate;
1169 }
1170
1171 /*
1172 ==================
1173 Host_Kill_f
1174 ==================
1175 */
1176 void Host_Kill_f (void)
1177 {
1178         if (cmd_source == src_command)
1179         {
1180                 Cmd_ForwardToServer ();
1181                 return;
1182         }
1183
1184         if (host_client->edict->fields.server->health <= 0)
1185         {
1186                 SV_ClientPrint("Can't suicide -- already dead!\n");
1187                 return;
1188         }
1189
1190         prog->globals.server->time = sv.time;
1191         prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1192         PRVM_ExecuteProgram (prog->globals.server->ClientKill, "QC function ClientKill is missing");
1193 }
1194
1195
1196 /*
1197 ==================
1198 Host_Pause_f
1199 ==================
1200 */
1201 void Host_Pause_f (void)
1202 {
1203
1204         if (cmd_source == src_command)
1205         {
1206                 Cmd_ForwardToServer ();
1207                 return;
1208         }
1209         if (!pausable.integer)
1210                 SV_ClientPrint("Pause not allowed.\n");
1211         else
1212         {
1213                 sv.paused ^= 1;
1214                 SV_BroadcastPrintf("%s %spaused the game\n", host_client->name, sv.paused ? "" : "un");
1215                 // send notification to all clients
1216                 MSG_WriteByte(&sv.reliable_datagram, svc_setpause);
1217                 MSG_WriteByte(&sv.reliable_datagram, sv.paused);
1218         }
1219 }
1220
1221 /*
1222 ======================
1223 Host_PModel_f
1224 LordHavoc: only supported for Nehahra, I personally think this is dumb, but Mindcrime won't listen.
1225 LordHavoc: correction, Mindcrime will be removing pmodel in the future, but it's still stuck here for compatibility.
1226 ======================
1227 */
1228 cvar_t cl_pmodel = {CVAR_SAVE, "_cl_pmodel", "0", "internal storage cvar for current player model number in nehahra (changed by pmodel command)"};
1229 static void Host_PModel_f (void)
1230 {
1231         int i;
1232         prvm_eval_t *val;
1233
1234         if (Cmd_Argc () == 1)
1235         {
1236                 Con_Printf("\"pmodel\" is \"%s\"\n", cl_pmodel.string);
1237                 return;
1238         }
1239         i = atoi(Cmd_Argv(1));
1240
1241         if (cmd_source == src_command)
1242         {
1243                 if (cl_pmodel.integer == i)
1244                         return;
1245                 Cvar_SetValue ("_cl_pmodel", i);
1246                 if (cls.state == ca_connected)
1247                         Cmd_ForwardToServer ();
1248                 return;
1249         }
1250
1251         if (host_client->edict && (val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_pmodel)))
1252                 val->_float = i;
1253 }
1254
1255 //===========================================================================
1256
1257
1258 /*
1259 ==================
1260 Host_PreSpawn_f
1261 ==================
1262 */
1263 void Host_PreSpawn_f (void)
1264 {
1265         if (cmd_source == src_command)
1266         {
1267                 Con_Print("prespawn is not valid from the console\n");
1268                 return;
1269         }
1270
1271         if (host_client->spawned)
1272         {
1273                 Con_Print("prespawn not valid -- already spawned\n");
1274                 return;
1275         }
1276
1277         if (host_client->netconnection)
1278         {
1279                 SZ_Write (&host_client->netconnection->message, sv.signon.data, sv.signon.cursize);
1280                 MSG_WriteByte (&host_client->netconnection->message, svc_signonnum);
1281                 MSG_WriteByte (&host_client->netconnection->message, 2);
1282         }
1283         host_client->sendsignon = true;
1284
1285         // reset the name change timer because the client will send name soon
1286         host_client->nametime = 0;
1287 }
1288
1289 /*
1290 ==================
1291 Host_Spawn_f
1292 ==================
1293 */
1294 void Host_Spawn_f (void)
1295 {
1296         int i;
1297         client_t *client;
1298         func_t RestoreGame;
1299         mfunction_t *f;
1300         int stats[MAX_CL_STATS];
1301
1302         if (cmd_source == src_command)
1303         {
1304                 Con_Print("spawn is not valid from the console\n");
1305                 return;
1306         }
1307
1308         if (host_client->spawned)
1309         {
1310                 Con_Print("Spawn not valid -- already spawned\n");
1311                 return;
1312         }
1313
1314         // reset name change timer again because they might want to change name
1315         // again in the first 5 seconds after connecting
1316         host_client->nametime = 0;
1317
1318         // LordHavoc: moved this above the QC calls at FrikaC's request
1319         // LordHavoc: commented this out
1320         //if (host_client->netconnection)
1321         //      SZ_Clear (&host_client->netconnection->message);
1322
1323         // run the entrance script
1324         if (sv.loadgame)
1325         {
1326                 // loaded games are fully initialized already
1327                 // if this is the last client to be connected, unpause
1328                 sv.paused = false;
1329
1330                 if ((f = PRVM_ED_FindFunction ("RestoreGame")))
1331                 if ((RestoreGame = (func_t)(f - prog->functions)))
1332                 {
1333                         Con_DPrint("Calling RestoreGame\n");
1334                         prog->globals.server->time = sv.time;
1335                         prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1336                         PRVM_ExecuteProgram (RestoreGame, "QC function RestoreGame is missing");
1337                 }
1338         }
1339         else
1340         {
1341                 //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PRVM_GetString(host_client->edict->fields.server->netname), PRVM_GetString(host_client->edict->fields.server->netname), host_client->name);
1342
1343                 // copy spawn parms out of the client_t
1344                 for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1345                         (&prog->globals.server->parm1)[i] = host_client->spawn_parms[i];
1346
1347                 // call the spawn function
1348                 host_client->clientconnectcalled = true;
1349                 prog->globals.server->time = sv.time;
1350                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1351                 PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
1352
1353                 if ((Sys_DoubleTime() - host_client->connecttime) <= sv.time)
1354                         Con_Printf("%s entered the game\n", host_client->name);
1355
1356                 PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
1357         }
1358
1359         host_client->sendsignon = true;
1360
1361         if (!host_client->netconnection)
1362                 return;
1363
1364         // send time of update
1365         MSG_WriteByte (&host_client->netconnection->message, svc_time);
1366         MSG_WriteFloat (&host_client->netconnection->message, sv.time);
1367
1368         // send all current names, colors, and frag counts
1369         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1370         {
1371                 if (!client->active)
1372                         continue;
1373                 MSG_WriteByte (&host_client->netconnection->message, svc_updatename);
1374                 MSG_WriteByte (&host_client->netconnection->message, i);
1375                 MSG_WriteString (&host_client->netconnection->message, client->name);
1376                 MSG_WriteByte (&host_client->netconnection->message, svc_updatefrags);
1377                 MSG_WriteByte (&host_client->netconnection->message, i);
1378                 MSG_WriteShort (&host_client->netconnection->message, client->frags);
1379                 MSG_WriteByte (&host_client->netconnection->message, svc_updatecolors);
1380                 MSG_WriteByte (&host_client->netconnection->message, i);
1381                 MSG_WriteByte (&host_client->netconnection->message, client->colors);
1382         }
1383
1384         // send all current light styles
1385         for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
1386         {
1387                 if (sv.lightstyles[i][0])
1388                 {
1389                         MSG_WriteByte (&host_client->netconnection->message, svc_lightstyle);
1390                         MSG_WriteByte (&host_client->netconnection->message, (char)i);
1391                         MSG_WriteString (&host_client->netconnection->message, sv.lightstyles[i]);
1392                 }
1393         }
1394
1395         // send some stats
1396         MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
1397         MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALSECRETS);
1398         MSG_WriteLong (&host_client->netconnection->message, prog->globals.server->total_secrets);
1399
1400         MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
1401         MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALMONSTERS);
1402         MSG_WriteLong (&host_client->netconnection->message, prog->globals.server->total_monsters);
1403
1404         MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
1405         MSG_WriteByte (&host_client->netconnection->message, STAT_SECRETS);
1406         MSG_WriteLong (&host_client->netconnection->message, prog->globals.server->found_secrets);
1407
1408         MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
1409         MSG_WriteByte (&host_client->netconnection->message, STAT_MONSTERS);
1410         MSG_WriteLong (&host_client->netconnection->message, prog->globals.server->killed_monsters);
1411
1412         // send a fixangle
1413         // Never send a roll angle, because savegames can catch the server
1414         // in a state where it is expecting the client to correct the angle
1415         // and it won't happen if the game was just loaded, so you wind up
1416         // with a permanent head tilt
1417         MSG_WriteByte (&host_client->netconnection->message, svc_setangle);
1418         MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->angles[0], sv.protocol);
1419         MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->angles[1], sv.protocol);
1420         MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
1421
1422         SV_WriteClientdataToMessage (host_client, host_client->edict, &host_client->netconnection->message, stats);
1423
1424         MSG_WriteByte (&host_client->netconnection->message, svc_signonnum);
1425         MSG_WriteByte (&host_client->netconnection->message, 3);
1426 }
1427
1428 /*
1429 ==================
1430 Host_Begin_f
1431 ==================
1432 */
1433 void Host_Begin_f (void)
1434 {
1435         if (cmd_source == src_command)
1436         {
1437                 Con_Print("begin is not valid from the console\n");
1438                 return;
1439         }
1440
1441         host_client->spawned = true;
1442 }
1443
1444 //===========================================================================
1445
1446
1447 /*
1448 ==================
1449 Host_Kick_f
1450
1451 Kicks a user off of the server
1452 ==================
1453 */
1454 void Host_Kick_f (void)
1455 {
1456         char *who;
1457         const char *message = NULL;
1458         client_t *save;
1459         int i;
1460         qboolean byNumber = false;
1461
1462         if (cmd_source != src_command || !sv.active)
1463                 return;
1464
1465         SV_VM_Begin();
1466         save = host_client;
1467
1468         if (Cmd_Argc() > 2 && strcmp(Cmd_Argv(1), "#") == 0)
1469         {
1470                 i = atof(Cmd_Argv(2)) - 1;
1471                 if (i < 0 || i >= svs.maxclients || !(host_client = svs.clients + i)->active)
1472                         return;
1473                 byNumber = true;
1474         }
1475         else
1476         {
1477                 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1478                 {
1479                         if (!host_client->active)
1480                                 continue;
1481                         if (strcasecmp(host_client->name, Cmd_Argv(1)) == 0)
1482                                 break;
1483                 }
1484         }
1485
1486         if (i < svs.maxclients)
1487         {
1488                 if (cmd_source == src_command)
1489                 {
1490                         if (cls.state == ca_dedicated)
1491                                 who = "Console";
1492                         else
1493                                 who = cl_name.string;
1494                 }
1495                 else
1496                         who = save->name;
1497
1498                 // can't kick yourself!
1499                 if (host_client == save)
1500                         return;
1501
1502                 if (Cmd_Argc() > 2)
1503                 {
1504                         message = Cmd_Args();
1505                         COM_ParseToken(&message, false);
1506                         if (byNumber)
1507                         {
1508                                 message++;                                                      // skip the #
1509                                 while (*message == ' ')                         // skip white space
1510                                         message++;
1511                                 message += strlen(Cmd_Argv(2)); // skip the number
1512                         }
1513                         while (*message && *message == ' ')
1514                                 message++;
1515                 }
1516                 if (message)
1517                         SV_ClientPrintf("Kicked by %s: %s\n", who, message);
1518                 else
1519                         SV_ClientPrintf("Kicked by %s\n", who);
1520                 SV_DropClient (false); // kicked
1521         }
1522
1523         host_client = save;
1524         SV_VM_End();
1525 }
1526
1527 /*
1528 ===============================================================================
1529
1530 DEBUGGING TOOLS
1531
1532 ===============================================================================
1533 */
1534
1535 /*
1536 ==================
1537 Host_Give_f
1538 ==================
1539 */
1540 void Host_Give_f (void)
1541 {
1542         const char *t;
1543         int v;
1544         prvm_eval_t *val;
1545
1546         if (cmd_source == src_command)
1547         {
1548                 Cmd_ForwardToServer ();
1549                 return;
1550         }
1551
1552         if (!allowcheats)
1553         {
1554                 SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
1555                 return;
1556         }
1557
1558         t = Cmd_Argv(1);
1559         v = atoi (Cmd_Argv(2));
1560
1561         switch (t[0])
1562         {
1563         case '0':
1564         case '1':
1565         case '2':
1566         case '3':
1567         case '4':
1568         case '5':
1569         case '6':
1570         case '7':
1571         case '8':
1572         case '9':
1573                 // MED 01/04/97 added hipnotic give stuff
1574                 if (gamemode == GAME_HIPNOTIC)
1575                 {
1576                         if (t[0] == '6')
1577                         {
1578                                 if (t[1] == 'a')
1579                                         host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_PROXIMITY_GUN;
1580                                 else
1581                                         host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | IT_GRENADE_LAUNCHER;
1582                         }
1583                         else if (t[0] == '9')
1584                                 host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_LASER_CANNON;
1585                         else if (t[0] == '0')
1586                                 host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_MJOLNIR;
1587                         else if (t[0] >= '2')
1588                                 host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
1589                 }
1590                 else
1591                 {
1592                         if (t[0] >= '2')
1593                                 host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
1594                 }
1595                 break;
1596
1597         case 's':
1598                 if (gamemode == GAME_ROGUE && (val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_shells1)))
1599                         val->_float = v;
1600
1601                 host_client->edict->fields.server->ammo_shells = v;
1602                 break;
1603         case 'n':
1604                 if (gamemode == GAME_ROGUE)
1605                 {
1606                         if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_nails1)))
1607                         {
1608                                 val->_float = v;
1609                                 if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
1610                                         host_client->edict->fields.server->ammo_nails = v;
1611                         }
1612                 }
1613                 else
1614                 {
1615                         host_client->edict->fields.server->ammo_nails = v;
1616                 }
1617                 break;
1618         case 'l':
1619                 if (gamemode == GAME_ROGUE)
1620                 {
1621                         val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_lava_nails);
1622                         if (val)
1623                         {
1624                                 val->_float = v;
1625                                 if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
1626                                         host_client->edict->fields.server->ammo_nails = v;
1627                         }
1628                 }
1629                 break;
1630         case 'r':
1631                 if (gamemode == GAME_ROGUE)
1632                 {
1633                         val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_rockets1);
1634                         if (val)
1635                         {
1636                                 val->_float = v;
1637                                 if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
1638                                         host_client->edict->fields.server->ammo_rockets = v;
1639                         }
1640                 }
1641                 else
1642                 {
1643                         host_client->edict->fields.server->ammo_rockets = v;
1644                 }
1645                 break;
1646         case 'm':
1647                 if (gamemode == GAME_ROGUE)
1648                 {
1649                         val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_multi_rockets);
1650                         if (val)
1651                         {
1652                                 val->_float = v;
1653                                 if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
1654                                         host_client->edict->fields.server->ammo_rockets = v;
1655                         }
1656                 }
1657                 break;
1658         case 'h':
1659                 host_client->edict->fields.server->health = v;
1660                 break;
1661         case 'c':
1662                 if (gamemode == GAME_ROGUE)
1663                 {
1664                         val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_cells1);
1665                         if (val)
1666                         {
1667                                 val->_float = v;
1668                                 if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
1669                                         host_client->edict->fields.server->ammo_cells = v;
1670                         }
1671                 }
1672                 else
1673                 {
1674                         host_client->edict->fields.server->ammo_cells = v;
1675                 }
1676                 break;
1677         case 'p':
1678                 if (gamemode == GAME_ROGUE)
1679                 {
1680                         val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_plasma);
1681                         if (val)
1682                         {
1683                                 val->_float = v;
1684                                 if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
1685                                         host_client->edict->fields.server->ammo_cells = v;
1686                         }
1687                 }
1688                 break;
1689         }
1690 }
1691
1692 prvm_edict_t    *FindViewthing (void)
1693 {
1694         int             i;
1695         prvm_edict_t    *e;
1696
1697         for (i=0 ; i<prog->num_edicts ; i++)
1698         {
1699                 e = PRVM_EDICT_NUM(i);
1700                 if (!strcmp (PRVM_GetString(e->fields.server->classname), "viewthing"))
1701                         return e;
1702         }
1703         Con_Print("No viewthing on map\n");
1704         return NULL;
1705 }
1706
1707 /*
1708 ==================
1709 Host_Viewmodel_f
1710 ==================
1711 */
1712 void Host_Viewmodel_f (void)
1713 {
1714         prvm_edict_t    *e;
1715         model_t *m;
1716
1717         if (!sv.active)
1718                 return;
1719
1720         SV_VM_Begin();
1721         e = FindViewthing ();
1722         SV_VM_End();
1723         if (!e)
1724                 return;
1725
1726         m = Mod_ForName (Cmd_Argv(1), false, true, false);
1727         if (!m || !m->loaded || !m->Draw)
1728         {
1729                 Con_Printf("viewmodel: can't load %s\n", Cmd_Argv(1));
1730                 return;
1731         }
1732
1733         e->fields.server->frame = 0;
1734         cl.model_precache[(int)e->fields.server->modelindex] = m;
1735 }
1736
1737 /*
1738 ==================
1739 Host_Viewframe_f
1740 ==================
1741 */
1742 void Host_Viewframe_f (void)
1743 {
1744         prvm_edict_t    *e;
1745         int             f;
1746         model_t *m;
1747
1748         if (!sv.active)
1749                 return;
1750
1751         SV_VM_Begin();
1752         e = FindViewthing ();
1753         SV_VM_End();
1754         if (!e)
1755                 return;
1756         m = cl.model_precache[(int)e->fields.server->modelindex];
1757
1758         f = atoi(Cmd_Argv(1));
1759         if (f >= m->numframes)
1760                 f = m->numframes-1;
1761
1762         e->fields.server->frame = f;
1763 }
1764
1765
1766 void PrintFrameName (model_t *m, int frame)
1767 {
1768         if (m->animscenes)
1769                 Con_Printf("frame %i: %s\n", frame, m->animscenes[frame].name);
1770         else
1771                 Con_Printf("frame %i\n", frame);
1772 }
1773
1774 /*
1775 ==================
1776 Host_Viewnext_f
1777 ==================
1778 */
1779 void Host_Viewnext_f (void)
1780 {
1781         prvm_edict_t    *e;
1782         model_t *m;
1783
1784         if (!sv.active)
1785                 return;
1786
1787         SV_VM_Begin();
1788         e = FindViewthing ();
1789         SV_VM_End();
1790         if (!e)
1791                 return;
1792         m = cl.model_precache[(int)e->fields.server->modelindex];
1793
1794         e->fields.server->frame = e->fields.server->frame + 1;
1795         if (e->fields.server->frame >= m->numframes)
1796                 e->fields.server->frame = m->numframes - 1;
1797
1798         PrintFrameName (m, e->fields.server->frame);
1799 }
1800
1801 /*
1802 ==================
1803 Host_Viewprev_f
1804 ==================
1805 */
1806 void Host_Viewprev_f (void)
1807 {
1808         prvm_edict_t    *e;
1809         model_t *m;
1810
1811         if (!sv.active)
1812                 return;
1813
1814         SV_VM_Begin();
1815         e = FindViewthing ();
1816         SV_VM_End();
1817         if (!e)
1818                 return;
1819
1820         m = cl.model_precache[(int)e->fields.server->modelindex];
1821
1822         e->fields.server->frame = e->fields.server->frame - 1;
1823         if (e->fields.server->frame < 0)
1824                 e->fields.server->frame = 0;
1825
1826         PrintFrameName (m, e->fields.server->frame);
1827 }
1828
1829 /*
1830 ===============================================================================
1831
1832 DEMO LOOP CONTROL
1833
1834 ===============================================================================
1835 */
1836
1837
1838 /*
1839 ==================
1840 Host_Startdemos_f
1841 ==================
1842 */
1843 void Host_Startdemos_f (void)
1844 {
1845         int             i, c;
1846
1847         if (cls.state == ca_dedicated || COM_CheckParm("-listen") || COM_CheckParm("-benchmark") || COM_CheckParm("-demo") || COM_CheckParm("-demolooponly"))
1848                 return;
1849
1850         c = Cmd_Argc() - 1;
1851         if (c > MAX_DEMOS)
1852         {
1853                 Con_Printf("Max %i demos in demoloop\n", MAX_DEMOS);
1854                 c = MAX_DEMOS;
1855         }
1856         Con_Printf("%i demo(s) in loop\n", c);
1857
1858         for (i=1 ; i<c+1 ; i++)
1859                 strlcpy (cls.demos[i-1], Cmd_Argv(i), sizeof (cls.demos[i-1]));
1860
1861         // LordHavoc: clear the remaining slots
1862         for (;i <= MAX_DEMOS;i++)
1863                 cls.demos[i-1][0] = 0;
1864
1865         if (!sv.active && cls.demonum != -1 && !cls.demoplayback)
1866         {
1867                 cls.demonum = 0;
1868                 CL_NextDemo ();
1869         }
1870         else
1871                 cls.demonum = -1;
1872 }
1873
1874
1875 /*
1876 ==================
1877 Host_Demos_f
1878
1879 Return to looping demos
1880 ==================
1881 */
1882 void Host_Demos_f (void)
1883 {
1884         if (cls.state == ca_dedicated)
1885                 return;
1886         if (cls.demonum == -1)
1887                 cls.demonum = 1;
1888         CL_Disconnect_f ();
1889         CL_NextDemo ();
1890 }
1891
1892 /*
1893 ==================
1894 Host_Stopdemo_f
1895
1896 Return to looping demos
1897 ==================
1898 */
1899 void Host_Stopdemo_f (void)
1900 {
1901         if (!cls.demoplayback)
1902                 return;
1903         CL_Disconnect ();
1904         Host_ShutdownServer ();
1905 }
1906
1907 void Host_SendCvar_f (void)
1908 {
1909         int             i;
1910         cvar_t  *c;
1911         client_t *old;
1912
1913         if(Cmd_Argc() != 2)
1914                 return;
1915         if(!(c = Cvar_FindVar(Cmd_Argv(1))))
1916                 return;
1917         if (cls.state != ca_dedicated)
1918                 Cmd_ForwardStringToServer(va("sentcvar %s %s\n", c->name, c->string));
1919         if(!sv.active)// || !SV_ParseClientCommandQC)
1920                 return;
1921
1922         old = host_client;
1923         if (cls.state != ca_dedicated)
1924                 i = 1;
1925         else
1926                 i = 0;
1927         for(;i<svs.maxclients;i++)
1928                 if(svs.clients[i].active && svs.clients[i].netconnection)
1929                 {
1930                         host_client = &svs.clients[i];
1931                         Host_ClientCommands(va("sendcvar %s\n", c->name));
1932                 }
1933         host_client = old;
1934 }
1935
1936 static void MaxPlayers_f(void)
1937 {
1938         int n;
1939
1940         if (Cmd_Argc() != 2)
1941         {
1942                 Con_Printf("\"maxplayers\" is \"%u\"\n", svs.maxclients);
1943                 return;
1944         }
1945
1946         if (sv.active)
1947         {
1948                 Con_Print("maxplayers can not be changed while a server is running.\n");
1949                 return;
1950         }
1951
1952         n = atoi(Cmd_Argv(1));
1953         n = bound(1, n, MAX_SCOREBOARD);
1954         Con_Printf("\"maxplayers\" set to \"%u\"\n", n);
1955
1956         if (svs.clients)
1957                 Mem_Free(svs.clients);
1958         svs.maxclients = n;
1959         svs.clients = (client_t *)Mem_Alloc(sv_mempool, sizeof(client_t) * svs.maxclients);
1960         if (n == 1)
1961                 Cvar_Set ("deathmatch", "0");
1962         else
1963                 Cvar_Set ("deathmatch", "1");
1964 }
1965
1966 //=============================================================================
1967
1968 /*
1969 ==================
1970 Host_InitCommands
1971 ==================
1972 */
1973 void Host_InitCommands (void)
1974 {
1975         Cmd_AddCommand ("status", Host_Status_f, "print server status information");
1976         Cmd_AddCommand ("quit", Host_Quit_f, "quit the game");
1977         if (gamemode == GAME_NEHAHRA)
1978         {
1979                 Cmd_AddCommand ("max", Host_God_f, "god mode (invulnerability)");
1980                 Cmd_AddCommand ("monster", Host_Notarget_f, "notarget mode (monsters do not see you)");
1981                 Cmd_AddCommand ("scrag", Host_Fly_f, "fly mode (flight)");
1982                 Cmd_AddCommand ("wraith", Host_Noclip_f, "noclip mode (flight without collisions, move through walls)");
1983                 Cmd_AddCommand ("gimme", Host_Give_f, "alter inventory");
1984         }
1985         else
1986         {
1987                 Cmd_AddCommand ("god", Host_God_f, "god mode (invulnerability)");
1988                 Cmd_AddCommand ("notarget", Host_Notarget_f, "notarget mode (monsters do not see you)");
1989                 Cmd_AddCommand ("fly", Host_Fly_f, "fly mode (flight)");
1990                 Cmd_AddCommand ("noclip", Host_Noclip_f, "noclip mode (flight without collisions, move through walls)");
1991                 Cmd_AddCommand ("give", Host_Give_f, "alter inventory");
1992         }
1993         Cmd_AddCommand ("map", Host_Map_f, "kick everyone off the server and start a new level");
1994         Cmd_AddCommand ("restart", Host_Restart_f, "restart current level");
1995         Cmd_AddCommand ("changelevel", Host_Changelevel_f, "change to another level, bringing along all connected clients");
1996         Cmd_AddCommand ("connect", Host_Connect_f, "connect to a server by IP address or hostname");
1997         Cmd_AddCommand ("reconnect", Host_Reconnect_f, "reset signon level in preparation for a new level (do not use)");
1998         Cmd_AddCommand ("version", Host_Version_f, "print engine version");
1999         Cmd_AddCommand ("say", Host_Say_f, "send a chat message to everyone on the server");
2000         Cmd_AddCommand ("say_team", Host_Say_Team_f, "send a chat message to your team on the server");
2001         Cmd_AddCommand ("tell", Host_Tell_f, "send a chat message to only one person on the server");
2002         Cmd_AddCommand ("kill", Host_Kill_f, "die instantly");
2003         Cmd_AddCommand ("pause", Host_Pause_f, "pause the game (if the server allows pausing)");
2004         Cmd_AddCommand ("kick", Host_Kick_f, "kick a player off the server by number or name");
2005         Cmd_AddCommand ("ping", Host_Ping_f, "print ping times of all players on the server");
2006         Cmd_AddCommand ("load", Host_Loadgame_f, "load a saved game file");
2007         Cmd_AddCommand ("save", Host_Savegame_f, "save the game to a file");
2008
2009         Cmd_AddCommand ("startdemos", Host_Startdemos_f, "start playing back the selected demos sequentially (used at end of startup script)");
2010         Cmd_AddCommand ("demos", Host_Demos_f, "restart looping demos defined by the last startdemos command");
2011         Cmd_AddCommand ("stopdemo", Host_Stopdemo_f, "stop playing or recording demo (like stop command) and return to looping demos");
2012
2013         Cmd_AddCommand ("viewmodel", Host_Viewmodel_f, "change model of viewthing entity in current level");
2014         Cmd_AddCommand ("viewframe", Host_Viewframe_f, "change animation frame of viewthing entity in current level");
2015         Cmd_AddCommand ("viewnext", Host_Viewnext_f, "change to next animation frame of viewthing entity in current level");
2016         Cmd_AddCommand ("viewprev", Host_Viewprev_f, "change to previous animation frame of viewthing entity in current level");
2017
2018         Cvar_RegisterVariable (&cl_name);
2019         Cmd_AddCommand ("name", Host_Name_f, "change your player name");
2020         Cvar_RegisterVariable (&cl_color);
2021         Cmd_AddCommand ("color", Host_Color_f, "change your player shirt and pants colors");
2022         Cvar_RegisterVariable (&cl_rate);
2023         Cmd_AddCommand ("rate", Host_Rate_f, "change your network connection speed");
2024         if (gamemode == GAME_NEHAHRA)
2025         {
2026                 Cvar_RegisterVariable (&cl_pmodel);
2027                 Cmd_AddCommand ("pmodel", Host_PModel_f, "change your player model choice (Nehahra specific)");
2028         }
2029
2030         // BLACK: This isnt game specific anymore (it was GAME_NEXUIZ at first)
2031         Cvar_RegisterVariable (&cl_playermodel);
2032         Cmd_AddCommand ("playermodel", Host_Playermodel_f, "change your player model");
2033         Cvar_RegisterVariable (&cl_playerskin);
2034         Cmd_AddCommand ("playerskin", Host_Playerskin_f, "change your player skin number");
2035
2036         Cmd_AddCommand ("prespawn", Host_PreSpawn_f, "signon 1 (client acknowledges that server information has been received)");
2037         Cmd_AddCommand ("spawn", Host_Spawn_f, "signon 2 (client has sent player information, and is asking server to send scoreboard rankings)");
2038         Cmd_AddCommand ("begin", Host_Begin_f, "signon 3 (client asks server to start sending entities, and will go to signon 4 (playing) when the first entity update is received)");
2039         Cmd_AddCommand ("maxplayers", MaxPlayers_f, "sets limit on how many players (or bots) may be connected to the server at once");
2040
2041         Cmd_AddCommand ("sendcvar", Host_SendCvar_f, "sends the value of a cvar to the server as a sentcvar command, for use by QuakeC");       // By [515]
2042
2043         Cvar_RegisterVariable(&sv_cheats);
2044 }
2045