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