char com_cmdline[CMDLINE_LENGTH];
int gamemode;
-char *gamename;
-char *gamedirname;
-char com_modname[MAX_OSPATH];
+const char *gamename;
+const char *gamedirname;
+const char *gamescreenshotname;
+char com_modname[MAX_OSPATH] = "";
/*
============================================================================
*/
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short (*BigShort) (short l);
-short (*LittleShort) (short l);
-int (*BigLong) (int l);
-int (*LittleLong) (int l);
-float (*BigFloat) (float l);
-float (*LittleFloat) (float l);
-#endif
-
short ShortSwap (short l)
{
qbyte b1,b2;
return (b1<<8) + b2;
}
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short ShortNoSwap (short l)
-{
- return l;
-}
-#endif
-
int LongSwap (int l)
{
qbyte b1,b2,b3,b4;
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
}
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-int LongNoSwap (int l)
-{
- return l;
-}
-#endif
-
float FloatSwap (float f)
{
union
return dat2.f;
}
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-float FloatNoSwap (float f)
-{
- return f;
-}
-#endif
-
// Extract integers from buffers
void MSG_WriteChar (sizebuf_t *sb, int c)
{
qbyte *buf;
-
+
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteByte (sizebuf_t *sb, int c)
{
qbyte *buf;
-
+
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
SZ_Write (sb, s, strlen(s)+1);
}
-// used by server (always latest dpprotocol)
-void MSG_WriteDPCoord (sizebuf_t *sb, float f)
+void MSG_WriteCoord13i (sizebuf_t *sb, float f)
{
if (f >= 0)
- MSG_WriteShort (sb, (int)(f + 0.5f));
+ MSG_WriteShort (sb, (int)(f * 8.0 + 0.5));
else
- MSG_WriteShort (sb, (int)(f - 0.5f));
+ MSG_WriteShort (sb, (int)(f * 8.0 - 0.5));
}
-void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
+void MSG_WriteCoord16i (sizebuf_t *sb, float f)
{
if (f >= 0)
- MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
+ MSG_WriteShort (sb, (int)(f + 0.5));
+ else
+ MSG_WriteShort (sb, (int)(f - 0.5));
+}
+
+void MSG_WriteCoord32f (sizebuf_t *sb, float f)
+{
+ MSG_WriteFloat (sb, f);
+}
+
+void MSG_WriteCoord (sizebuf_t *sb, float f, int protocol)
+{
+ if (protocol == PROTOCOL_QUAKE)
+ MSG_WriteCoord13i (sb, f);
+ else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
+ MSG_WriteCoord32f (sb, f);
+ else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
+ MSG_WriteCoord16i (sb, f);
else
- MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
+ Host_Error("MSG_WriteCoord: unknown protocol\n");
+}
+
+void MSG_WriteVector (sizebuf_t *sb, float *v, int protocol)
+{
+ MSG_WriteCoord (sb, v[0], protocol);
+ MSG_WriteCoord (sb, v[1], protocol);
+ MSG_WriteCoord (sb, v[2], protocol);
}
// LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
-void MSG_WriteAngle (sizebuf_t *sb, float f)
+void MSG_WriteAngle8i (sizebuf_t *sb, float f)
{
if (f >= 0)
- MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
+ MSG_WriteByte (sb, (int)(f*(256.0/360.0) + 0.5) & 255);
else
- MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
+ MSG_WriteByte (sb, (int)(f*(256.0/360.0) - 0.5) & 255);
+}
+
+void MSG_WriteAngle16i (sizebuf_t *sb, float f)
+{
+ if (f >= 0)
+ MSG_WriteShort (sb, (int)(f*(65536.0/360.0) + 0.5) & 65535);
+ else
+ MSG_WriteShort (sb, (int)(f*(65536.0/360.0) - 0.5) & 65535);
+}
+
+void MSG_WriteAngle32f (sizebuf_t *sb, float f)
+{
+ MSG_WriteFloat (sb, f);
+}
+
+void MSG_WriteAngle (sizebuf_t *sb, float f, int protocol)
+{
+ if (protocol == PROTOCOL_DARKPLACES5)
+ MSG_WriteAngle16i (sb, f);
+ else
+ MSG_WriteAngle8i (sb, f);
}
//
msg_badread = false;
}
-int MSG_ReadShort (void)
+int MSG_ReadLittleShort (void)
{
- int c;
-
if (msg_readcount+2 > net_message.cursize)
{
msg_badread = true;
return -1;
}
-
- c = (short)(net_message.data[msg_readcount]
- + (net_message.data[msg_readcount+1]<<8));
-
msg_readcount += 2;
-
- return c;
+ return (short)(net_message.data[msg_readcount-2] | (net_message.data[msg_readcount-1]<<8));
}
-int MSG_ReadLong (void)
+int MSG_ReadBigShort (void)
{
- int c;
+ if (msg_readcount+2 > net_message.cursize)
+ {
+ msg_badread = true;
+ return -1;
+ }
+ msg_readcount += 2;
+ return (short)((net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1]);
+}
+int MSG_ReadLittleLong (void)
+{
if (msg_readcount+4 > net_message.cursize)
{
msg_badread = true;
return -1;
}
-
- c = net_message.data[msg_readcount]
- + (net_message.data[msg_readcount+1]<<8)
- + (net_message.data[msg_readcount+2]<<16)
- + (net_message.data[msg_readcount+3]<<24);
-
msg_readcount += 4;
+ 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);
+}
- return c;
+int MSG_ReadBigLong (void)
+{
+ if (msg_readcount+4 > net_message.cursize)
+ {
+ msg_badread = true;
+ return -1;
+ }
+ msg_readcount += 4;
+ 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];
}
-float MSG_ReadFloat (void)
+float MSG_ReadLittleFloat (void)
{
union
{
- qbyte b[4];
float f;
int l;
} dat;
-
- dat.b[0] = net_message.data[msg_readcount];
- dat.b[1] = net_message.data[msg_readcount+1];
- dat.b[2] = net_message.data[msg_readcount+2];
- dat.b[3] = net_message.data[msg_readcount+3];
+ if (msg_readcount+4 > net_message.cursize)
+ {
+ msg_badread = true;
+ return -1;
+ }
msg_readcount += 4;
+ 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);
+ return dat.f;
+}
- dat.l = LittleLong (dat.l);
-
+float MSG_ReadBigFloat (void)
+{
+ union
+ {
+ float f;
+ int l;
+ } dat;
+ if (msg_readcount+4 > net_message.cursize)
+ {
+ msg_badread = true;
+ return -1;
+ }
+ msg_readcount += 4;
+ 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];
return dat.f;
}
{
static char string[2048];
int l,c;
-
- l = 0;
- do
- {
- c = MSG_ReadChar ();
- if (c == -1 || c == 0)
- break;
+ for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
string[l] = c;
- l++;
- } while (l < (int)sizeof(string)-1);
-
string[l] = 0;
-
return string;
}
-// used by server (always latest dpprotocol)
-float MSG_ReadDPCoord (void)
+int MSG_ReadBytes (int numbytes, unsigned char *out)
+{
+ int l, c;
+ for (l = 0;l < numbytes && (c = MSG_ReadChar()) != -1;l++)
+ out[l] = c;
+ return l;
+}
+
+float MSG_ReadCoord13i (void)
{
- return (signed short) MSG_ReadShort();
+ return MSG_ReadLittleShort() * (1.0/8.0);
}
-// used by client
-float MSG_ReadCoord (void)
+float MSG_ReadCoord16i (void)
{
- if (dpprotocol == DPPROTOCOL_VERSION2 || dpprotocol == DPPROTOCOL_VERSION3)
- return (signed short) MSG_ReadShort();
- else if (dpprotocol == DPPROTOCOL_VERSION1)
- return MSG_ReadFloat();
+ return (signed short) MSG_ReadLittleShort();
+}
+
+float MSG_ReadCoord32f (void)
+{
+ return MSG_ReadLittleFloat();
+}
+
+float MSG_ReadCoord (int protocol)
+{
+ if (protocol == PROTOCOL_QUAKE)
+ return MSG_ReadCoord13i();
+ else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
+ return MSG_ReadCoord32f();
+ else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
+ return MSG_ReadCoord16i();
+ Host_Error("MSG_ReadCoord: unknown protocol\n");
+ return 0;
+}
+
+void MSG_ReadVector (float *v, int protocol)
+{
+ v[0] = MSG_ReadCoord(protocol);
+ v[1] = MSG_ReadCoord(protocol);
+ v[2] = MSG_ReadCoord(protocol);
+}
+
+// LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
+float MSG_ReadAngle8i (void)
+{
+ return (signed char) MSG_ReadByte () * (360.0/256.0);
+}
+
+float MSG_ReadAngle16i (void)
+{
+ return (signed short)MSG_ReadShort () * (360.0/65536.0);
+}
+
+float MSG_ReadAngle32f (void)
+{
+ return MSG_ReadFloat ();
+}
+
+float MSG_ReadAngle (int protocol)
+{
+ if (protocol == PROTOCOL_DARKPLACES5)
+ return MSG_ReadAngle16i ();
else
- return MSG_ReadShort() * (1.0f/8.0f);
+ return MSG_ReadAngle8i ();
}
{
if (startsize < 256)
startsize = 256;
- buf->mempool = Mem_AllocPool(name);
+ buf->mempool = Mem_AllocPool(name, 0, NULL);
buf->data = Mem_Alloc(buf->mempool, startsize);
buf->maxsize = startsize;
buf->cursize = 0;
Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
buf->overflowed = true;
- Con_Printf ("SZ_GetSpace: overflow\n");
+ Con_Print("SZ_GetSpace: overflow\n");
SZ_Clear (buf);
}
memcpy (SZ_GetSpace(buf,length),data,length);
}
-void SZ_Print (sizebuf_t *buf, const char *data)
-{
- int len;
- len = strlen(data)+1;
-
-// byte * cast to keep VC++ happy
- if (buf->data[buf->cursize-1])
- memcpy ((qbyte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
- else
- memcpy ((qbyte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
-}
+// LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
+// attention, it has been eradicated from here, its only (former) use in
+// all of darkplaces.
static char *hexchar = "0123456789ABCDEF";
void Com_HexDumpToConsole(const qbyte *data, int size)
if (n > size - i)
n = size - i;
d = data + i;
+ // print offset
*cur++ = hexchar[(i >> 12) & 15];
*cur++ = hexchar[(i >> 8) & 15];
*cur++ = hexchar[(i >> 4) & 15];
*cur++ = hexchar[(i >> 0) & 15];
*cur++ = ':';
- for (j = 0;j < n;j++)
+ // print hex
+ for (j = 0;j < 16;j++)
{
- if (j & 1)
+ if (j < n)
{
- *cur++ = hexchar[(d[j] >> 4) & 15] | 0x80;
- *cur++ = hexchar[(d[j] >> 0) & 15] | 0x80;
+ *cur++ = hexchar[(d[j] >> 4) & 15];
+ *cur++ = hexchar[(d[j] >> 0) & 15];
}
else
{
- *cur++ = hexchar[(d[j] >> 4) & 15];
- *cur++ = hexchar[(d[j] >> 0) & 15];
+ *cur++ = ' ';
+ *cur++ = ' ';
}
+ if ((j & 3) == 3)
+ *cur++ = ' ';
}
- for (;j < 16;j++)
+ // print text
+ for (j = 0;j < 16;j++)
{
- *cur++ = ' ';
- *cur++ = ' ';
+ if (j < n)
+ {
+ if (d[j] >= ' ' && d[j] <= 127)
+ *cur++ = d[j];
+ else
+ *cur++ = '.';
+ }
+ else
+ *cur++ = ' ';
}
- for (j = 0;j < n;j++)
- *cur++ = (d[j] >= ' ' && d[j] <= 0x7E) ? d[j] : '.';
- for (;j < 16;j++)
- *cur++ = ' ';
*cur++ = '\n';
i += n;
if (cur >= flushpointer || i >= size)
{
*cur++ = 0;
- Con_Printf("%s", text);
+ Con_Print(text);
cur = text;
}
}
Parse a token out of a string
==============
*/
-int COM_ParseToken (const char **datapointer)
+int COM_ParseToken(const char **datapointer, int returnnewline)
{
- int c;
int len;
const char *data = *datapointer;
// skip whitespace
skipwhite:
- while ((c = *data) <= ' ')
+ for (;*data <= ' ' && (*data != '\n' || !returnnewline);data++)
{
- if (c == 0)
+ if (*data == 0)
{
// end of file
*datapointer = NULL;
return false;
}
- data++;
}
-// skip // comments
- if (c=='/' && data[1] == '/')
+ if (data[0] == '/' && data[1] == '/')
{
+ // comment
while (*data && *data != '\n')
data++;
goto skipwhite;
}
-
-
-// handle quoted strings specially
- if (c == '\"')
+ else if (data[0] == '/' && data[1] == '*')
{
+ // comment
data++;
- while (1)
+ while (*data && (data[0] != '*' || data[1] != '/'))
+ data++;
+ data += 2;
+ goto skipwhite;
+ }
+ else if (*data == '\"')
+ {
+ // quoted string
+ for (data++;*data != '\"';data++)
{
- c = *data++;
- if (c=='\"' || !c)
+ if (!*data || len >= (int)sizeof(com_token) - 1)
{
- com_token[len] = 0;
- *datapointer = data;
- return true;
+ com_token[0] = 0;
+ *datapointer = NULL;
+ return false;
}
- com_token[len] = c;
- len++;
+ com_token[len++] = *data;
}
+ com_token[len] = 0;
+ *datapointer = data+1;
+ return true;
}
-
-// parse single characters
- if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
+ else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
{
- com_token[len] = c;
- len++;
+ // single character
+ com_token[len++] = *data++;
com_token[len] = 0;
- *datapointer = data+1;
+ *datapointer = data;
+ return true;
+ }
+ else
+ {
+ // regular word
+ for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';';data++)
+ {
+ if (len >= (int)sizeof(com_token) - 1)
+ {
+ com_token[0] = 0;
+ *datapointer = NULL;
+ return false;
+ }
+ com_token[len++] = *data;
+ }
+ com_token[len] = 0;
+ *datapointer = data;
return true;
}
+}
+
+/*
+==============
+COM_ParseTokenConsole
+
+Parse a token out of a string, behaving like the qwcl console
+==============
+*/
+int COM_ParseTokenConsole(const char **datapointer)
+{
+ int len;
+ const char *data = *datapointer;
-// parse a regular word
- do
+ len = 0;
+ com_token[0] = 0;
+
+ if (!data)
{
- com_token[len] = c;
- data++;
- len++;
- c = *data;
- if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
- break;
- } while (c>32);
+ *datapointer = NULL;
+ return false;
+ }
- com_token[len] = 0;
- *datapointer = data;
- return true;
+// skip whitespace
+skipwhite:
+ for (;*data <= ' ';data++)
+ {
+ if (*data == 0)
+ {
+ // end of file
+ *datapointer = NULL;
+ return false;
+ }
+ }
+
+ if (*data == '/' && data[1] == '/')
+ {
+ // comment
+ while (*data && *data != '\n')
+ data++;
+ goto skipwhite;
+ }
+ else if (*data == '\"')
+ {
+ // quoted string
+ for (data++;*data != '\"';data++)
+ {
+ if (!*data || len >= (int)sizeof(com_token) - 1)
+ {
+ com_token[0] = 0;
+ *datapointer = NULL;
+ return false;
+ }
+ com_token[len++] = *data;
+ }
+ com_token[len] = 0;
+ *datapointer = data+1;
+ return true;
+ }
+ else
+ {
+ // regular word
+ for (;*data > ' ';data++)
+ {
+ if (len >= (int)sizeof(com_token) - 1)
+ {
+ com_token[0] = 0;
+ *datapointer = NULL;
+ return false;
+ }
+ com_token[len++] = *data;
+ }
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
}
if (!FS_FileExists("gfx/pop.lmp"))
{
if (fs_modified)
- Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+ Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
else
- Con_Printf ("Playing shareware version.\n");
+ Con_Print("Playing shareware version.\n");
return;
}
Cvar_Set ("registered", "1");
- Con_Printf ("Playing registered version.\n");
+ Con_Print("Playing registered version.\n");
}
for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
{
i = 0;
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
- com_cmdline[n++] = com_argv[j][i++];
+ if (strstr(com_argv[j], " "))
+ {
+ // arg contains whitespace, store quotes around it
+ com_cmdline[n++] = '\"';
+ while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ com_cmdline[n++] = com_argv[j][i++];
+ com_cmdline[n++] = '\"';
+ }
+ else
+ {
+ while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ com_cmdline[n++] = com_argv[j][i++];
+ }
if (n < (CMDLINE_LENGTH - 1))
com_cmdline[n++] = ' ';
else
com_cmdline[n] = 0;
}
+
+//===========================================================================
+
+// Game mods
+
+typedef struct
+{
+ const char* prog_name;
+ const char* cmdline;
+ const char* gamename;
+ const char* gamedirname;
+ const char* gamescreenshotname;
+} gamemode_info_t;
+
+static const gamemode_info_t gamemode_info [] =
+{// prog_name cmdline gamename gamedirname gamescreenshotname
+
+// GAME_NORMAL
+// COMMANDLINEOPTION: -quake runs the game Quake (default)
+{ "", "-quake", "DarkPlaces-Quake", "", "dp" },
+// GAME_HIPNOTIC
+// COMMANDLINEOPTION: -hipnotic runs Quake mission pack 1: The Scourge of Armagon
+{ "hipnotic", "-hipnotic", "Darkplaces-Hipnotic", "hipnotic", "dp" },
+// GAME_ROGUE
+// COMMANDLINEOPTION: -rogue runs Quake mission pack 2: The Dissolution of Eternity
+{ "rogue", "-rogue", "Darkplaces-Rogue", "rogue", "dp" },
+// GAME_NEHAHRA
+// COMMANDLINEOPTION: -nehahra runs The Seal of Nehahra movie and game
+{ "nehahra", "-nehahra", "DarkPlaces-Nehahra", "nehahra", "dp" },
+// GAME_NEXUIZ
+// COMMANDLINEOPTION: -nexuiz runs the multiplayer game Nexuiz
+{ "nexuiz", "-nexuiz", "Nexuiz", "data", "nexuiz" },
+// GAME_TRANSFUSION
+// COMMANDLINEOPTION: -transfusion runs Transfusion (the recreation of Blood in Quake)
+{ "transfusion", "-transfusion", "Transfusion", "basetf", "transfusion" },
+// GAME_GOODVSBAD2
+// COMMANDLINEOPTION: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2
+{ "gvb2", "-goodvsbad2", "GoodVs.Bad2", "rts", "gvb2" },
+// GAME_TEU
+// COMMANDLINEOPTION: -teu runs The Evil Unleashed (this option is obsolete as they are not using darkplaces)
+{ "teu", "-teu", "TheEvilUnleashed", "baseteu", "teu" },
+// GAME_BATTLEMECH
+// COMMANDLINEOPTION: -battlemech runs the multiplayer topdown deathmatch game BattleMech
+{ "battlemech", "-battlemech", "Battlemech", "base", "battlemech" },
+// GAME_ZYMOTIC
+// COMMANDLINEOPTION: -zymotic runs the singleplayer game Zymotic
+{ "zymotic", "-zymotic", "Zymotic", "data", "zymotic" },
+// GAME_FNIGGIUM
+// COMMANDLINEOPTION: -fniggium runs the post apocalyptic melee RPG Fniggium
+{ "fniggium", "-fniggium", "Fniggium", "data", "fniggium" },
+// GAME_SETHERAL
+// COMMANDLINEOPTION: -setheral runs the multiplayer game Setheral
+{ "setheral", "-setheral", "Setheral", "data", "setheral" },
+// GAME_SOM
+// COMMANDLINEOPTION: -som runs the multiplayer game Son Of Man
+{ "som", "-som", "Son of Man", "sonofman", "som" },
+// GAME_TENEBRAE
+// COMMANDLINEOPTION: -tenebrae runs the graphics test mod known as Tenebrae (some features not implemented)
+{ "tenebrae", "-tenebrae", "DarkPlaces-Tenebrae", "tenebrae", "dp" },
+// GAME_NEOTERIC
+// COMMANDLINEOPTION: -neoteric runs the game Neoteric
+{ "neoteric", "-neoteric", "Neoteric", "neobase", "neo" },
+// GAME_OPENQUARTZ
+// COMMANDLINEOPTION: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
+{ "openquartz", "-openquartz", "OpenQuartz", "id1", "openquartz"},
+// GAME_PRYDON
+// COMMANDLINEOPTION: -prydon runs the topdown point and click action-RPG Prydon Gate
+{ "prydon", "-prydon", "PrydonGate", "prydon", "prydon"},
+// GAME_NETHERWORLD
+// COMMANDLINEOPTION: -netherworld runs the game Netherworld: Dark Masters
+{ "netherworld", "-netherworld", "Dark Masters", "netherworld", "nw"},
+};
+
void COM_InitGameType (void)
{
- char name[MAX_OSPATH];
- FS_StripExtension(com_argv[0], name);
- COM_ToLowerString(name, name);
-
- if (strstr(name, "transfusion"))
- gamemode = GAME_TRANSFUSION;
- else if (strstr(name, "nexiuz"))
- gamemode = GAME_NEXIUZ;
- else if (strstr(name, "nehahra"))
- gamemode = GAME_NEHAHRA;
- else if (strstr(name, "hipnotic"))
- gamemode = GAME_HIPNOTIC;
- else if (strstr(name, "rogue"))
- gamemode = GAME_ROGUE;
- else
- gamemode = GAME_NORMAL;
-
- if (COM_CheckParm ("-transfusion"))
- gamemode = GAME_TRANSFUSION;
- else if (COM_CheckParm ("-nexiuz"))
- gamemode = GAME_NEXIUZ;
- else if (COM_CheckParm ("-nehahra"))
- gamemode = GAME_NEHAHRA;
- else if (COM_CheckParm ("-hipnotic"))
- gamemode = GAME_HIPNOTIC;
- else if (COM_CheckParm ("-rogue"))
- gamemode = GAME_ROGUE;
- else if (COM_CheckParm ("-quake"))
- gamemode = GAME_NORMAL;
-
- switch(gamemode)
- {
- case GAME_NORMAL:
- gamename = "DarkPlaces-Quake";
- gamedirname = "";
- break;
- case GAME_HIPNOTIC:
- gamename = "Darkplaces-Hipnotic";
- gamedirname = "hipnotic";
- break;
- case GAME_ROGUE:
- gamename = "Darkplaces-Rogue";
- gamedirname = "rogue";
- break;
- case GAME_NEHAHRA:
- gamename = "DarkPlaces-Nehahra";
- gamedirname = "nehahra";
- break;
- case GAME_NEXIUZ:
- gamename = "Nexiuz";
- gamedirname = "data";
- break;
- case GAME_TRANSFUSION:
- gamename = "Transfusion";
- gamedirname = "transfusion";
- break;
- default:
- Sys_Error("COM_InitGameType: unknown gamemode %i\n", gamemode);
- break;
- }
+ char name [MAX_OSPATH];
+ unsigned int i;
+
+ FS_StripExtension (com_argv[0], name, sizeof (name));
+ COM_ToLowerString (name, name, sizeof (name));
+
+ // Check the binary name; default to GAME_NORMAL (0)
+ gamemode = GAME_NORMAL;
+ for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
+ if (strstr (name, gamemode_info[i].prog_name))
+ {
+ gamemode = i;
+ break;
+ }
+
+ // Look for a command-line option
+ for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
+ if (COM_CheckParm (gamemode_info[i].cmdline))
+ {
+ gamemode = i;
+ break;
+ }
+
+ gamename = gamemode_info[gamemode].gamename;
+ gamedirname = gamemode_info[gamemode].gamedirname;
+ gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
}
*/
void COM_Init (void)
{
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
- qbyte swaptest[2] = {1,0};
-
-// set the byte swapping variables in a portable manner
- if ( *(short *)swaptest == 1)
- {
- BigShort = ShortSwap;
- LittleShort = ShortNoSwap;
- BigLong = LongSwap;
- LittleLong = LongNoSwap;
- BigFloat = FloatSwap;
- LittleFloat = FloatNoSwap;
- }
- else
- {
- BigShort = ShortNoSwap;
- LittleShort = ShortSwap;
- BigLong = LongNoSwap;
- LittleLong = LongSwap;
- BigFloat = FloatNoSwap;
- LittleFloat = FloatSwap;
- }
-#endif
-
Cvar_RegisterVariable (®istered);
Cvar_RegisterVariable (&cmdline);
Mathlib_Init();
FS_Init ();
+ Log_Init ();
COM_CheckRegistered ();
-
- COM_InitGameType();
}
s = string[stringindex];
stringindex = (stringindex + 1) & 7;
va_start (argptr, format);
- vsprintf (s, format,argptr);
+ vsnprintf (s, sizeof (string[0]), format,argptr);
va_end (argptr);
return s;
//======================================
-// LordHavoc: added these because they are useful
-void COM_ToLowerString(const char *in, char *out)
+void COM_ToLowerString (const char *in, char *out, size_t size_out)
{
- while (*in)
+ if (size_out == 0)
+ return;
+
+ while (*in && size_out > 1)
{
if (*in >= 'A' && *in <= 'Z')
*out++ = *in++ + 'a' - 'A';
else
*out++ = *in++;
+ size_out--;
}
+ *out = '\0';
}
-void COM_ToUpperString(const char *in, char *out)
+void COM_ToUpperString (const char *in, char *out, size_t size_out)
{
- while (*in)
+ if (size_out == 0)
+ return;
+
+ while (*in && size_out > 1)
{
if (*in >= 'a' && *in <= 'z')
*out++ = *in++ + 'A' - 'a';
else
*out++ = *in++;
+ size_out--;
}
+ *out = '\0';
}
int COM_StringBeginsWith(const char *s, const char *match)
return false;
return true;
}
+
+int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
+{
+ int argc, commentprefixlength;
+ char *tokenbufend;
+ const char *l;
+ argc = 0;
+ tokenbufend = tokenbuf + tokenbufsize;
+ l = *text;
+ commentprefixlength = 0;
+ if (commentprefix)
+ commentprefixlength = strlen(commentprefix);
+ while (*l && *l != '\n')
+ {
+ if (*l > ' ')
+ {
+ if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
+ {
+ while (*l && *l != '\n')
+ l++;
+ break;
+ }
+ if (argc >= maxargc)
+ return -1;
+ argv[argc++] = tokenbuf;
+ if (*l == '"')
+ {
+ l++;
+ while (*l && *l != '"')
+ {
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = *l++;
+ }
+ if (*l == '"')
+ l++;
+ }
+ else
+ {
+ while (*l > ' ')
+ {
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = *l++;
+ }
+ }
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = 0;
+ }
+ else
+ l++;
+ }
+ if (*l == '\n')
+ l++;
+ *text = l;
+ return argc;
+}
+
+// written by Elric, thanks Elric!
+char *SearchInfostring(const char *infostring, const char *key)
+{
+ static char value [256];
+ char crt_key [256];
+ size_t value_ind, key_ind;
+ char c;
+
+ if (*infostring++ != '\\')
+ return NULL;
+
+ value_ind = 0;
+ for (;;)
+ {
+ key_ind = 0;
+
+ // Get the key name
+ for (;;)
+ {
+ c = *infostring++;
+
+ if (c == '\0')
+ return NULL;
+ if (c == '\\' || key_ind == sizeof (crt_key) - 1)
+ {
+ crt_key[key_ind] = '\0';
+ break;
+ }
+
+ crt_key[key_ind++] = c;
+ }
+
+ // If it's the key we are looking for, save it in "value"
+ if (!strcmp(crt_key, key))
+ {
+ for (;;)
+ {
+ c = *infostring++;
+
+ if (c == '\0' || c == '\\' || value_ind == sizeof (value) - 1)
+ {
+ value[value_ind] = '\0';
+ return value;
+ }
+
+ value[value_ind++] = c;
+ }
+ }
+
+ // Else, skip the value
+ for (;;)
+ {
+ c = *infostring++;
+
+ if (c == '\0')
+ return NULL;
+ if (c == '\\')
+ break;
+ }
+ }
+}
+
+
+//========================================================
+// strlcat and strlcpy, from OpenBSD
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $ */
+/* $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $ */
+
+
+#ifndef HAVE_STRLCAT
+size_t
+strlcat(char *dst, const char *src, size_t siz)
+{
+ register char *d = dst;
+ register const char *s = src;
+ register size_t n = siz;
+ size_t dlen;
+
+ /* Find the end of dst and adjust bytes left but don't go past end */
+ while (n-- != 0 && *d != '\0')
+ d++;
+ dlen = d - dst;
+ n = siz - dlen;
+
+ if (n == 0)
+ return(dlen + strlen(s));
+ while (*s != '\0') {
+ if (n != 1) {
+ *d++ = *s;
+ n--;
+ }
+ s++;
+ }
+ *d = '\0';
+
+ return(dlen + (s - src)); /* count does not include NUL */
+}
+#endif // #ifndef HAVE_STRLCAT
+
+
+#ifndef HAVE_STRLCPY
+size_t
+strlcpy(char *dst, const char *src, size_t siz)
+{
+ register char *d = dst;
+ register const char *s = src;
+ register size_t n = siz;
+
+ /* Copy as many bytes as will fit */
+ if (n != 0 && --n != 0) {
+ do {
+ if ((*d++ = *s++) == 0)
+ break;
+ } while (--n != 0);
+ }
+
+ /* Not enough room in dst, add NUL and traverse rest of src */
+ if (n == 0) {
+ if (siz != 0)
+ *d = '\0'; /* NUL-terminate dst */
+ while (*s++)
+ ;
+ }
+
+ return(s - src - 1); /* count does not include NUL */
+}
+
+#endif // #ifndef HAVE_STRLCPY
projects / xonotic / darkplaces.git / blobdiff