added GAME_NEOTERIC
[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 char *gamename;
45 char *gamedirname;
46 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 // used by server (always latest PROTOCOL_DARKPLACES)
194 void MSG_WriteDPCoord (sizebuf_t *sb, float f)
195 {
196         if (f >= 0)
197                 MSG_WriteShort (sb, (int)(f + 0.5f));
198         else
199                 MSG_WriteShort (sb, (int)(f - 0.5f));
200 }
201
202 void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
203 {
204         if (f >= 0)
205                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
206         else
207                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
208 }
209
210 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
211 void MSG_WriteAngle (sizebuf_t *sb, float f)
212 {
213         if (f >= 0)
214                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
215         else
216                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
217 }
218
219 //
220 // reading functions
221 //
222 int msg_readcount;
223 qboolean msg_badread;
224
225 void MSG_BeginReading (void)
226 {
227         msg_readcount = 0;
228         msg_badread = false;
229 }
230
231 int MSG_ReadLittleShort (void)
232 {
233         if (msg_readcount+2 > net_message.cursize)
234         {
235                 msg_badread = true;
236                 return -1;
237         }
238         msg_readcount += 2;
239         return (short)(net_message.data[msg_readcount-2] | (net_message.data[msg_readcount-1]<<8));
240 }
241
242 int MSG_ReadBigShort (void)
243 {
244         if (msg_readcount+2 > net_message.cursize)
245         {
246                 msg_badread = true;
247                 return -1;
248         }
249         msg_readcount += 2;
250         return (short)((net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1]);
251 }
252
253 int MSG_ReadLittleLong (void)
254 {
255         if (msg_readcount+4 > net_message.cursize)
256         {
257                 msg_badread = true;
258                 return -1;
259         }
260         msg_readcount += 4;
261         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);
262 }
263
264 int MSG_ReadBigLong (void)
265 {
266         if (msg_readcount+4 > net_message.cursize)
267         {
268                 msg_badread = true;
269                 return -1;
270         }
271         msg_readcount += 4;
272         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];
273 }
274
275 float MSG_ReadLittleFloat (void)
276 {
277         union
278         {
279                 float f;
280                 int l;
281         } dat;
282         if (msg_readcount+4 > net_message.cursize)
283         {
284                 msg_badread = true;
285                 return -1;
286         }
287         msg_readcount += 4;
288         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);
289         return dat.f;
290 }
291
292 float MSG_ReadBigFloat (void)
293 {
294         union
295         {
296                 float f;
297                 int l;
298         } dat;
299         if (msg_readcount+4 > net_message.cursize)
300         {
301                 msg_badread = true;
302                 return -1;
303         }
304         msg_readcount += 4;
305         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];
306         return dat.f;
307 }
308
309 char *MSG_ReadString (void)
310 {
311         static char string[2048];
312         int l,c;
313         for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
314                 string[l] = c;
315         string[l] = 0;
316         return string;
317 }
318
319 int MSG_ReadBytes (int numbytes, unsigned char *out)
320 {
321         int l, c;
322         for (l = 0;l < numbytes && (c = MSG_ReadChar()) != -1;l++)
323                 out[l] = c;
324         return l;
325 }
326
327 // used by client
328 float MSG_ReadCoord (void)
329 {
330         if (cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5)
331                 return (signed short) MSG_ReadLittleShort();
332         else if (cl.protocol == PROTOCOL_DARKPLACES1)
333                 return MSG_ReadLittleFloat();
334         else
335                 return MSG_ReadLittleShort() * (1.0f/8.0f);
336 }
337
338
339 //===========================================================================
340
341 void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name)
342 {
343         if (startsize < 256)
344                 startsize = 256;
345         buf->mempool = Mem_AllocPool(name);
346         buf->data = Mem_Alloc(buf->mempool, startsize);
347         buf->maxsize = startsize;
348         buf->cursize = 0;
349 }
350
351
352 void SZ_Free (sizebuf_t *buf)
353 {
354         Mem_FreePool(&buf->mempool);
355         buf->data = NULL;
356         buf->maxsize = 0;
357         buf->cursize = 0;
358 }
359
360 void SZ_Clear (sizebuf_t *buf)
361 {
362         buf->cursize = 0;
363 }
364
365 void *SZ_GetSpace (sizebuf_t *buf, int length)
366 {
367         void *data;
368
369         if (buf->cursize + length > buf->maxsize)
370         {
371                 if (!buf->allowoverflow)
372                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
373
374                 if (length > buf->maxsize)
375                         Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
376
377                 buf->overflowed = true;
378                 Con_Print("SZ_GetSpace: overflow\n");
379                 SZ_Clear (buf);
380         }
381
382         data = buf->data + buf->cursize;
383         buf->cursize += length;
384
385         return data;
386 }
387
388 void SZ_Write (sizebuf_t *buf, const void *data, int length)
389 {
390         memcpy (SZ_GetSpace(buf,length),data,length);
391 }
392
393 // LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
394 // attention, it has been eradicated from here, its only (former) use in
395 // all of darkplaces.
396
397 static char *hexchar = "0123456789ABCDEF";
398 void Com_HexDumpToConsole(const qbyte *data, int size)
399 {
400         int i, j, n;
401         char text[1024];
402         char *cur, *flushpointer;
403         const qbyte *d;
404         cur = text;
405         flushpointer = text + 512;
406         for (i = 0;i < size;)
407         {
408                 n = 16;
409                 if (n > size - i)
410                         n = size - i;
411                 d = data + i;
412                 // print offset
413                 *cur++ = hexchar[(i >> 12) & 15];
414                 *cur++ = hexchar[(i >>  8) & 15];
415                 *cur++ = hexchar[(i >>  4) & 15];
416                 *cur++ = hexchar[(i >>  0) & 15];
417                 *cur++ = ':';
418                 // print hex
419                 for (j = 0;j < 16;j++)
420                 {
421                         if (j < n)
422                         {
423                                 *cur++ = hexchar[(d[j] >> 4) & 15];
424                                 *cur++ = hexchar[(d[j] >> 0) & 15];
425                         }
426                         else
427                         {
428                                 *cur++ = ' ';
429                                 *cur++ = ' ';
430                         }
431                         if ((j & 3) == 0)
432                                 *cur++ = ' ';
433                 }
434                 // print text
435                 for (j = 0;j < 16;j++)
436                 {
437                         if (j < n)
438                         {
439                                 if (d[j] >= ' ' && d[j] <= 127)
440                                         *cur++ = d[j];
441                                 else
442                                         *cur++ = '.';
443                         }
444                         else
445                                 *cur++ = ' ';
446                 }
447                 *cur++ = '\n';
448                 i += n;
449                 if (cur >= flushpointer || i >= size)
450                 {
451                         *cur++ = 0;
452                         Con_Print(text);
453                         cur = text;
454                 }
455         }
456 }
457
458 void SZ_HexDumpToConsole(const sizebuf_t *buf)
459 {
460         Com_HexDumpToConsole(buf->data, buf->cursize);
461 }
462
463
464 //============================================================================
465
466
467 /*
468 ==============
469 COM_ParseToken
470
471 Parse a token out of a string
472 ==============
473 */
474 int COM_ParseToken(const char **datapointer, int returnnewline)
475 {
476         int len;
477         const char *data = *datapointer;
478
479         len = 0;
480         com_token[0] = 0;
481
482         if (!data)
483         {
484                 *datapointer = NULL;
485                 return false;
486         }
487
488 // skip whitespace
489 skipwhite:
490         for (;*data <= ' ' && (*data != '\n' || !returnnewline);data++)
491         {
492                 if (*data == 0)
493                 {
494                         // end of file
495                         *datapointer = NULL;
496                         return false;
497                 }
498         }
499
500         if (data[0] == '/' && data[1] == '/')
501         {
502                 // comment
503                 while (*data && *data != '\n')
504                         data++;
505                 goto skipwhite;
506         }
507         else if (data[0] == '/' && data[1] == '*')
508         {
509                 // comment
510                 data++;
511                 while (*data && (data[0] != '*' || data[1] != '/'))
512                         data++;
513                 data += 2;
514                 goto skipwhite;
515         }
516         else if (*data == '\"')
517         {
518                 // quoted string
519                 for (data++;*data != '\"';data++)
520                 {
521                         if (!*data || len >= (int)sizeof(com_token) - 1)
522                         {
523                                 com_token[0] = 0;
524                                 *datapointer = NULL;
525                                 return false;
526                         }
527                         com_token[len++] = *data;
528                 }
529                 com_token[len] = 0;
530                 *datapointer = data+1;
531                 return true;
532         }
533         else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
534         {
535                 // single character
536                 com_token[len++] = *data++;
537                 com_token[len] = 0;
538                 *datapointer = data;
539                 return true;
540         }
541         else
542         {
543                 // regular word
544                 for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';';data++)
545                 {
546                         if (len >= (int)sizeof(com_token) - 1)
547                         {
548                                 com_token[0] = 0;
549                                 *datapointer = NULL;
550                                 return false;
551                         }
552                         com_token[len++] = *data;
553                 }
554                 com_token[len] = 0;
555                 *datapointer = data;
556                 return true;
557         }
558 }
559
560 /*
561 ==============
562 COM_ParseTokenConsole
563
564 Parse a token out of a string, behaving like the qwcl console
565 ==============
566 */
567 int COM_ParseTokenConsole(const char **datapointer)
568 {
569         int len;
570         const char *data = *datapointer;
571
572         len = 0;
573         com_token[0] = 0;
574
575         if (!data)
576         {
577                 *datapointer = NULL;
578                 return false;
579         }
580
581 // skip whitespace
582 skipwhite:
583         for (;*data <= ' ';data++)
584         {
585                 if (*data == 0)
586                 {
587                         // end of file
588                         *datapointer = NULL;
589                         return false;
590                 }
591         }
592
593         if (*data == '/' && data[1] == '/')
594         {
595                 // comment
596                 while (*data && *data != '\n')
597                         data++;
598                 goto skipwhite;
599         }
600         else if (*data == '\"')
601         {
602                 // quoted string
603                 for (data++;*data != '\"';data++)
604                 {
605                         if (!*data || len >= (int)sizeof(com_token) - 1)
606                         {
607                                 com_token[0] = 0;
608                                 *datapointer = NULL;
609                                 return false;
610                         }
611                         com_token[len++] = *data;
612                 }
613                 com_token[len] = 0;
614                 *datapointer = data+1;
615                 return true;
616         }
617         else
618         {
619                 // regular word
620                 for (;*data > ' ';data++)
621                 {
622                         if (len >= (int)sizeof(com_token) - 1)
623                         {
624                                 com_token[0] = 0;
625                                 *datapointer = NULL;
626                                 return false;
627                         }
628                         com_token[len++] = *data;
629                 }
630                 com_token[len] = 0;
631                 *datapointer = data;
632                 return true;
633         }
634 }
635
636
637 /*
638 ================
639 COM_CheckParm
640
641 Returns the position (1 to argc-1) in the program's argument list
642 where the given parameter apears, or 0 if not present
643 ================
644 */
645 int COM_CheckParm (const char *parm)
646 {
647         int i;
648
649         for (i=1 ; i<com_argc ; i++)
650         {
651                 if (!com_argv[i])
652                         continue;               // NEXTSTEP sometimes clears appkit vars.
653                 if (!strcmp (parm,com_argv[i]))
654                         return i;
655         }
656
657         return 0;
658 }
659
660 /*
661 ================
662 COM_CheckRegistered
663
664 Looks for the pop.txt file and verifies it.
665 Sets the "registered" cvar.
666 Immediately exits out if an alternate game was attempted to be started without
667 being registered.
668 ================
669 */
670 void COM_CheckRegistered (void)
671 {
672         Cvar_Set ("cmdline", com_cmdline);
673
674         if (!FS_FileExists("gfx/pop.lmp"))
675         {
676                 if (fs_modified)
677                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
678                 else
679                         Con_Print("Playing shareware version.\n");
680                 return;
681         }
682
683         Cvar_Set ("registered", "1");
684         Con_Print("Playing registered version.\n");
685 }
686
687
688 /*
689 ================
690 COM_InitArgv
691 ================
692 */
693 void COM_InitArgv (void)
694 {
695         int i, j, n;
696         // reconstitute the command line for the cmdline externally visible cvar
697         n = 0;
698         for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
699         {
700                 i = 0;
701                 while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
702                         com_cmdline[n++] = com_argv[j][i++];
703                 if (n < (CMDLINE_LENGTH - 1))
704                         com_cmdline[n++] = ' ';
705                 else
706                         break;
707         }
708         com_cmdline[n] = 0;
709 }
710
711 void COM_InitGameType (void)
712 {
713         char name[MAX_OSPATH];
714         FS_StripExtension (com_argv[0], name, sizeof (name));
715         COM_ToLowerString (name, name, sizeof (name));
716
717         if (strstr(name, "transfusion"))
718                 gamemode = GAME_TRANSFUSION;
719         else if (strstr(name, "nexuiz"))
720                 gamemode = GAME_NEXUIZ;
721         else if (strstr(name, "nehahra"))
722                 gamemode = GAME_NEHAHRA;
723         else if (strstr(name, "hipnotic"))
724                 gamemode = GAME_HIPNOTIC;
725         else if (strstr(name, "rogue"))
726                 gamemode = GAME_ROGUE;
727         else if (strstr(name, "gvb2"))
728                 gamemode = GAME_GOODVSBAD2;
729         else if (strstr(name, "teu"))
730                 gamemode = GAME_TEU;
731         else if (strstr(name, "battlemech"))
732                 gamemode = GAME_BATTLEMECH;
733         else if (strstr(name, "zymotic"))
734                 gamemode = GAME_ZYMOTIC;
735         else if (strstr(name, "fniggium"))
736                 gamemode = GAME_FNIGGIUM;
737         else if (strstr(name, "setheral"))
738                 gamemode = GAME_SETHERAL;
739         else if (strstr(name, "som"))
740                 gamemode = GAME_SOM;
741         else if (strstr(name, "tenebrae"))
742                 gamemode = GAME_TENEBRAE;
743         else if (strstr(name, "neoteric"))
744                 gamemode = GAME_NEOTERIC;
745         else
746                 gamemode = GAME_NORMAL;
747
748         if (COM_CheckParm ("-transfusion"))
749                 gamemode = GAME_TRANSFUSION;
750         else if (COM_CheckParm ("-nexuiz"))
751                 gamemode = GAME_NEXUIZ;
752         else if (COM_CheckParm ("-nehahra"))
753                 gamemode = GAME_NEHAHRA;
754         else if (COM_CheckParm ("-hipnotic"))
755                 gamemode = GAME_HIPNOTIC;
756         else if (COM_CheckParm ("-rogue"))
757                 gamemode = GAME_ROGUE;
758         else if (COM_CheckParm ("-quake"))
759                 gamemode = GAME_NORMAL;
760         else if (COM_CheckParm ("-goodvsbad2"))
761                 gamemode = GAME_GOODVSBAD2;
762         else if (COM_CheckParm ("-teu"))
763                 gamemode = GAME_TEU;
764         else if (COM_CheckParm ("-battlemech"))
765                 gamemode = GAME_BATTLEMECH;
766         else if (COM_CheckParm ("-zymotic"))
767                 gamemode = GAME_ZYMOTIC;
768         else if (COM_CheckParm ("-fniggium"))
769                 gamemode = GAME_FNIGGIUM;
770         else if (COM_CheckParm ("-setheral"))
771                 gamemode = GAME_SETHERAL;
772         else if (COM_CheckParm ("-som"))
773                 gamemode = GAME_SOM;
774         else if (COM_CheckParm ("-tenebrae"))
775                 gamemode = GAME_TENEBRAE;
776         else if (COM_CheckParm ("-neoteric"))
777                 gamemode = GAME_NEOTERIC;
778
779         switch(gamemode)
780         {
781         case GAME_NORMAL:
782                 gamename = "DarkPlaces-Quake";
783                 gamedirname = "";
784                 gamescreenshotname = "dp";
785                 break;
786         case GAME_HIPNOTIC:
787                 gamename = "Darkplaces-Hipnotic";
788                 gamedirname = "hipnotic";
789                 gamescreenshotname = "dp";
790                 break;
791         case GAME_ROGUE:
792                 gamename = "Darkplaces-Rogue";
793                 gamedirname = "rogue";
794                 gamescreenshotname = "dp";
795                 break;
796         case GAME_NEHAHRA:
797                 gamename = "DarkPlaces-Nehahra";
798                 gamedirname = "nehahra";
799                 gamescreenshotname = "dp";
800                 break;
801         case GAME_NEXUIZ:
802                 gamename = "Nexuiz";
803                 gamedirname = "data";
804                 gamescreenshotname = "nexuiz";
805                 break;
806         case GAME_TRANSFUSION:
807                 gamename = "Transfusion";
808                 gamedirname = "basetf";
809                 gamescreenshotname = "transfusion";
810                 break;
811         case GAME_GOODVSBAD2:
812                 gamename = "GoodVs.Bad2";
813                 gamedirname = "rts";
814                 gamescreenshotname = "gvb2";
815                 break;
816         case GAME_TEU:
817                 gamename = "TheEvilUnleashed";
818                 gamedirname = "baseteu";
819                 gamescreenshotname = "teu";
820                 break;
821         case GAME_BATTLEMECH:
822                 gamename = "Battlemech";
823                 gamedirname = "base";
824                 gamescreenshotname = "battlemech";
825                 break;
826         case GAME_ZYMOTIC:
827                 gamename = "Zymotic";
828                 gamedirname = "data";
829                 gamescreenshotname = "zymotic";
830                 break;
831         case GAME_FNIGGIUM:
832                 gamename = "Fniggium";
833                 gamedirname = "data";
834                 gamescreenshotname = "fniggium";
835                 break;
836         case GAME_SETHERAL:
837                 gamename = "Setheral";
838                 gamedirname = "data";
839                 gamescreenshotname = "setheral";
840                 break;
841         case GAME_SOM:
842                 gamename = "Son of Man";
843                 gamedirname = "sonofman";
844                 gamescreenshotname = "som";
845                 break;
846         case GAME_TENEBRAE:
847                 gamename = "DarkPlaces-Tenebrae";
848                 gamedirname = "tenebrae";
849                 gamescreenshotname = "dp";
850                 break;
851         case GAME_NEOTERIC:
852                 gamename = "Neoteric";
853                 gamedirname = "neobase";
854                 gamescreenshotname = "neo";
855                 break;
856         default:
857                 Sys_Error("COM_InitGameType: unknown gamemode %i\n", gamemode);
858                 break;
859         }
860 }
861
862
863 extern void Mathlib_Init(void);
864 extern void FS_Init (void);
865
866 /*
867 ================
868 COM_Init
869 ================
870 */
871 void COM_Init (void)
872 {
873         Cvar_RegisterVariable (&registered);
874         Cvar_RegisterVariable (&cmdline);
875
876         Mathlib_Init();
877
878         FS_Init ();
879         Log_Init ();
880         COM_CheckRegistered ();
881 }
882
883
884 /*
885 ============
886 va
887
888 does a varargs printf into a temp buffer, so I don't need to have
889 varargs versions of all text functions.
890 FIXME: make this buffer size safe someday
891 ============
892 */
893 char *va(const char *format, ...)
894 {
895         va_list argptr;
896         // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
897         static char string[8][1024], *s;
898         static int stringindex = 0;
899
900         s = string[stringindex];
901         stringindex = (stringindex + 1) & 7;
902         va_start (argptr, format);
903         vsnprintf (s, sizeof (string[0]), format,argptr);
904         va_end (argptr);
905
906         return s;
907 }
908
909
910 //======================================
911
912 void COM_ToLowerString (const char *in, char *out, size_t size_out)
913 {
914         if (size_out == 0)
915                 return;
916
917         while (*in && size_out > 1)
918         {
919                 if (*in >= 'A' && *in <= 'Z')
920                         *out++ = *in++ + 'a' - 'A';
921                 else
922                         *out++ = *in++;
923                 size_out--;
924         }
925         *out = '\0';
926 }
927
928 void COM_ToUpperString (const char *in, char *out, size_t size_out)
929 {
930         if (size_out == 0)
931                 return;
932
933         while (*in && size_out > 1)
934         {
935                 if (*in >= 'a' && *in <= 'z')
936                         *out++ = *in++ + 'A' - 'a';
937                 else
938                         *out++ = *in++;
939                 size_out--;
940         }
941         *out = '\0';
942 }
943
944 int COM_StringBeginsWith(const char *s, const char *match)
945 {
946         for (;*s && *match;s++, match++)
947                 if (*s != *match)
948                         return false;
949         return true;
950 }
951
952 int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
953 {
954         int argc, commentprefixlength;
955         char *tokenbufend;
956         const char *l;
957         argc = 0;
958         tokenbufend = tokenbuf + tokenbufsize;
959         l = *text;
960         commentprefixlength = 0;
961         if (commentprefix)
962                 commentprefixlength = strlen(commentprefix);
963         while (*l && *l != '\n')
964         {
965                 if (*l > ' ')
966                 {
967                         if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
968                         {
969                                 while (*l && *l != '\n')
970                                         l++;
971                                 break;
972                         }
973                         if (argc >= maxargc)
974                                 return -1;
975                         argv[argc++] = tokenbuf;
976                         if (*l == '"')
977                         {
978                                 l++;
979                                 while (*l && *l != '"')
980                                 {
981                                         if (tokenbuf >= tokenbufend)
982                                                 return -1;
983                                         *tokenbuf++ = *l++;
984                                 }
985                                 if (*l == '"')
986                                         l++;
987                         }
988                         else
989                         {
990                                 while (*l > ' ')
991                                 {
992                                         if (tokenbuf >= tokenbufend)
993                                                 return -1;
994                                         *tokenbuf++ = *l++;
995                                 }
996                         }
997                         if (tokenbuf >= tokenbufend)
998                                 return -1;
999                         *tokenbuf++ = 0;
1000                 }
1001                 else
1002                         l++;
1003         }
1004         if (*l == '\n')
1005                 l++;
1006         *text = l;
1007         return argc;
1008 }
1009
1010 // written by Elric, thanks Elric!
1011 char *SearchInfostring(const char *infostring, const char *key)
1012 {
1013         static char value [256];
1014         char crt_key [256];
1015         size_t value_ind, key_ind;
1016         char c;
1017
1018         if (*infostring++ != '\\')
1019                 return NULL;
1020
1021         value_ind = 0;
1022         for (;;)
1023         {
1024                 key_ind = 0;
1025
1026                 // Get the key name
1027                 for (;;)
1028                 {
1029                         c = *infostring++;
1030
1031                         if (c == '\0')
1032                                 return NULL;
1033                         if (c == '\\' || key_ind == sizeof (crt_key) - 1)
1034                         {
1035                                 crt_key[key_ind] = '\0';
1036                                 break;
1037                         }
1038
1039                         crt_key[key_ind++] = c;
1040                 }
1041
1042                 // If it's the key we are looking for, save it in "value"
1043                 if (!strcmp(crt_key, key))
1044                 {
1045                         for (;;)
1046                         {
1047                                 c = *infostring++;
1048
1049                                 if (c == '\0' || c == '\\' || value_ind == sizeof (value) - 1)
1050                                 {
1051                                         value[value_ind] = '\0';
1052                                         return value;
1053                                 }
1054
1055                                 value[value_ind++] = c;
1056                         }
1057                 }
1058
1059                 // Else, skip the value
1060                 for (;;)
1061                 {
1062                         c = *infostring++;
1063
1064                         if (c == '\0')
1065                                 return NULL;
1066                         if (c == '\\')
1067                                 break;
1068                 }
1069         }
1070 }
1071
1072
1073 //========================================================
1074 // strlcat and strlcpy, from OpenBSD
1075
1076 /*
1077  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
1078  *
1079  * Permission to use, copy, modify, and distribute this software for any
1080  * purpose with or without fee is hereby granted, provided that the above
1081  * copyright notice and this permission notice appear in all copies.
1082  *
1083  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1084  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1085  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1086  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1087  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1088  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1089  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1090  */
1091
1092 /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
1093 /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
1094
1095
1096 #ifndef HAVE_STRLCAT
1097 size_t
1098 strlcat(char *dst, const char *src, size_t siz)
1099 {
1100         register char *d = dst;
1101         register const char *s = src;
1102         register size_t n = siz;
1103         size_t dlen;
1104
1105         /* Find the end of dst and adjust bytes left but don't go past end */
1106         while (n-- != 0 && *d != '\0')
1107                 d++;
1108         dlen = d - dst;
1109         n = siz - dlen;
1110
1111         if (n == 0)
1112                 return(dlen + strlen(s));
1113         while (*s != '\0') {
1114                 if (n != 1) {
1115                         *d++ = *s;
1116                         n--;
1117                 }
1118                 s++;
1119         }
1120         *d = '\0';
1121
1122         return(dlen + (s - src));       /* count does not include NUL */
1123 }
1124 #endif  // #ifndef HAVE_STRLCAT
1125
1126
1127 #ifndef HAVE_STRLCPY
1128 size_t
1129 strlcpy(char *dst, const char *src, size_t siz)
1130 {
1131         register char *d = dst;
1132         register const char *s = src;
1133         register size_t n = siz;
1134
1135         /* Copy as many bytes as will fit */
1136         if (n != 0 && --n != 0) {
1137                 do {
1138                         if ((*d++ = *s++) == 0)
1139                                 break;
1140                 } while (--n != 0);
1141         }
1142
1143         /* Not enough room in dst, add NUL and traverse rest of src */
1144         if (n == 0) {
1145                 if (siz != 0)
1146                         *d = '\0';              /* NUL-terminate dst */
1147                 while (*s++)
1148                         ;
1149         }
1150
1151         return(s - src - 1);    /* count does not include NUL */
1152 }
1153
1154 #endif  // #ifndef HAVE_STRLCPY