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