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