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