added COMMANDLINEOPTION comments for every commandline option, these will be listed...
[divverent/darkplaces.git] / common.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 // common.c -- misc functions used in client and server
21
22 #include <stdlib.h>
23 #include <fcntl.h>
24 #ifndef WIN32
25 #include <unistd.h>
26 #endif
27
28 #include "quakedef.h"
29
30 cvar_t registered = {0, "registered","0"};
31 cvar_t cmdline = {0, "cmdline","0"};
32
33 extern qboolean fs_modified;   // set true if using non-id files
34
35 char com_token[1024];
36 int com_argc;
37 const char **com_argv;
38
39 // LordHavoc: made commandline 1024 characters instead of 256
40 #define CMDLINE_LENGTH  1024
41 char com_cmdline[CMDLINE_LENGTH];
42
43 int gamemode;
44 const char *gamename;
45 const char *gamedirname;
46 const char *gamescreenshotname;
47 char com_modname[MAX_OSPATH] = "";
48
49
50 /*
51 ============================================================================
52
53                                         BYTE ORDER FUNCTIONS
54
55 ============================================================================
56 */
57
58 short   ShortSwap (short l)
59 {
60         qbyte    b1,b2;
61
62         b1 = l&255;
63         b2 = (l>>8)&255;
64
65         return (b1<<8) + b2;
66 }
67
68 int    LongSwap (int l)
69 {
70         qbyte    b1,b2,b3,b4;
71
72         b1 = l&255;
73         b2 = (l>>8)&255;
74         b3 = (l>>16)&255;
75         b4 = (l>>24)&255;
76
77         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
78 }
79
80 float FloatSwap (float f)
81 {
82         union
83         {
84                 float   f;
85                 qbyte    b[4];
86         } dat1, dat2;
87
88
89         dat1.f = f;
90         dat2.b[0] = dat1.b[3];
91         dat2.b[1] = dat1.b[2];
92         dat2.b[2] = dat1.b[1];
93         dat2.b[3] = dat1.b[0];
94         return dat2.f;
95 }
96
97
98 // Extract integers from buffers
99
100 unsigned int BuffBigLong (const qbyte *buffer)
101 {
102         return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
103 }
104
105 unsigned short BuffBigShort (const qbyte *buffer)
106 {
107         return (buffer[0] << 8) | buffer[1];
108 }
109
110 unsigned int BuffLittleLong (const qbyte *buffer)
111 {
112         return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
113 }
114
115 unsigned short BuffLittleShort (const qbyte *buffer)
116 {
117         return (buffer[1] << 8) | buffer[0];
118 }
119
120
121 /*
122 ==============================================================================
123
124                         MESSAGE IO FUNCTIONS
125
126 Handles byte ordering and avoids alignment errors
127 ==============================================================================
128 */
129
130 //
131 // writing functions
132 //
133
134 void MSG_WriteChar (sizebuf_t *sb, int c)
135 {
136         qbyte    *buf;
137
138         buf = SZ_GetSpace (sb, 1);
139         buf[0] = c;
140 }
141
142 void MSG_WriteByte (sizebuf_t *sb, int c)
143 {
144         qbyte    *buf;
145
146         buf = SZ_GetSpace (sb, 1);
147         buf[0] = c;
148 }
149
150 void MSG_WriteShort (sizebuf_t *sb, int c)
151 {
152         qbyte    *buf;
153
154         buf = SZ_GetSpace (sb, 2);
155         buf[0] = c&0xff;
156         buf[1] = c>>8;
157 }
158
159 void MSG_WriteLong (sizebuf_t *sb, int c)
160 {
161         qbyte    *buf;
162
163         buf = SZ_GetSpace (sb, 4);
164         buf[0] = c&0xff;
165         buf[1] = (c>>8)&0xff;
166         buf[2] = (c>>16)&0xff;
167         buf[3] = c>>24;
168 }
169
170 void MSG_WriteFloat (sizebuf_t *sb, float f)
171 {
172         union
173         {
174                 float   f;
175                 int     l;
176         } dat;
177
178
179         dat.f = f;
180         dat.l = LittleLong (dat.l);
181
182         SZ_Write (sb, &dat.l, 4);
183 }
184
185 void MSG_WriteString (sizebuf_t *sb, const char *s)
186 {
187         if (!s)
188                 SZ_Write (sb, "", 1);
189         else
190                 SZ_Write (sb, s, strlen(s)+1);
191 }
192
193 void MSG_WriteCoord13i (sizebuf_t *sb, float f)
194 {
195         if (f >= 0)
196                 MSG_WriteShort (sb, (int)(f * 8.0 + 0.5));
197         else
198                 MSG_WriteShort (sb, (int)(f * 8.0 - 0.5));
199 }
200
201 void MSG_WriteCoord16i (sizebuf_t *sb, float f)
202 {
203         if (f >= 0)
204                 MSG_WriteShort (sb, (int)(f + 0.5));
205         else
206                 MSG_WriteShort (sb, (int)(f - 0.5));
207 }
208
209 void MSG_WriteCoord32f (sizebuf_t *sb, float f)
210 {
211         MSG_WriteFloat (sb, f);
212 }
213
214 void MSG_WriteCoord (sizebuf_t *sb, float f, int protocol)
215 {
216         if (protocol == PROTOCOL_QUAKE)
217                 MSG_WriteCoord13i (sb, f);
218         else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
219                 MSG_WriteCoord32f (sb, f);
220         else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
221                 MSG_WriteCoord16i (sb, f);
222         else
223                 Host_Error("MSG_WriteCoord: unknown protocol\n");
224 }
225
226 void MSG_WriteVector (sizebuf_t *sb, float *v, int protocol)
227 {
228         MSG_WriteCoord (sb, v[0], protocol);
229         MSG_WriteCoord (sb, v[1], protocol);
230         MSG_WriteCoord (sb, v[2], protocol);
231 }
232
233 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
234 void MSG_WriteAngle8i (sizebuf_t *sb, float f)
235 {
236         if (f >= 0)
237                 MSG_WriteByte (sb, (int)(f*(256.0/360.0) + 0.5) & 255);
238         else
239                 MSG_WriteByte (sb, (int)(f*(256.0/360.0) - 0.5) & 255);
240 }
241
242 void MSG_WriteAngle16i (sizebuf_t *sb, float f)
243 {
244         if (f >= 0)
245                 MSG_WriteShort (sb, (int)(f*(65536.0/360.0) + 0.5) & 65535);
246         else
247                 MSG_WriteShort (sb, (int)(f*(65536.0/360.0) - 0.5) & 65535);
248 }
249
250 void MSG_WriteAngle32f (sizebuf_t *sb, float f)
251 {
252         MSG_WriteFloat (sb, f);
253 }
254
255 void MSG_WriteAngle (sizebuf_t *sb, float f, int protocol)
256 {
257         if (protocol == PROTOCOL_DARKPLACES5)
258                 MSG_WriteAngle16i (sb, f);
259         else
260                 MSG_WriteAngle8i (sb, f);
261 }
262
263 //
264 // reading functions
265 //
266 int msg_readcount;
267 qboolean msg_badread;
268
269 void MSG_BeginReading (void)
270 {
271         msg_readcount = 0;
272         msg_badread = false;
273 }
274
275 int MSG_ReadLittleShort (void)
276 {
277         if (msg_readcount+2 > net_message.cursize)
278         {
279                 msg_badread = true;
280                 return -1;
281         }
282         msg_readcount += 2;
283         return (short)(net_message.data[msg_readcount-2] | (net_message.data[msg_readcount-1]<<8));
284 }
285
286 int MSG_ReadBigShort (void)
287 {
288         if (msg_readcount+2 > net_message.cursize)
289         {
290                 msg_badread = true;
291                 return -1;
292         }
293         msg_readcount += 2;
294         return (short)((net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1]);
295 }
296
297 int MSG_ReadLittleLong (void)
298 {
299         if (msg_readcount+4 > net_message.cursize)
300         {
301                 msg_badread = true;
302                 return -1;
303         }
304         msg_readcount += 4;
305         return net_message.data[msg_readcount-4] | (net_message.data[msg_readcount-3]<<8) | (net_message.data[msg_readcount-2]<<16) | (net_message.data[msg_readcount-1]<<24);
306 }
307
308 int MSG_ReadBigLong (void)
309 {
310         if (msg_readcount+4 > net_message.cursize)
311         {
312                 msg_badread = true;
313                 return -1;
314         }
315         msg_readcount += 4;
316         return (net_message.data[msg_readcount-4]<<24) + (net_message.data[msg_readcount-3]<<16) + (net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1];
317 }
318
319 float MSG_ReadLittleFloat (void)
320 {
321         union
322         {
323                 float f;
324                 int l;
325         } dat;
326         if (msg_readcount+4 > net_message.cursize)
327         {
328                 msg_badread = true;
329                 return -1;
330         }
331         msg_readcount += 4;
332         dat.l = net_message.data[msg_readcount-4] | (net_message.data[msg_readcount-3]<<8) | (net_message.data[msg_readcount-2]<<16) | (net_message.data[msg_readcount-1]<<24);
333         return dat.f;
334 }
335
336 float MSG_ReadBigFloat (void)
337 {
338         union
339         {
340                 float f;
341                 int l;
342         } dat;
343         if (msg_readcount+4 > net_message.cursize)
344         {
345                 msg_badread = true;
346                 return -1;
347         }
348         msg_readcount += 4;
349         dat.l = (net_message.data[msg_readcount-4]<<24) | (net_message.data[msg_readcount-3]<<16) | (net_message.data[msg_readcount-2]<<8) | net_message.data[msg_readcount-1];
350         return dat.f;
351 }
352
353 char *MSG_ReadString (void)
354 {
355         static char string[2048];
356         int l,c;
357         for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
358                 string[l] = c;
359         string[l] = 0;
360         return string;
361 }
362
363 int MSG_ReadBytes (int numbytes, unsigned char *out)
364 {
365         int l, c;
366         for (l = 0;l < numbytes && (c = MSG_ReadChar()) != -1;l++)
367                 out[l] = c;
368         return l;
369 }
370
371 float MSG_ReadCoord13i (void)
372 {
373         return MSG_ReadLittleShort() * (1.0/8.0);
374 }
375
376 float MSG_ReadCoord16i (void)
377 {
378         return (signed short) MSG_ReadLittleShort();
379 }
380
381 float MSG_ReadCoord32f (void)
382 {
383         return MSG_ReadLittleFloat();
384 }
385
386 float MSG_ReadCoord (int protocol)
387 {
388         if (protocol == PROTOCOL_QUAKE)
389                 return MSG_ReadCoord13i();
390         else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
391                 return MSG_ReadCoord32f();
392         else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
393                 return MSG_ReadCoord16i();
394         Host_Error("MSG_ReadCoord: unknown protocol\n");
395         return 0;
396 }
397
398 void MSG_ReadVector (float *v, int protocol)
399 {
400         v[0] = MSG_ReadCoord(protocol);
401         v[1] = MSG_ReadCoord(protocol);
402         v[2] = MSG_ReadCoord(protocol);
403 }
404
405 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
406 float MSG_ReadAngle8i (void)
407 {
408         return (signed char) MSG_ReadByte () * (360.0/256.0);
409 }
410
411 float MSG_ReadAngle16i (void)
412 {
413         return (signed short)MSG_ReadShort () * (360.0/65536.0);
414 }
415
416 float MSG_ReadAngle32f (void)
417 {
418         return MSG_ReadFloat ();
419 }
420
421 float MSG_ReadAngle (int protocol)
422 {
423         if (protocol == PROTOCOL_DARKPLACES5)
424                 return MSG_ReadAngle16i ();
425         else
426                 return MSG_ReadAngle8i ();
427 }
428
429
430 //===========================================================================
431
432 void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name)
433 {
434         if (startsize < 256)
435                 startsize = 256;
436         buf->mempool = Mem_AllocPool(name, 0, NULL);
437         buf->data = Mem_Alloc(buf->mempool, startsize);
438         buf->maxsize = startsize;
439         buf->cursize = 0;
440 }
441
442
443 void SZ_Free (sizebuf_t *buf)
444 {
445         Mem_FreePool(&buf->mempool);
446         buf->data = NULL;
447         buf->maxsize = 0;
448         buf->cursize = 0;
449 }
450
451 void SZ_Clear (sizebuf_t *buf)
452 {
453         buf->cursize = 0;
454 }
455
456 void *SZ_GetSpace (sizebuf_t *buf, int length)
457 {
458         void *data;
459
460         if (buf->cursize + length > buf->maxsize)
461         {
462                 if (!buf->allowoverflow)
463                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
464
465                 if (length > buf->maxsize)
466                         Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
467
468                 buf->overflowed = true;
469                 Con_Print("SZ_GetSpace: overflow\n");
470                 SZ_Clear (buf);
471         }
472
473         data = buf->data + buf->cursize;
474         buf->cursize += length;
475
476         return data;
477 }
478
479 void SZ_Write (sizebuf_t *buf, const void *data, int length)
480 {
481         memcpy (SZ_GetSpace(buf,length),data,length);
482 }
483
484 // LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
485 // attention, it has been eradicated from here, its only (former) use in
486 // all of darkplaces.
487
488 static char *hexchar = "0123456789ABCDEF";
489 void Com_HexDumpToConsole(const qbyte *data, int size)
490 {
491         int i, j, n;
492         char text[1024];
493         char *cur, *flushpointer;
494         const qbyte *d;
495         cur = text;
496         flushpointer = text + 512;
497         for (i = 0;i < size;)
498         {
499                 n = 16;
500                 if (n > size - i)
501                         n = size - i;
502                 d = data + i;
503                 // print offset
504                 *cur++ = hexchar[(i >> 12) & 15];
505                 *cur++ = hexchar[(i >>  8) & 15];
506                 *cur++ = hexchar[(i >>  4) & 15];
507                 *cur++ = hexchar[(i >>  0) & 15];
508                 *cur++ = ':';
509                 // print hex
510                 for (j = 0;j < 16;j++)
511                 {
512                         if (j < n)
513                         {
514                                 *cur++ = hexchar[(d[j] >> 4) & 15];
515                                 *cur++ = hexchar[(d[j] >> 0) & 15];
516                         }
517                         else
518                         {
519                                 *cur++ = ' ';
520                                 *cur++ = ' ';
521                         }
522                         if ((j & 3) == 3)
523                                 *cur++ = ' ';
524                 }
525                 // print text
526                 for (j = 0;j < 16;j++)
527                 {
528                         if (j < n)
529                         {
530                                 if (d[j] >= ' ' && d[j] <= 127)
531                                         *cur++ = d[j];
532                                 else
533                                         *cur++ = '.';
534                         }
535                         else
536                                 *cur++ = ' ';
537                 }
538                 *cur++ = '\n';
539                 i += n;
540                 if (cur >= flushpointer || i >= size)
541                 {
542                         *cur++ = 0;
543                         Con_Print(text);
544                         cur = text;
545                 }
546         }
547 }
548
549 void SZ_HexDumpToConsole(const sizebuf_t *buf)
550 {
551         Com_HexDumpToConsole(buf->data, buf->cursize);
552 }
553
554
555 //============================================================================
556
557
558 /*
559 ==============
560 COM_ParseToken
561
562 Parse a token out of a string
563 ==============
564 */
565 int COM_ParseToken(const char **datapointer, int returnnewline)
566 {
567         int len;
568         const char *data = *datapointer;
569
570         len = 0;
571         com_token[0] = 0;
572
573         if (!data)
574         {
575                 *datapointer = NULL;
576                 return false;
577         }
578
579 // skip whitespace
580 skipwhite:
581         for (;*data <= ' ' && (*data != '\n' || !returnnewline);data++)
582         {
583                 if (*data == 0)
584                 {
585                         // end of file
586                         *datapointer = NULL;
587                         return false;
588                 }
589         }
590
591         if (data[0] == '/' && data[1] == '/')
592         {
593                 // comment
594                 while (*data && *data != '\n')
595                         data++;
596                 goto skipwhite;
597         }
598         else if (data[0] == '/' && data[1] == '*')
599         {
600                 // comment
601                 data++;
602                 while (*data && (data[0] != '*' || data[1] != '/'))
603                         data++;
604                 data += 2;
605                 goto skipwhite;
606         }
607         else if (*data == '\"')
608         {
609                 // quoted string
610                 for (data++;*data != '\"';data++)
611                 {
612                         if (!*data || len >= (int)sizeof(com_token) - 1)
613                         {
614                                 com_token[0] = 0;
615                                 *datapointer = NULL;
616                                 return false;
617                         }
618                         com_token[len++] = *data;
619                 }
620                 com_token[len] = 0;
621                 *datapointer = data+1;
622                 return true;
623         }
624         else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
625         {
626                 // single character
627                 com_token[len++] = *data++;
628                 com_token[len] = 0;
629                 *datapointer = data;
630                 return true;
631         }
632         else
633         {
634                 // regular word
635                 for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';';data++)
636                 {
637                         if (len >= (int)sizeof(com_token) - 1)
638                         {
639                                 com_token[0] = 0;
640                                 *datapointer = NULL;
641                                 return false;
642                         }
643                         com_token[len++] = *data;
644                 }
645                 com_token[len] = 0;
646                 *datapointer = data;
647                 return true;
648         }
649 }
650
651 /*
652 ==============
653 COM_ParseTokenConsole
654
655 Parse a token out of a string, behaving like the qwcl console
656 ==============
657 */
658 int COM_ParseTokenConsole(const char **datapointer)
659 {
660         int len;
661         const char *data = *datapointer;
662
663         len = 0;
664         com_token[0] = 0;
665
666         if (!data)
667         {
668                 *datapointer = NULL;
669                 return false;
670         }
671
672 // skip whitespace
673 skipwhite:
674         for (;*data <= ' ';data++)
675         {
676                 if (*data == 0)
677                 {
678                         // end of file
679                         *datapointer = NULL;
680                         return false;
681                 }
682         }
683
684         if (*data == '/' && data[1] == '/')
685         {
686                 // comment
687                 while (*data && *data != '\n')
688                         data++;
689                 goto skipwhite;
690         }
691         else if (*data == '\"')
692         {
693                 // quoted string
694                 for (data++;*data != '\"';data++)
695                 {
696                         if (!*data || len >= (int)sizeof(com_token) - 1)
697                         {
698                                 com_token[0] = 0;
699                                 *datapointer = NULL;
700                                 return false;
701                         }
702                         com_token[len++] = *data;
703                 }
704                 com_token[len] = 0;
705                 *datapointer = data+1;
706                 return true;
707         }
708         else
709         {
710                 // regular word
711                 for (;*data > ' ';data++)
712                 {
713                         if (len >= (int)sizeof(com_token) - 1)
714                         {
715                                 com_token[0] = 0;
716                                 *datapointer = NULL;
717                                 return false;
718                         }
719                         com_token[len++] = *data;
720                 }
721                 com_token[len] = 0;
722                 *datapointer = data;
723                 return true;
724         }
725 }
726
727
728 /*
729 ================
730 COM_CheckParm
731
732 Returns the position (1 to argc-1) in the program's argument list
733 where the given parameter apears, or 0 if not present
734 ================
735 */
736 int COM_CheckParm (const char *parm)
737 {
738         int i;
739
740         for (i=1 ; i<com_argc ; i++)
741         {
742                 if (!com_argv[i])
743                         continue;               // NEXTSTEP sometimes clears appkit vars.
744                 if (!strcmp (parm,com_argv[i]))
745                         return i;
746         }
747
748         return 0;
749 }
750
751 /*
752 ================
753 COM_CheckRegistered
754
755 Looks for the pop.txt file and verifies it.
756 Sets the "registered" cvar.
757 Immediately exits out if an alternate game was attempted to be started without
758 being registered.
759 ================
760 */
761 void COM_CheckRegistered (void)
762 {
763         Cvar_Set ("cmdline", com_cmdline);
764
765         if (!FS_FileExists("gfx/pop.lmp"))
766         {
767                 if (fs_modified)
768                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
769                 else
770                         Con_Print("Playing shareware version.\n");
771                 return;
772         }
773
774         Cvar_Set ("registered", "1");
775         Con_Print("Playing registered version.\n");
776 }
777
778
779 /*
780 ================
781 COM_InitArgv
782 ================
783 */
784 void COM_InitArgv (void)
785 {
786         int i, j, n;
787         // reconstitute the command line for the cmdline externally visible cvar
788         n = 0;
789         for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
790         {
791                 i = 0;
792                 if (strstr(com_argv[j], " "))
793                 {
794                         // arg contains whitespace, store quotes around it
795                         com_cmdline[n++] = '\"';
796                         while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
797                                 com_cmdline[n++] = com_argv[j][i++];
798                         com_cmdline[n++] = '\"';
799                 }
800                 else
801                 {
802                         while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
803                                 com_cmdline[n++] = com_argv[j][i++];
804                 }
805                 if (n < (CMDLINE_LENGTH - 1))
806                         com_cmdline[n++] = ' ';
807                 else
808                         break;
809         }
810         com_cmdline[n] = 0;
811 }
812
813
814 //===========================================================================
815
816 // Game mods
817
818 typedef struct
819 {
820         const char* prog_name;
821         const char* cmdline;
822         const char* gamename;
823         const char* gamedirname;
824         const char* gamescreenshotname;
825 } gamemode_info_t;
826
827 static const gamemode_info_t gamemode_info [] =
828 {// prog_name           cmdline                 gamename                                gamedirname     gamescreenshotname
829
830 // GAME_NORMAL
831 // COMMANDLINEOPTION: -quake runs the game Quake (default)
832 { "",                           "-quake",               "DarkPlaces-Quake",             "",                     "dp" },
833 // GAME_HIPNOTIC
834 // COMMANDLINEOPTION: -hipnotic runs Quake mission pack 1: The Scourge of Armagon
835 { "hipnotic",           "-hipnotic",    "Darkplaces-Hipnotic",  "hipnotic",     "dp" },
836 // GAME_ROGUE
837 // COMMANDLINEOPTION: -rogue runs Quake mission pack 2: The Dissolution of Eternity
838 { "rogue",                      "-rogue",               "Darkplaces-Rogue",             "rogue",        "dp" },
839 // GAME_NEHAHRA
840 // COMMANDLINEOPTION: -nehahra runs The Seal of Nehahra movie and game
841 { "nehahra",            "-nehahra",             "DarkPlaces-Nehahra",   "nehahra",      "dp" },
842 // GAME_NEXUIZ
843 // COMMANDLINEOPTION: -nexuiz runs the multiplayer game Nexuiz
844 { "nexuiz",                     "-nexuiz",              "Nexuiz",                               "data",         "nexuiz" },
845 // GAME_TRANSFUSION
846 // COMMANDLINEOPTION: -transfusion runs Transfusion (the recreation of Blood in Quake)
847 { "transfusion",        "-transfusion", "Transfusion",                  "basetf",       "transfusion" },
848 // GAME_GOODVSBAD2
849 // COMMANDLINEOPTION: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2
850 { "gvb2",                       "-goodvsbad2",  "GoodVs.Bad2",                  "rts",          "gvb2" },
851 // GAME_TEU
852 // COMMANDLINEOPTION: -teu runs The Evil Unleashed (this option is obsolete as they are not using darkplaces)
853 { "teu",                        "-teu",                 "TheEvilUnleashed",             "baseteu",      "teu" },
854 // GAME_BATTLEMECH
855 // COMMANDLINEOPTION: -battlemech runs the multiplayer topdown deathmatch game BattleMech 
856 { "battlemech",         "-battlemech",  "Battlemech",                   "base",         "battlemech" },
857 // GAME_ZYMOTIC
858 // COMMANDLINEOPTION: -zymotic runs the singleplayer game Zymotic
859 { "zymotic",            "-zymotic",             "Zymotic",                              "data",         "zymotic" },
860 // GAME_FNIGGIUM
861 // COMMANDLINEOPTION: -fniggium runs the post apocalyptic melee RPG Fniggium 
862 { "fniggium",           "-fniggium",    "Fniggium",                             "data",         "fniggium" },
863 // GAME_SETHERAL
864 // COMMANDLINEOPTION: -setheral runs the multiplayer game Setheral 
865 { "setheral",           "-setheral",    "Setheral",                             "data",         "setheral" },
866 // GAME_SOM
867 // COMMANDLINEOPTION: -som runs the multiplayer game Son Of Man 
868 { "som",                        "-som",                 "Son of Man",                   "sonofman",     "som" },
869 // GAME_TENEBRAE
870 // COMMANDLINEOPTION: -tenebrae runs the graphics test mod known as Tenebrae (some features not implemented)
871 { "tenebrae",           "-tenebrae",    "DarkPlaces-Tenebrae",  "tenebrae",     "dp" },
872 // GAME_NEOTERIC
873 // COMMANDLINEOPTION: -neoteric runs the game Neoteric
874 { "neoteric",           "-neoteric",    "Neoteric",                             "neobase",      "neo" },
875 // GAME_OPENQUARTZ
876 // COMMANDLINEOPTION: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
877 { "openquartz",         "-openquartz",  "OpenQuartz",                   "id1",          "openquartz"},
878 // GAME_PRYDON
879 // COMMANDLINEOPTION: -prydon runs the topdown point and click action-RPG Prydon Gate
880 { "prydon",                     "-prydon",              "PrydonGate",                   "prydon",       "prydon"},
881 // GAME_NETHERWORLD
882 // COMMANDLINEOPTION: -netherworld runs the game Netherworld: Dark Masters
883 { "netherworld",        "-netherworld", "Dark Masters",                 "netherworld",  "nw"},
884 };
885
886 void COM_InitGameType (void)
887 {
888         char name [MAX_OSPATH];
889         unsigned int i;
890
891         FS_StripExtension (com_argv[0], name, sizeof (name));
892         COM_ToLowerString (name, name, sizeof (name));
893
894         // Check the binary name; default to GAME_NORMAL (0)
895         gamemode = GAME_NORMAL;
896         for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
897                 if (strstr (name, gamemode_info[i].prog_name))
898                 {
899                         gamemode = i;
900                         break;
901                 }
902
903         // Look for a command-line option
904         for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
905                 if (COM_CheckParm (gamemode_info[i].cmdline))
906                 {
907                         gamemode = i;
908                         break;
909                 }
910
911         gamename = gamemode_info[gamemode].gamename;
912         gamedirname = gamemode_info[gamemode].gamedirname;
913         gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
914 }
915
916
917 extern void Mathlib_Init(void);
918 extern void FS_Init (void);
919
920 /*
921 ================
922 COM_Init
923 ================
924 */
925 void COM_Init (void)
926 {
927         Cvar_RegisterVariable (&registered);
928         Cvar_RegisterVariable (&cmdline);
929
930         Mathlib_Init();
931
932         FS_Init ();
933         Log_Init ();
934         COM_CheckRegistered ();
935 }
936
937
938 /*
939 ============
940 va
941
942 does a varargs printf into a temp buffer, so I don't need to have
943 varargs versions of all text functions.
944 FIXME: make this buffer size safe someday
945 ============
946 */
947 char *va(const char *format, ...)
948 {
949         va_list argptr;
950         // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
951         static char string[8][1024], *s;
952         static int stringindex = 0;
953
954         s = string[stringindex];
955         stringindex = (stringindex + 1) & 7;
956         va_start (argptr, format);
957         vsnprintf (s, sizeof (string[0]), format,argptr);
958         va_end (argptr);
959
960         return s;
961 }
962
963
964 //======================================
965
966 void COM_ToLowerString (const char *in, char *out, size_t size_out)
967 {
968         if (size_out == 0)
969                 return;
970
971         while (*in && size_out > 1)
972         {
973                 if (*in >= 'A' && *in <= 'Z')
974                         *out++ = *in++ + 'a' - 'A';
975                 else
976                         *out++ = *in++;
977                 size_out--;
978         }
979         *out = '\0';
980 }
981
982 void COM_ToUpperString (const char *in, char *out, size_t size_out)
983 {
984         if (size_out == 0)
985                 return;
986
987         while (*in && size_out > 1)
988         {
989                 if (*in >= 'a' && *in <= 'z')
990                         *out++ = *in++ + 'A' - 'a';
991                 else
992                         *out++ = *in++;
993                 size_out--;
994         }
995         *out = '\0';
996 }
997
998 int COM_StringBeginsWith(const char *s, const char *match)
999 {
1000         for (;*s && *match;s++, match++)
1001                 if (*s != *match)
1002                         return false;
1003         return true;
1004 }
1005
1006 int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
1007 {
1008         int argc, commentprefixlength;
1009         char *tokenbufend;
1010         const char *l;
1011         argc = 0;
1012         tokenbufend = tokenbuf + tokenbufsize;
1013         l = *text;
1014         commentprefixlength = 0;
1015         if (commentprefix)
1016                 commentprefixlength = strlen(commentprefix);
1017         while (*l && *l != '\n')
1018         {
1019                 if (*l > ' ')
1020                 {
1021                         if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
1022                         {
1023                                 while (*l && *l != '\n')
1024                                         l++;
1025                                 break;
1026                         }
1027                         if (argc >= maxargc)
1028                                 return -1;
1029                         argv[argc++] = tokenbuf;
1030                         if (*l == '"')
1031                         {
1032                                 l++;
1033                                 while (*l && *l != '"')
1034                                 {
1035                                         if (tokenbuf >= tokenbufend)
1036                                                 return -1;
1037                                         *tokenbuf++ = *l++;
1038                                 }
1039                                 if (*l == '"')
1040                                         l++;
1041                         }
1042                         else
1043                         {
1044                                 while (*l > ' ')
1045                                 {
1046                                         if (tokenbuf >= tokenbufend)
1047                                                 return -1;
1048                                         *tokenbuf++ = *l++;
1049                                 }
1050                         }
1051                         if (tokenbuf >= tokenbufend)
1052                                 return -1;
1053                         *tokenbuf++ = 0;
1054                 }
1055                 else
1056                         l++;
1057         }
1058         if (*l == '\n')
1059                 l++;
1060         *text = l;
1061         return argc;
1062 }
1063
1064 // written by Elric, thanks Elric!
1065 char *SearchInfostring(const char *infostring, const char *key)
1066 {
1067         static char value [256];
1068         char crt_key [256];
1069         size_t value_ind, key_ind;
1070         char c;
1071
1072         if (*infostring++ != '\\')
1073                 return NULL;
1074
1075         value_ind = 0;
1076         for (;;)
1077         {
1078                 key_ind = 0;
1079
1080                 // Get the key name
1081                 for (;;)
1082                 {
1083                         c = *infostring++;
1084
1085                         if (c == '\0')
1086                                 return NULL;
1087                         if (c == '\\' || key_ind == sizeof (crt_key) - 1)
1088                         {
1089                                 crt_key[key_ind] = '\0';
1090                                 break;
1091                         }
1092
1093                         crt_key[key_ind++] = c;
1094                 }
1095
1096                 // If it's the key we are looking for, save it in "value"
1097                 if (!strcmp(crt_key, key))
1098                 {
1099                         for (;;)
1100                         {
1101                                 c = *infostring++;
1102
1103                                 if (c == '\0' || c == '\\' || value_ind == sizeof (value) - 1)
1104                                 {
1105                                         value[value_ind] = '\0';
1106                                         return value;
1107                                 }
1108
1109                                 value[value_ind++] = c;
1110                         }
1111                 }
1112
1113                 // Else, skip the value
1114                 for (;;)
1115                 {
1116                         c = *infostring++;
1117
1118                         if (c == '\0')
1119                                 return NULL;
1120                         if (c == '\\')
1121                                 break;
1122                 }
1123         }
1124 }
1125
1126
1127 //========================================================
1128 // strlcat and strlcpy, from OpenBSD
1129
1130 /*
1131  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
1132  *
1133  * Permission to use, copy, modify, and distribute this software for any
1134  * purpose with or without fee is hereby granted, provided that the above
1135  * copyright notice and this permission notice appear in all copies.
1136  *
1137  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1138  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1139  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1140  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1141  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1142  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1143  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1144  */
1145
1146 /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
1147 /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
1148
1149
1150 #ifndef HAVE_STRLCAT
1151 size_t
1152 strlcat(char *dst, const char *src, size_t siz)
1153 {
1154         register char *d = dst;
1155         register const char *s = src;
1156         register size_t n = siz;
1157         size_t dlen;
1158
1159         /* Find the end of dst and adjust bytes left but don't go past end */
1160         while (n-- != 0 && *d != '\0')
1161                 d++;
1162         dlen = d - dst;
1163         n = siz - dlen;
1164
1165         if (n == 0)
1166                 return(dlen + strlen(s));
1167         while (*s != '\0') {
1168                 if (n != 1) {
1169                         *d++ = *s;
1170                         n--;
1171                 }
1172                 s++;
1173         }
1174         *d = '\0';
1175
1176         return(dlen + (s - src));       /* count does not include NUL */
1177 }
1178 #endif  // #ifndef HAVE_STRLCAT
1179
1180
1181 #ifndef HAVE_STRLCPY
1182 size_t
1183 strlcpy(char *dst, const char *src, size_t siz)
1184 {
1185         register char *d = dst;
1186         register const char *s = src;
1187         register size_t n = siz;
1188
1189         /* Copy as many bytes as will fit */
1190         if (n != 0 && --n != 0) {
1191                 do {
1192                         if ((*d++ = *s++) == 0)
1193                                 break;
1194                 } while (--n != 0);
1195         }
1196
1197         /* Not enough room in dst, add NUL and traverse rest of src */
1198         if (n == 0) {
1199                 if (siz != 0)
1200                         *d = '\0';              /* NUL-terminate dst */
1201                 while (*s++)
1202                         ;
1203         }
1204
1205         return(s - src - 1);    /* count does not include NUL */
1206 }
1207
1208 #endif  // #ifndef HAVE_STRLCPY