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