Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
eb04271c83 | ||
|
|
54e7ad571e |
No files matched your search
@@ -49,7 +49,6 @@
|
||||
# Already enabled by default for 32-bit
|
||||
# Windows.
|
||||
# NOCURL=1 - Disable libcurl--HTTP capability.
|
||||
# NOHOLEPUNCH=1 - Disable holepunch capability.
|
||||
# NOLIBGME=1 - Disable game music emu, retro VGM support.
|
||||
# NOOPENMPT=1 - Disable module (tracker) music support.
|
||||
# NOMIXER=1 - Disable SDL Mixer (audio playback).
|
||||
|
||||
@@ -6,8 +6,7 @@ passthru_opts+=\
|
||||
NOHW NOMD5 NOPOSTPROCESSING\
|
||||
MOBJCONSISTANCY PACKETDROP ZDEBUG\
|
||||
HAVE_MINIUPNPC\
|
||||
HAVE_DISCORDRPC DEVELOP\
|
||||
NOHOLEPUNCH\
|
||||
HAVE_DISCORDRPC DEVELOP
|
||||
|
||||
# build with debugging information
|
||||
ifdef DEBUGMODE
|
||||
|
||||
+2
-4
@@ -24,8 +24,6 @@
|
||||
|
||||
#include "lauxlib.h"
|
||||
|
||||
#include "../doomdef.h"
|
||||
|
||||
|
||||
#define FREELIST_REF 0 /* free list of references */
|
||||
|
||||
@@ -42,7 +40,7 @@ LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
|
||||
if (!lua_getstack(L, 0, &ar)) /* no stack frame? */
|
||||
return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
|
||||
lua_getinfo(L, "n", &ar);
|
||||
if (fastcmp(ar.namewhat, "method")) {
|
||||
if (strcmp(ar.namewhat, "method") == 0) {
|
||||
narg--; /* do not count `self' */
|
||||
if (narg == 0) /* error is in the self argument itself? */
|
||||
return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
|
||||
@@ -99,7 +97,7 @@ LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
|
||||
luaL_checkstring(L, narg);
|
||||
int i;
|
||||
for (i=0; lst[i]; i++)
|
||||
if (fastcmp(lst[i], name))
|
||||
if (strcmp(lst[i], name) == 0)
|
||||
return i;
|
||||
return luaL_argerror(L, narg,
|
||||
lua_pushfstring(L, "invalid option " LUA_QS, name));
|
||||
|
||||
+3
-5
@@ -161,13 +161,12 @@ static int io_tostring (lua_State *L) {
|
||||
|
||||
static int StartsWith(const char *a, const char *b) // this is wolfs being lazy yet again
|
||||
{
|
||||
if (strncmp(a, b, strlen(b)) == 0) return 1;
|
||||
if(strncmp(a, b, strlen(b)) == 0) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int io_open(lua_State *L)
|
||||
{
|
||||
static int io_open (lua_State *L) {
|
||||
FILE **pf;
|
||||
const char *filename = luaL_checkstring(L, 1);
|
||||
int pass = 0;
|
||||
@@ -179,13 +178,12 @@ static int io_open(lua_State *L)
|
||||
|
||||
for (i = 0; i < (sizeof (whitelist) / sizeof(const char *)); i++)
|
||||
{
|
||||
if (fasticmp(&filename[length - strlen(whitelist[i])], whitelist[i]))
|
||||
if (!stricmp(&filename[length - strlen(whitelist[i])], whitelist[i]))
|
||||
{
|
||||
pass = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (l_unlikely(strstr(filename, "..") || strchr(filename, ':') || StartsWith(filename, "\\")
|
||||
|| StartsWith(filename, "/") || !pass))
|
||||
{
|
||||
|
||||
+44
-47
@@ -359,7 +359,7 @@ size_t COM_CheckParm(const char *check)
|
||||
size_t i;
|
||||
|
||||
for (i = 1; i < com_argc; i++)
|
||||
if (fasticmp(check, com_argv[i]))
|
||||
if (!strcasecmp(check, com_argv[i]))
|
||||
return i;
|
||||
return 0;
|
||||
}
|
||||
@@ -456,7 +456,7 @@ void COM_AddCommand(const char *name, com_func_t func)
|
||||
// fail if the command already exists
|
||||
for (cmd = com_commands; cmd; cmd = cmd->next)
|
||||
{
|
||||
if (fasticmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
if (!stricmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
{
|
||||
// don't I_Error for Lua commands
|
||||
// Lua commands can replace game commands, and they have priority.
|
||||
@@ -492,7 +492,7 @@ int COM_AddLuaCommand(const char *name)
|
||||
// command already exists
|
||||
for (cmd = com_commands; cmd; cmd = cmd->next)
|
||||
{
|
||||
if (fasticmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
if (!stricmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
{
|
||||
// replace the built in command.
|
||||
cmd->function = COM_Lua_f;
|
||||
@@ -519,7 +519,7 @@ static boolean COM_Exists(const char *com_name)
|
||||
xcommand_t *cmd;
|
||||
|
||||
for (cmd = com_commands; cmd; cmd = cmd->next)
|
||||
if (fasticmp(com_name, cmd->name))
|
||||
if (!stricmp(com_name, cmd->name))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
@@ -571,7 +571,7 @@ static void COM_ExecuteString(char *ptext)
|
||||
// check functions
|
||||
for (cmd = com_commands; cmd; cmd = cmd->next)
|
||||
{
|
||||
if (fasticmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
if (!stricmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
|
||||
{
|
||||
cmd->function();
|
||||
return;
|
||||
@@ -581,7 +581,7 @@ static void COM_ExecuteString(char *ptext)
|
||||
// check aliases
|
||||
for (a = com_alias; a; a = a->next)
|
||||
{
|
||||
if (fasticmp(com_argv[0], a->name))
|
||||
if (!stricmp(com_argv[0], a->name))
|
||||
{
|
||||
if (recursion > MAX_ALIAS_RECURSION)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Alias recursion cycle detected!\n"));
|
||||
@@ -700,7 +700,6 @@ static void COM_Echo_f(void)
|
||||
|
||||
for (i = 1; i < COM_Argc(); i++)
|
||||
CONS_Printf("%s ", COM_Argv(i));
|
||||
|
||||
CONS_Printf("\n");
|
||||
}
|
||||
|
||||
@@ -709,11 +708,11 @@ static void COM_Echo_f(void)
|
||||
static void COM_CEcho_f(void)
|
||||
{
|
||||
size_t i;
|
||||
char cechotext[1024] = {0};
|
||||
char cechotext[1024] = "";
|
||||
|
||||
for (i = 1; i < COM_Argc(); i++)
|
||||
{
|
||||
strlcat(cechotext, COM_Argv(i), sizeof(cechotext)-1);
|
||||
strlcpy(cechotext, COM_Argv(i), sizeof(cechotext)-1);
|
||||
strlcat(cechotext, " ", sizeof(cechotext)-1);
|
||||
}
|
||||
|
||||
@@ -836,7 +835,7 @@ static void COM_Help_f(void)
|
||||
if (cvar->PossibleValue)
|
||||
{
|
||||
{
|
||||
if (fasticmp(cvar->PossibleValue[0].strvalue, "MIN") && fasticmp(cvar->PossibleValue[1].strvalue, "MAX"))
|
||||
if (!stricmp(cvar->PossibleValue[0].strvalue, "MIN") && !stricmp(cvar->PossibleValue[1].strvalue, "MAX"))
|
||||
{
|
||||
if (floatmode)
|
||||
{
|
||||
@@ -879,7 +878,7 @@ static void COM_Help_f(void)
|
||||
{
|
||||
for (cmd = com_commands; cmd; cmd = cmd->next)
|
||||
{
|
||||
if (!fastcmp(cmd->name, help))
|
||||
if (strcmp(cmd->name, help))
|
||||
continue;
|
||||
|
||||
CONS_Printf("\x82""Command %s:\n", cmd->name);
|
||||
@@ -939,8 +938,6 @@ static void COM_Find_f(void)
|
||||
}
|
||||
|
||||
help = COM_Argv(1);
|
||||
if (!help)
|
||||
return;
|
||||
helplen = strlen(help);
|
||||
CONS_Printf("\x82""Variables:\n");
|
||||
matchesany = false;
|
||||
@@ -1176,7 +1173,7 @@ consvar_t *CV_FindVar(const char *name)
|
||||
consvar_t *cvar;
|
||||
|
||||
for (cvar = consvar_vars; cvar; cvar = cvar->next)
|
||||
if (fasticmp(name,cvar->name))
|
||||
if (!stricmp(name,cvar->name))
|
||||
return cvar;
|
||||
|
||||
return NULL;
|
||||
@@ -1366,7 +1363,7 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
|
||||
v = INT32_MIN; // Invalid integer trigger
|
||||
}
|
||||
|
||||
if (var->PossibleValue[0].strvalue && fasticmp(var->PossibleValue[0].strvalue, "MIN")) // bounded cvar
|
||||
if (var->PossibleValue[0].strvalue && !stricmp(var->PossibleValue[0].strvalue, "MIN")) // bounded cvar
|
||||
{
|
||||
#define MINVAL 0
|
||||
#define MAXVAL 1
|
||||
@@ -1379,21 +1376,21 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
|
||||
|
||||
// search for other
|
||||
for (i = MAXVAL+1; var->PossibleValue[i].strvalue; i++)
|
||||
if (v == var->PossibleValue[i].value || fasticmp(var->PossibleValue[i].strvalue, valstr))
|
||||
if (v == var->PossibleValue[i].value || !stricmp(var->PossibleValue[i].strvalue, valstr))
|
||||
{
|
||||
var->value = var->PossibleValue[i].value;
|
||||
var->string = var->PossibleValue[i].strvalue;
|
||||
goto finish;
|
||||
}
|
||||
|
||||
if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || fasticmp(valstr, "MIN"))
|
||||
if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || !stricmp(valstr, "MIN"))
|
||||
{
|
||||
v = var->PossibleValue[MINVAL].value;
|
||||
valstr = var->PossibleValue[MINVAL].strvalue;
|
||||
override = true;
|
||||
overrideval = v;
|
||||
}
|
||||
else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || fasticmp(valstr, "MAX"))
|
||||
else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || !stricmp(valstr, "MAX"))
|
||||
{
|
||||
v = var->PossibleValue[MAXVAL].value;
|
||||
valstr = var->PossibleValue[MAXVAL].strvalue;
|
||||
@@ -1411,7 +1408,7 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
|
||||
|
||||
// check first strings
|
||||
for (i = 0; var->PossibleValue[i].strvalue; i++)
|
||||
if (fasticmp(var->PossibleValue[i].strvalue, valstr))
|
||||
if (!stricmp(var->PossibleValue[i].strvalue, valstr))
|
||||
goto found;
|
||||
if (v != INT32_MIN)
|
||||
{
|
||||
@@ -1424,9 +1421,9 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
|
||||
if (var->PossibleValue == CV_OnOff || var->PossibleValue == CV_YesNo)
|
||||
{
|
||||
overrideval = -1;
|
||||
if (fasticmp(valstr, "on") || fasticmp(valstr, "yes"))
|
||||
if (!stricmp(valstr, "on") || !stricmp(valstr, "yes"))
|
||||
overrideval = 1;
|
||||
else if (fasticmp(valstr, "off") || fasticmp(valstr, "no"))
|
||||
else if (!stricmp(valstr, "off") || !stricmp(valstr, "no"))
|
||||
overrideval = 0;
|
||||
|
||||
if (overrideval != -1)
|
||||
@@ -1610,7 +1607,7 @@ void CV_ResetCheatNetVars(void)
|
||||
// Returns true if the variable's current value is its default value
|
||||
boolean CV_IsSetToDefault(consvar_t *v)
|
||||
{
|
||||
return (fastcmp(v->defaultvalue, v->string));
|
||||
return (!(strcmp(v->defaultvalue, v->string)));
|
||||
}
|
||||
|
||||
// If any cheats CVars are not at their default settings, return true.
|
||||
@@ -1622,7 +1619,7 @@ UINT8 CV_CheatsEnabled(void)
|
||||
consvar_t *cvar;
|
||||
|
||||
for (cvar = consvar_vars; cvar; cvar = cvar->next)
|
||||
if ((cvar->flags & CV_CHEAT) && !fastcmp(cvar->defaultvalue, cvar->string))
|
||||
if ((cvar->flags & CV_CHEAT) && strcmp(cvar->defaultvalue, cvar->string))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
@@ -1643,7 +1640,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
|
||||
if (!var->string)
|
||||
I_Error("CV_Set: %s no string set!\n", var->name);
|
||||
#endif
|
||||
if (!var || !var->string || !value || fasticmp(var->string, value))
|
||||
if (!var || !var->string || !value || !stricmp(var->string, value))
|
||||
return; // no changes
|
||||
|
||||
if (var->flags & CV_NETVAR)
|
||||
@@ -1665,7 +1662,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
|
||||
|
||||
if (var == &cv_kartspeed && !M_SecretUnlocked(SECRET_HARDSPEED))
|
||||
{
|
||||
if (fasticmp(value, "Hard") || atoi(value) == 2)
|
||||
if (!stricmp(value, "Hard") || atoi(value) == 2)
|
||||
{
|
||||
CONS_Alert(CONS_NOTICE, "You haven't unlocked this yet!\n");
|
||||
return;
|
||||
@@ -1799,7 +1796,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
|
||||
}
|
||||
#define MINVAL 0
|
||||
#define MAXVAL 1
|
||||
else if (var->PossibleValue[MINVAL].strvalue && fastcmp(var->PossibleValue[MINVAL].strvalue, "MIN"))
|
||||
else if (var->PossibleValue[MINVAL].strvalue && !strcmp(var->PossibleValue[MINVAL].strvalue, "MIN"))
|
||||
{ // SRB2Kart
|
||||
#ifdef PARANOIA
|
||||
if (!var->PossibleValue[MAXVAL].strvalue)
|
||||
@@ -1971,12 +1968,12 @@ static boolean CV_FilterJoyAxisVars(consvar_t *v, const char *valstr)
|
||||
{
|
||||
if (joyaxis_default[i])
|
||||
{
|
||||
if (fasticmp(v->name, "joyaxis_fire"))
|
||||
if (!stricmp(v->name, "joyaxis_fire"))
|
||||
{
|
||||
if (joyaxis_count[i] > 7) return false;
|
||||
else if (joyaxis_count[i] == 7) return true;
|
||||
|
||||
if (fasticmp(valstr, "None")) joyaxis_count[i]++;
|
||||
if (!stricmp(valstr, "None")) joyaxis_count[i]++;
|
||||
else joyaxis_default[i] = false;
|
||||
}
|
||||
// reset all axis settings to defaults
|
||||
@@ -2008,37 +2005,37 @@ static boolean CV_FilterJoyAxisVars(consvar_t *v, const char *valstr)
|
||||
// Block the Xbox DInput default axes and reset to the current defaults
|
||||
static boolean CV_FilterJoyAxisVars2(consvar_t *v, const char *valstr)
|
||||
{
|
||||
if (fasticmp(v->name, "joyaxis_turn") && fasticmp(valstr, "X-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis_turn") && !stricmp(valstr, "X-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis2_turn") && fasticmp(valstr, "X-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis2_turn") && !stricmp(valstr, "X-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis3_turn") && fasticmp(valstr, "X-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis3_turn") && !stricmp(valstr, "X-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis4_turn") && fasticmp(valstr, "X-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis4_turn") && !stricmp(valstr, "X-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis_aim") && fasticmp(valstr, "Y-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis_aim") && !stricmp(valstr, "Y-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis2_aim") && fasticmp(valstr, "Y-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis2_aim") && !stricmp(valstr, "Y-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis3_aim") && fasticmp(valstr, "Y-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis3_aim") && !stricmp(valstr, "Y-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis4_aim") && fasticmp(valstr, "Y-Axis"))
|
||||
if (!stricmp(v->name, "joyaxis4_aim") && !stricmp(valstr, "Y-Axis"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis_fire") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis_fire") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis2_fire") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis2_fire") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis3_fire") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis3_fire") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis4_fire") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis4_fire") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis_drift") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis_drift") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis2_drift") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis2_drift") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis3_drift") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis3_drift") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
if (fasticmp(v->name, "joyaxis4_drift") && fasticmp(valstr, "None"))
|
||||
if (!stricmp(v->name, "joyaxis4_drift") && !stricmp(valstr, "None"))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
@@ -2055,8 +2052,8 @@ static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr)
|
||||
|
||||
if (GETMAJOREXECVERSION(cv_execversion.value) < 8) // 8 = 1.4
|
||||
{
|
||||
if (fasticmp(v->name, "masterserver") // Replaces a hack in MasterServer_OnChange for the original SRB2 MS.
|
||||
|| fasticmp(v->name, "gamma")) // Too easy to accidentially change in prior versions.
|
||||
if (!stricmp(v->name, "masterserver") // Replaces a hack in MasterServer_OnChange for the original SRB2 MS.
|
||||
|| !stricmp(v->name, "gamma")) // Too easy to accidentially change in prior versions.
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -2139,7 +2136,7 @@ void CV_SaveVariables(FILE *f)
|
||||
char stringtowrite[MAXTEXTCMD+1];
|
||||
|
||||
// Silly hack for Min/Max vars
|
||||
if (fastcmp(cvar->string, "MAX") || fastcmp(cvar->string, "MIN"))
|
||||
if (!strcmp(cvar->string, "MAX") || !strcmp(cvar->string, "MIN"))
|
||||
{
|
||||
if (cvar->flags & CV_FLOAT)
|
||||
sprintf(stringtowrite, "%f", FixedToFloat(cvar->value));
|
||||
|
||||
+1
-1
@@ -1010,7 +1010,7 @@ boolean CON_Responder(event_t *ev)
|
||||
Lock_state();
|
||||
|
||||
// Only add command to history if it differs from previous one
|
||||
if (!fastcmp(input.buffer, inputlines[(inputline-1) & 31]))
|
||||
if (strcmp(input.buffer, inputlines[(inputline-1) & 31]))
|
||||
{
|
||||
inputline = (inputline+1) & 31;
|
||||
M_TextInputInit(&input, inputlines[inputline], CON_MAXPROMPTCHARS);
|
||||
|
||||
+14
-21
@@ -823,7 +823,7 @@ static void resynch_read_player(resynch_pak *rsp)
|
||||
P_SetThingPosition(players[i].mo);
|
||||
}
|
||||
|
||||
static void resynch_write_ctf(resynchend_pak *rst)
|
||||
static inline void resynch_write_ctf(resynchend_pak *rst)
|
||||
{
|
||||
mobj_t *mflag;
|
||||
UINT8 i, j;
|
||||
@@ -863,7 +863,7 @@ static void resynch_write_ctf(resynchend_pak *rst)
|
||||
}
|
||||
}
|
||||
|
||||
static void resynch_read_ctf(resynchend_pak *p)
|
||||
static inline void resynch_read_ctf(resynchend_pak *p)
|
||||
{
|
||||
UINT8 i;
|
||||
|
||||
@@ -1656,7 +1656,12 @@ static void SV_SendPlayerInfo(INT32 node)
|
||||
|
||||
netbuffer->u.playerinfo[i].node = i;
|
||||
|
||||
strlcpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
|
||||
// Can't really change this because net compatibility, but the warning is annoying
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstringop-truncation"
|
||||
strncpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
|
||||
#pragma GCC diagnostic pop
|
||||
netbuffer->u.playerinfo[i].name[MAXPLAYERNAME] = '\0';
|
||||
|
||||
//fetch IP address
|
||||
//No, don't do that, you fuckface.
|
||||
@@ -2174,7 +2179,7 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
|
||||
if (info->subversion != SUBVERSION)
|
||||
return; // Close, but no cigar.
|
||||
|
||||
if (!fastcmp(info->application, SRB2APPLICATION))
|
||||
if (strcmp(info->application, SRB2APPLICATION))
|
||||
return;/* that's a different mod */
|
||||
|
||||
i = serverlistcount++;
|
||||
@@ -2219,7 +2224,7 @@ void CL_QueryServerList (msg_server_t *server_list)
|
||||
// thwart nefarious servers who lie to the MS.
|
||||
|
||||
/* lol bruh, that version COMES from the servers */
|
||||
//if (fastcmp(version, server_list[i].version))
|
||||
//if (strcmp(version, server_list[i].version) == 0)
|
||||
{
|
||||
INT32 node = I_NetMakeNodewPort(server_list[i].ip, server_list[i].port);
|
||||
if (node == -1)
|
||||
@@ -3215,7 +3220,7 @@ static void Command_connect(void)
|
||||
|
||||
server = false;
|
||||
|
||||
if (fasticmp(COM_Argv(1), "self"))
|
||||
if (!stricmp(COM_Argv(1), "self"))
|
||||
{
|
||||
servernode = 0;
|
||||
server = true;
|
||||
@@ -3225,7 +3230,7 @@ static void Command_connect(void)
|
||||
else
|
||||
{
|
||||
// used in menu to connect to a server in the list
|
||||
if (netgame && fasticmp(COM_Argv(1), "node"))
|
||||
if (netgame && !stricmp(COM_Argv(1), "node"))
|
||||
{
|
||||
servernode = (SINT8)atoi(COM_Argv(2));
|
||||
}
|
||||
@@ -3240,7 +3245,7 @@ static void Command_connect(void)
|
||||
netgame = true;
|
||||
multiplayer = true;
|
||||
|
||||
if (fasticmp(COM_Argv(1), "any"))
|
||||
if (!stricmp(COM_Argv(1), "any"))
|
||||
servernode = BROADCASTADDR;
|
||||
else if (I_NetMakeNodewPort && COM_Argc() >= 3)
|
||||
servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
|
||||
@@ -3264,7 +3269,6 @@ static void Command_connect(void)
|
||||
splitscreen = cv_splitplayers.value-1;
|
||||
SplitScreen_OnChange();
|
||||
}
|
||||
|
||||
botingame = false;
|
||||
botskin = 0;
|
||||
CL_ConnectToServer();
|
||||
@@ -4650,22 +4654,11 @@ void SV_StopServer(void)
|
||||
Y_EndIntermission();
|
||||
if (gamestate == GS_VOTING)
|
||||
Y_EndVote();
|
||||
|
||||
G_SetGamestate(GS_NULL);
|
||||
wipegamestate = GS_NULL;
|
||||
gamestate = wipegamestate = GS_NULL;
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
localtextcmd[i][0] = 0;
|
||||
|
||||
while (textcmdbuf[i] != NULL)
|
||||
{
|
||||
textcmdbuf_t *buf = textcmdbuf[i];
|
||||
textcmdbuf[i] = textcmdbuf[i]->next;
|
||||
Z_Free(buf);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = firstticstosend; i < firstticstosend + BACKUPTICS; i++)
|
||||
D_Clearticcmd(i);
|
||||
|
||||
|
||||
+111
-137
@@ -97,15 +97,15 @@
|
||||
UINT8 window_notinfocus = false;
|
||||
|
||||
static char *startupiwadfiles[MAX_WADFILES];
|
||||
static size_t startupiwadcount = 0;
|
||||
static char *startuppwads[MAX_WADFILES];
|
||||
static size_t startuppwadcount = 0;
|
||||
|
||||
// autoloading
|
||||
static char *autoloadwadfiles[MAX_WADFILES];
|
||||
static char *autoloadwadfilespost[MAX_WADFILES];
|
||||
static size_t autoloadcount = 0;
|
||||
static size_t postloadcount = 0;
|
||||
boolean autoloading;
|
||||
boolean autoloaded;
|
||||
boolean postautoloaded = false;
|
||||
boolean wasautoloaded = false;
|
||||
//
|
||||
|
||||
boolean devparm = false; // started game with -devparm
|
||||
@@ -113,9 +113,7 @@ boolean devparm = false; // started game with -devparm
|
||||
boolean singletics = false; // timedemo
|
||||
boolean lastdraw = false;
|
||||
|
||||
#ifdef MOTIONBLUR
|
||||
INT32 postimgparam[MAXSPLITSCREENPLAYERS];
|
||||
#endif
|
||||
|
||||
// These variables are only true if
|
||||
// whether the respective sound system is disabled
|
||||
@@ -399,11 +397,7 @@ static void D_Renderview(void)
|
||||
if (i == 0)
|
||||
R_ApplyViewMorph();
|
||||
|
||||
#ifdef MOTIONBLUR
|
||||
V_DoPostProcessor(i, postimgparam[i]);
|
||||
#else
|
||||
V_DoPostProcessor(i, 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -967,11 +961,8 @@ void D_ClearState(void)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
demo.title = false;
|
||||
|
||||
// okay, stop now
|
||||
// (otherwise the game still thinks we're playing!)
|
||||
CURLAbortFile();
|
||||
SV_StopServer();
|
||||
SV_ResetServer();
|
||||
serverlistultimatecount = 0;
|
||||
@@ -980,10 +971,7 @@ void D_ClearState(void)
|
||||
CL_ClearPlayer(i);
|
||||
|
||||
splitscreen = 0;
|
||||
|
||||
// recompute screen size
|
||||
R_ExecuteSetViewSize();
|
||||
|
||||
SplitScreen_OnChange();
|
||||
botingame = false;
|
||||
botskin = 0;
|
||||
cv_debug = 0;
|
||||
@@ -1002,6 +990,7 @@ void D_ClearState(void)
|
||||
gameaction = ga_nothing;
|
||||
memset(displayplayers, 0, sizeof(displayplayers));
|
||||
consoleplayer = 0;
|
||||
//demosequence = -1;
|
||||
gametype = GT_RACE; // SRB2kart
|
||||
paused = false;
|
||||
|
||||
@@ -1024,11 +1013,6 @@ void D_ClearState(void)
|
||||
|
||||
G_SetGamestate(GS_NULL);
|
||||
wipegamestate = GS_NULL;
|
||||
|
||||
M_ClearMenus(true);
|
||||
|
||||
// map palettes affect this
|
||||
D_ResetDeviceLED();
|
||||
}
|
||||
|
||||
//
|
||||
@@ -1036,18 +1020,25 @@ void D_ClearState(void)
|
||||
//
|
||||
void D_StartTitle(void)
|
||||
{
|
||||
demo.title = false;
|
||||
D_ClearState();
|
||||
multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao
|
||||
netgame = false; // title menu shouldnt be a netgame lmao
|
||||
M_ClearMenus(true);
|
||||
F_StartTitleScreen();
|
||||
D_ResetDeviceLED();
|
||||
}
|
||||
|
||||
//
|
||||
// D_AddFile
|
||||
//
|
||||
static void D_AddFile(const char *file, char **filearray, size_t index)
|
||||
static void D_AddFile(const char *file, char **filearray)
|
||||
{
|
||||
size_t pnumwadfiles;
|
||||
char *newfile;
|
||||
|
||||
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
|
||||
;
|
||||
|
||||
newfile = malloc(strlen(file) + 1);
|
||||
if (!newfile)
|
||||
{
|
||||
@@ -1055,17 +1046,16 @@ static void D_AddFile(const char *file, char **filearray, size_t index)
|
||||
}
|
||||
strcpy(newfile, file);
|
||||
|
||||
filearray[index] = newfile;
|
||||
filearray[pnumwadfiles] = newfile;
|
||||
}
|
||||
|
||||
static void D_CleanFile(char **filearray, size_t count)
|
||||
static void D_CleanFile(char **filearray)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
size_t pnumwadfiles;
|
||||
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
|
||||
{
|
||||
free(filearray[i]);
|
||||
filearray[i] = NULL;
|
||||
free(filearray[pnumwadfiles]);
|
||||
filearray[pnumwadfiles] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1078,27 +1068,28 @@ static INT32 D_DetectFileType(const char* filename)
|
||||
|
||||
const size_t len = strlen(filename);
|
||||
|
||||
if (fasticmp(&filename[len - 4], ".wad"))
|
||||
if (!stricmp(&filename[len - 4], ".wad"))
|
||||
return 2;
|
||||
else if (fasticmp(&filename[len - 4], ".pk3"))
|
||||
else if (!stricmp(&filename[len - 4], ".pk3"))
|
||||
return 3;
|
||||
else if (fasticmp(&filename[len - 5], ".kart"))
|
||||
else if (!stricmp(&filename[len - 5], ".kart"))
|
||||
return 4;
|
||||
else if (fasticmp(&filename[len - 4], ".lua"))
|
||||
else if (!stricmp(&filename[len - 4], ".lua"))
|
||||
return 5;
|
||||
else if (fasticmp(&filename[len - 4], ".soc"))
|
||||
else if (!stricmp(&filename[len - 4], ".soc"))
|
||||
return 6;
|
||||
else if (fasticmp(&filename[len - 4], ".cfg"))
|
||||
else if (!stricmp(&filename[len - 4], ".cfg"))
|
||||
return 7;
|
||||
else if (fasticmp(&filename[len - 4], ".txt"))
|
||||
else if (!stricmp(&filename[len - 4], ".txt"))
|
||||
return 8;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// autoload that shit
|
||||
static void D_AutoloadFile(const char *file, char **filearray, size_t index)
|
||||
static void D_AutoloadFile(const char *file, char **filearray)
|
||||
{
|
||||
size_t pnumwadfiles;
|
||||
char *newfile;
|
||||
INT32 fileType = D_DetectFileType(file);
|
||||
|
||||
@@ -1108,6 +1099,9 @@ static void D_AutoloadFile(const char *file, char **filearray, size_t index)
|
||||
return;
|
||||
}
|
||||
|
||||
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
|
||||
;
|
||||
|
||||
if (fileType <= 6)
|
||||
{
|
||||
newfile = malloc(strlen(file) + 1);
|
||||
@@ -1115,7 +1109,7 @@ static void D_AutoloadFile(const char *file, char **filearray, size_t index)
|
||||
I_Error("No more free memory to AutoloadFile %s",file);
|
||||
|
||||
strcpy(newfile, file);
|
||||
filearray[index] = newfile;
|
||||
filearray[pnumwadfiles] = newfile;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1145,44 +1139,42 @@ static void D_FindAddonsToAutoload(void)
|
||||
{
|
||||
FILE *autoloadconfigfile;
|
||||
const char *autoloadpath;
|
||||
char *newline;
|
||||
|
||||
boolean postload;
|
||||
|
||||
INT32 i;
|
||||
char wadsToAutoload[256] = "";
|
||||
|
||||
// does it exist tho
|
||||
autoloadpath = va("%s"PATHSEP"%s", srb2home, AUTOLOADCONFIGFILENAME);
|
||||
autoloadpath = va("%s"PATHSEP"%s",srb2home,AUTOLOADCONFIGFILENAME);
|
||||
autoloadconfigfile = fopen(autoloadpath, "r");
|
||||
|
||||
// If the file is found, run our shit
|
||||
if (!autoloadconfigfile) // nope outta here
|
||||
{
|
||||
autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
|
||||
wasautoloaded = postautoloaded = true; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
|
||||
return;
|
||||
}
|
||||
|
||||
while (fgets(wadsToAutoload, sizeof(wadsToAutoload), autoloadconfigfile) != NULL)
|
||||
while (fgets(wadsToAutoload, sizeof wadsToAutoload, autoloadconfigfile) != NULL)
|
||||
{
|
||||
postload = false;
|
||||
|
||||
// skip if commented or empty
|
||||
if (wadsToAutoload[0] == '\n' ||
|
||||
wadsToAutoload[0] == '#' ||
|
||||
wadsToAutoload[0] == '\0')
|
||||
if ((wadsToAutoload[1] == '\0' || wadsToAutoload[1] == '\n')
|
||||
|| (wadsToAutoload[0] == '#'))
|
||||
continue;
|
||||
|
||||
// this marks it so that it loads after loading server addons
|
||||
if (fastncmp(wadsToAutoload, "postload ", 9))
|
||||
else if (fastncmp(wadsToAutoload, "postload ", 9))
|
||||
{
|
||||
strremove(wadsToAutoload, "postload ");
|
||||
postload = true;
|
||||
}
|
||||
|
||||
// Remove Any Empty or Skipped Lines
|
||||
newline = strchr(wadsToAutoload, '\n');
|
||||
if (newline)
|
||||
*newline = '\0';
|
||||
for (i = 0; wadsToAutoload[i] != '\0'; i++)
|
||||
{
|
||||
if (wadsToAutoload[i] == '\n')
|
||||
wadsToAutoload[i] = '\0';
|
||||
}
|
||||
|
||||
if (!postload && W_CheckPostLoadList(wadsToAutoload))
|
||||
{
|
||||
@@ -1192,19 +1184,14 @@ static void D_FindAddonsToAutoload(void)
|
||||
|
||||
// LOAD IT
|
||||
if (!postload)
|
||||
{
|
||||
D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
|
||||
autoloadcount++;
|
||||
}
|
||||
D_AutoloadFile(wadsToAutoload, autoloadwadfiles);
|
||||
else
|
||||
{
|
||||
D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
|
||||
postloadcount++;
|
||||
}
|
||||
}
|
||||
D_AutoloadFile(wadsToAutoload, autoloadwadfilespost);
|
||||
|
||||
autoloadwadfiles[autoloadcount] = NULL;
|
||||
autoloadwadfilespost[postloadcount] = NULL;
|
||||
// end it here
|
||||
for (i = 0; wadsToAutoload[i] != '\0'; i++)
|
||||
wadsToAutoload[i] = '\0';
|
||||
}
|
||||
|
||||
// we dont want memory leaks around here do we?
|
||||
fclose(autoloadconfigfile);
|
||||
@@ -1212,47 +1199,41 @@ static void D_FindAddonsToAutoload(void)
|
||||
|
||||
static void D_AddAutoloadFiles(void)
|
||||
{
|
||||
// nothing to autoload
|
||||
if (autoloadcount == 0)
|
||||
if (wasautoloaded)
|
||||
return;
|
||||
|
||||
CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
|
||||
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
|
||||
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfiles);
|
||||
|
||||
D_CleanFile(autoloadwadfiles, autoloadcount);
|
||||
|
||||
autoloadcount = 0;
|
||||
wasautoloaded = true;
|
||||
}
|
||||
|
||||
void D_AddPostloadFiles(void)
|
||||
{
|
||||
// nothing to postload
|
||||
if (postloadcount == 0 || !netgame)
|
||||
if (postautoloaded || !netgame)
|
||||
return;
|
||||
|
||||
CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
|
||||
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
|
||||
CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfilespost);
|
||||
|
||||
D_CleanFile(autoloadwadfilespost, postloadcount);
|
||||
|
||||
postloadcount = 0;
|
||||
postautoloaded = true;
|
||||
}
|
||||
|
||||
// ==========================================================================
|
||||
// Identify the SRB2 version, and IWAD file to use.
|
||||
// ==========================================================================
|
||||
|
||||
static boolean AddIWAD(const char * file, const char *dir)
|
||||
static boolean AddIWAD(void)
|
||||
{
|
||||
char * path = va(pandf, dir, file);
|
||||
char * path = va(pandf, srb2path, "srb2.srb");
|
||||
|
||||
if (FIL_ReadFileOK(path))
|
||||
{
|
||||
D_AddFile(path, startupiwadfiles, startupiwadcount++);
|
||||
D_AddFile(path, startupiwadfiles);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1288,14 +1269,14 @@ static void IdentifyVersion(void)
|
||||
}
|
||||
|
||||
#if (1) // reduce the amount of findfile by only using full cwd in this func
|
||||
if (!fastcmp(tempsrb2path, srb2waddir))
|
||||
if (strcmp(tempsrb2path, srb2waddir))
|
||||
#endif
|
||||
{
|
||||
strlcpy(srb2path, srb2waddir, sizeof (srb2path));
|
||||
}
|
||||
|
||||
// Load the IWAD
|
||||
if (!AddIWAD("srb2.srb", srb2path)) // not sure why this uses srb2path and not srb2waddir?
|
||||
if (!AddIWAD())
|
||||
{
|
||||
I_Error("SRB2.SRB not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
@@ -1309,60 +1290,57 @@ static void IdentifyVersion(void)
|
||||
|
||||
#ifdef USE_PATCH_DTA
|
||||
// Add our crappy patches to fix our bugs
|
||||
if (!AddIWAD("patch.dta", srb2waddir))
|
||||
{
|
||||
I_Error("patch.dta not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
D_AddFile(va(pandf,srb2waddir,"patch.dta"));
|
||||
#endif
|
||||
if (!AddIWAD("gfx.kart", srb2waddir))
|
||||
{
|
||||
I_Error("gfx.kart not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
|
||||
if (!AddIWAD("textures.kart", srb2waddir))
|
||||
{
|
||||
I_Error("textures.kart not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
|
||||
if (!AddIWAD("chars.kart", srb2waddir))
|
||||
{
|
||||
I_Error("chars.kart not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
|
||||
if (!AddIWAD("maps.kart", srb2waddir))
|
||||
{
|
||||
I_Error("maps.kart not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
D_AddFile(va(pandf, srb2waddir, "gfx.kart"), startupiwadfiles);
|
||||
D_AddFile(va(pandf, srb2waddir, "textures.kart"), startupiwadfiles);
|
||||
D_AddFile(va(pandf, srb2waddir, "chars.kart"), startupiwadfiles);
|
||||
D_AddFile(va(pandf, srb2waddir, "maps.kart"), startupiwadfiles);
|
||||
#ifdef USE_PATCH_KART
|
||||
if (!AddIWAD("patch.kart", srb2waddir))
|
||||
{
|
||||
I_Error("patch.kart not found! Expected in %s\n", srb2waddir);
|
||||
}
|
||||
D_AddFile(va(pandf,srb2waddir,"patch.kart"), startupiwadfiles);
|
||||
#endif
|
||||
|
||||
const char *path = NULL;
|
||||
|
||||
path = va(pandf, srb2waddir, "extra.kart");
|
||||
|
||||
// completely optional
|
||||
if (AddIWAD("extra.kart", srb2waddir))
|
||||
if (FIL_ReadFileOK(path))
|
||||
{
|
||||
D_AddFile(path, startupiwadfiles);
|
||||
found_extra_kart = true;
|
||||
}
|
||||
|
||||
path = va(pandf, srb2waddir, "extra2.kart");
|
||||
|
||||
// completely optional 2: Back with a vengence
|
||||
if (AddIWAD("extra2.kart", srb2waddir))
|
||||
if (FIL_ReadFileOK(path))
|
||||
{
|
||||
D_AddFile(path, startupiwadfiles);
|
||||
found_extra2_kart = true;
|
||||
}
|
||||
|
||||
if (AddIWAD("extra3.kart", srb2waddir))
|
||||
path = va(pandf, srb2waddir, "extra3.kart");
|
||||
|
||||
if (FIL_ReadFileOK(path))
|
||||
{
|
||||
D_AddFile(path, startupiwadfiles);
|
||||
found_extra3_kart = true;
|
||||
}
|
||||
|
||||
#if !defined (HAVE_SDL) || defined (HAVE_MIXER)
|
||||
#define MUSICTEST(str) \
|
||||
musicpath = va(pandf, srb2waddir, str);\
|
||||
musicpath = va(pandf,srb2waddir,str);\
|
||||
handle = W_OpenWadFile(&musicpath, false); \
|
||||
if (handle) \
|
||||
{ \
|
||||
{\
|
||||
int ms = W_VerifyNMUSlumps(musicpath, handle, false); \
|
||||
fclose(handle); \
|
||||
if (ms == 0) \
|
||||
I_Error("File " str " has been modified with non-music/sound lumps"); \
|
||||
if (ms == 1) \
|
||||
D_AddFile(musicpath, startupiwadfiles, startupiwadcount++); \
|
||||
D_AddFile(musicpath, startupiwadfiles); \
|
||||
}
|
||||
{
|
||||
const char *musicpath;
|
||||
@@ -1736,14 +1714,8 @@ void D_SRB2Main(void)
|
||||
else
|
||||
{
|
||||
// use user specific config file
|
||||
if (M_CheckParm("-workdir") && M_IsNextParm())
|
||||
snprintf(srb2home, sizeof srb2home, "%s", M_GetNextParm());
|
||||
else
|
||||
#ifdef DEFAULTDIR
|
||||
snprintf(srb2home, sizeof srb2home, "%s" PATHSEP DEFAULTDIR, userhome);
|
||||
#else // DEFAULTDIR
|
||||
snprintf(srb2home, sizeof srb2home, "%s", userhome);
|
||||
#endif // DEFAULTDIR
|
||||
snprintf(srb2home, sizeof srb2home, "%s" PATHSEP DEFAULTDIR, userhome);
|
||||
snprintf(downloaddir, sizeof downloaddir, "%s" PATHSEP "DOWNLOAD", srb2home);
|
||||
if (dedicated)
|
||||
snprintf(configfile, sizeof configfile, "%s" PATHSEP "d"CONFIGFILENAME, srb2home);
|
||||
@@ -1752,6 +1724,17 @@ void D_SRB2Main(void)
|
||||
|
||||
// can't use sprintf since there is %u in savegamename
|
||||
strcatbf(savegamename, srb2home, PATHSEP);
|
||||
#else
|
||||
snprintf(srb2home, sizeof srb2home, "%s", userhome);
|
||||
snprintf(downloaddir, sizeof downloaddir, "%s", userhome);
|
||||
if (dedicated)
|
||||
snprintf(configfile, sizeof configfile, "%s" PATHSEP "d"CONFIGFILENAME, userhome);
|
||||
else
|
||||
snprintf(configfile, sizeof configfile, "%s" PATHSEP CONFIGFILENAME, userhome);
|
||||
|
||||
// can't use sprintf since there is %u in savegamename
|
||||
strcatbf(savegamename, userhome, PATHSEP);
|
||||
#endif
|
||||
}
|
||||
|
||||
configfile[sizeof configfile - 1] = '\0';
|
||||
@@ -1777,9 +1760,6 @@ void D_SRB2Main(void)
|
||||
}
|
||||
}
|
||||
|
||||
// make sure workdir exists
|
||||
I_mkdir(srb2home, 0755);
|
||||
|
||||
// Create addons dir
|
||||
snprintf(addonsdir, sizeof addonsdir, "%s%s%s", srb2home, PATHSEP, "addons");
|
||||
I_mkdir(addonsdir, 0755);
|
||||
@@ -1808,7 +1788,7 @@ void D_SRB2Main(void)
|
||||
const char *s = M_GetNextParm();
|
||||
|
||||
if (s) // Check for NULL?
|
||||
D_AddFile(s, startuppwads, startuppwadcount++);
|
||||
D_AddFile(s, startuppwads);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1841,10 +1821,8 @@ void D_SRB2Main(void)
|
||||
// load wad, including the main wad file
|
||||
CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n");
|
||||
|
||||
W_InitMultipleFiles(startupiwadfiles, startupiwadcount, false);
|
||||
//mainwads = startupiwadcount - musicwads;
|
||||
D_CleanFile(startupiwadfiles, startupiwadcount);
|
||||
startupiwadcount = 0;
|
||||
W_InitMultipleFiles(startupiwadfiles, false);
|
||||
D_CleanFile(startupiwadfiles);
|
||||
mainwads = 0;
|
||||
|
||||
#ifndef DEVELOP
|
||||
@@ -1883,16 +1861,15 @@ void D_SRB2Main(void)
|
||||
|
||||
D_CheckMaps(false);
|
||||
|
||||
W_InitMultipleFiles(startuppwads, startuppwadcount, true);
|
||||
W_InitMultipleFiles(startuppwads, true);
|
||||
|
||||
// Only search for pwad maps if we actually have a pwad added
|
||||
if (startuppwadcount > 0)
|
||||
if (startuppwads[0] != NULL)
|
||||
{
|
||||
D_CheckMaps(true);
|
||||
}
|
||||
|
||||
D_CleanFile(startuppwads, startuppwadcount);
|
||||
startuppwadcount = 0;
|
||||
D_CleanFile(startuppwads);
|
||||
|
||||
cht_Init();
|
||||
|
||||
@@ -2156,14 +2133,11 @@ void D_SRB2Main(void)
|
||||
const char *sskill = M_GetNextParm();
|
||||
|
||||
for (j = 0; kartspeed_cons_t[j].strvalue; j++)
|
||||
{
|
||||
if (fasticmp(kartspeed_cons_t[j].strvalue, sskill))
|
||||
if (!strcasecmp(kartspeed_cons_t[j].strvalue, sskill))
|
||||
{
|
||||
newskill = (INT16)kartspeed_cons_t[j].value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!kartspeed_cons_t[j].strvalue) // reached end of the list with no match
|
||||
{
|
||||
j = atoi(sskill); // assume they gave us a skill number, which is okay too
|
||||
|
||||
@@ -61,6 +61,9 @@ extern boolean minilighticon; // mkwii-style minimap headlight
|
||||
//
|
||||
|
||||
// autoload stuff
|
||||
extern boolean autoloading;
|
||||
extern boolean autoloaded;
|
||||
extern boolean postautoloaded;
|
||||
void D_AddPostloadFiles(void);
|
||||
|
||||
// the infinite loop of D_SRB2Loop() called from win_main for windows version
|
||||
|
||||
+3
-2
@@ -1127,7 +1127,9 @@ boolean HGetPacket(void)
|
||||
|
||||
while (true)
|
||||
{
|
||||
if (!I_NetGet()) // No packets received
|
||||
I_NetGet();
|
||||
|
||||
if (doomcom->remotenode == -1) // No packet received
|
||||
return false;
|
||||
|
||||
getbytes += packetheaderlength + doomcom->datalength; // For stat
|
||||
@@ -1163,7 +1165,6 @@ boolean HGetPacket(void)
|
||||
GotAcks();
|
||||
continue;
|
||||
}
|
||||
|
||||
doomcom->datalength -= BASEPACKETSIZE;
|
||||
break;
|
||||
}
|
||||
|
||||
+50
-71
@@ -292,10 +292,6 @@ consvar_t cv_mouseturn = {"mouseturn", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL,
|
||||
// Lagless camera! Yay!
|
||||
consvar_t cv_laglesscam = {"lagless_camera", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// makes the camera use the saved angleturn in replays instead of the players angle
|
||||
// more accurate to how the recording player seen things in game, but may be jittery if they encountered net issues
|
||||
consvar_t cv_demoangturn = {"useangleturninreplays", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_verticallook[MAXSPLITSCREENPLAYERS] = {
|
||||
{"verticallook", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"verticallook2", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
@@ -1047,7 +1043,6 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_betainterscreen);
|
||||
|
||||
CV_RegisterVar(&cv_laglesscam);
|
||||
CV_RegisterVar(&cv_demoangturn);
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
@@ -1219,7 +1214,7 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
|
||||
for (ix = 0; ix < MAXPLAYERS; ix++)
|
||||
{
|
||||
if (ix != playernum && playeringame[ix]
|
||||
&& fasticmp(name, player_names[ix]))
|
||||
&& strcasecmp(name, player_names[ix]) == 0)
|
||||
{
|
||||
// We shouldn't kick people out just because
|
||||
// they joined the game with the same name
|
||||
@@ -1336,7 +1331,7 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (i != playernum && playeringame[i]
|
||||
&& fasticmp(tmpname, player_names[i]))
|
||||
&& strcasecmp(tmpname, player_names[i]) == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
@@ -1386,7 +1381,7 @@ static void SetPlayerName(INT32 playernum, char *newname)
|
||||
{
|
||||
if (EnsurePlayerNameIsGood(newname, playernum))
|
||||
{
|
||||
if (!fasticmp(newname, player_names[playernum]))
|
||||
if (strcasecmp(newname, player_names[playernum]) != 0)
|
||||
{
|
||||
if (netgame)
|
||||
HU_AddChatText(va("\x82*%s renamed to %s", player_names[playernum], newname), false);
|
||||
@@ -1508,9 +1503,9 @@ static void SendNameAndColor(void)
|
||||
CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
|
||||
}
|
||||
|
||||
if (fastcmp(cv_playername.string, player_names[consoleplayer])
|
||||
if (!strcmp(cv_playername.string, player_names[consoleplayer])
|
||||
&& cv_playercolor.value == players[consoleplayer].skincolor
|
||||
&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
|
||||
&& !strcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
|
||||
return;
|
||||
|
||||
// We'll handle it later if we're not playing.
|
||||
@@ -1945,7 +1940,7 @@ static void Got_NameAndColor(UINT8 **cp, INT32 playernum)
|
||||
// set name
|
||||
if (player_name_changes[playernum] < MAXNAMECHANGES)
|
||||
{
|
||||
if (!fasticmp(player_names[playernum], name))
|
||||
if (strcasecmp(player_names[playernum], name) != 0)
|
||||
SetPlayerName(playernum, name);
|
||||
}
|
||||
|
||||
@@ -2322,8 +2317,8 @@ static void Command_Playdemo_f(void)
|
||||
|
||||
CONS_Printf(M_GetText("Playing back demo '%s'.\n"), name);
|
||||
|
||||
demo.loadfiles = fastcmp(COM_Argv(2), "-addfiles");
|
||||
demo.ignorefiles = fastcmp(COM_Argv(2), "-force");
|
||||
demo.loadfiles = strcmp(COM_Argv(2), "-addfiles") == 0;
|
||||
demo.ignorefiles = strcmp(COM_Argv(2), "-force") == 0;
|
||||
|
||||
// Internal if no extension, external if one exists
|
||||
// If external, convert the file name to a path in SRB2's home directory
|
||||
@@ -2492,18 +2487,15 @@ void D_SetupVote(void)
|
||||
INT32 i;
|
||||
UINT8 gt = (cv_kartgametypepreference.value == -1) ? gametype : cv_kartgametypepreference.value;
|
||||
UINT8 secondgt = G_SometimesGetDifferentGametype(gt);
|
||||
INT16 votebuffer[4] = {-1,-1,-1, 0};
|
||||
INT16 votebuffer[4] = {-1,-1,-1,0};
|
||||
INT16 luamaps[4] = {0, 0, 0, 0};
|
||||
|
||||
LUA_HookSetupVote(luamaps, sizeof(luamaps)/sizeof(luamaps[0]), gt, secondgt);
|
||||
|
||||
// Correct secondgt if needed
|
||||
if (luamaps[2])
|
||||
{
|
||||
UINT8 typeoflevel = mapheaderinfo[luamaps[2]-1]->typeoflevel;
|
||||
if ((typeoflevel & G_TOLFlag(secondgt&(~0x80))) == 0)
|
||||
secondgt = ((typeoflevel & TOL_RACE) ? GT_RACE : GT_MATCH)|(secondgt&0x80);
|
||||
}
|
||||
UINT8 typeoflevel = mapheaderinfo[luamaps[2]-1]->typeoflevel;
|
||||
if (luamaps[2] && (typeoflevel & G_TOLFlag(secondgt&(~0x80))) == 0)
|
||||
secondgt = ((typeoflevel & TOL_RACE) ? GT_RACE : GT_MATCH)|(secondgt&0x80);
|
||||
|
||||
if (cv_kartencore.value && gt == GT_RACE)
|
||||
WRITEUINT8(p, (gt|0x80));
|
||||
@@ -2604,18 +2596,14 @@ ConcatCommandArgv (int start, int end)
|
||||
size += strlen(COM_Argv(i)) + 1;
|
||||
}
|
||||
|
||||
p = final = ZZ_Alloc(size);
|
||||
|
||||
if (!p)
|
||||
I_Error("ConcatCommandArgv: Out of memory!\n");
|
||||
final = ZZ_Alloc(size);
|
||||
p = final;
|
||||
|
||||
--end;/* handle the final argument separately */
|
||||
|
||||
for (i = start; i < end; ++i)
|
||||
{
|
||||
p += sprintf(p, "%s ", COM_Argv(i));
|
||||
}
|
||||
|
||||
/* at this point "end" is actually the last argument's position */
|
||||
strcpy(p, COM_Argv(end));
|
||||
|
||||
@@ -3194,20 +3182,20 @@ static void Command_Teamchange_f(void)
|
||||
|
||||
if (G_GametypeHasTeams())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
|
||||
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
|
||||
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasSpectators())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
|
||||
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else
|
||||
error = true;
|
||||
@@ -3284,20 +3272,20 @@ static void Command_Teamchange2_f(void)
|
||||
|
||||
if (G_GametypeHasTeams())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
|
||||
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
|
||||
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasSpectators())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
|
||||
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else
|
||||
error = true;
|
||||
@@ -3375,20 +3363,20 @@ static void Command_Teamchange3_f(void)
|
||||
|
||||
if (G_GametypeHasTeams())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
|
||||
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
|
||||
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasSpectators())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
|
||||
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else
|
||||
error = true;
|
||||
@@ -3466,20 +3454,20 @@ static void Command_Teamchange4_f(void)
|
||||
|
||||
if (G_GametypeHasTeams())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
|
||||
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
|
||||
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasSpectators())
|
||||
{
|
||||
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
|
||||
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
|
||||
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else
|
||||
error = true;
|
||||
@@ -3565,33 +3553,33 @@ static void Command_ServerTeamChange_f(void)
|
||||
|
||||
if (G_TagGametype())
|
||||
{
|
||||
if (fasticmp(COM_Argv(2), "it") || fasticmp(COM_Argv(2), "1"))
|
||||
if (!strcasecmp(COM_Argv(2), "it") || !strcasecmp(COM_Argv(2), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(2), "notit") || fasticmp(COM_Argv(2), "2"))
|
||||
else if (!strcasecmp(COM_Argv(2), "notit") || !strcasecmp(COM_Argv(2), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(2), "playing") || fasticmp(COM_Argv(2), "3"))
|
||||
else if (!strcasecmp(COM_Argv(2), "playing") || !strcasecmp(COM_Argv(2), "3"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
|
||||
else if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasTeams())
|
||||
{
|
||||
if (fasticmp(COM_Argv(2), "red") || fasticmp(COM_Argv(2), "1"))
|
||||
if (!strcasecmp(COM_Argv(2), "red") || !strcasecmp(COM_Argv(2), "1"))
|
||||
NetPacket.packet.newteam = 1;
|
||||
else if (fasticmp(COM_Argv(2), "blue") || fasticmp(COM_Argv(2), "2"))
|
||||
else if (!strcasecmp(COM_Argv(2), "blue") || !strcasecmp(COM_Argv(2), "2"))
|
||||
NetPacket.packet.newteam = 2;
|
||||
else if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
|
||||
else if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else
|
||||
error = true;
|
||||
}
|
||||
else if (G_GametypeHasSpectators())
|
||||
{
|
||||
if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
|
||||
if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
|
||||
NetPacket.packet.newteam = 0;
|
||||
else if (fasticmp(COM_Argv(2), "playing") || fasticmp(COM_Argv(2), "1"))
|
||||
else if (!strcasecmp(COM_Argv(2), "playing") || !strcasecmp(COM_Argv(2), "1"))
|
||||
NetPacket.packet.newteam = 3;
|
||||
else
|
||||
error = true;
|
||||
@@ -4226,32 +4214,23 @@ static void Command_MotD_f(void)
|
||||
|
||||
mymotd = Z_Malloc(sizeof(motd), PU_STATIC, NULL);
|
||||
|
||||
if (!mymotd)
|
||||
return;
|
||||
//I_Error("Command_MotD_f: Out of memory!\n"); // idk if this aint a bit too much lel
|
||||
|
||||
strlcpy(mymotd, COM_Argv(1), sizeof(motd));
|
||||
|
||||
strlcpy(mymotd, COM_Argv(1), sizeof motd);
|
||||
for (i = 2; i < j; i++)
|
||||
{
|
||||
strlcat(mymotd, " ", sizeof(motd));
|
||||
strlcat(mymotd, COM_Argv(i), sizeof(motd));
|
||||
strlcat(mymotd, " ", sizeof motd);
|
||||
strlcat(mymotd, COM_Argv(i), sizeof motd);
|
||||
}
|
||||
|
||||
// Disallow non-printing characters and semicolons.
|
||||
for (i = 0; mymotd[i] != '\0'; i++)
|
||||
{
|
||||
if (!isprint(mymotd[i]) || mymotd[i] == ';')
|
||||
{
|
||||
Z_Free(mymotd);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if ((netgame || multiplayer) && client)
|
||||
{
|
||||
SendNetXCmd(XD_SETMOTD, mymotd, i); // send the actual size of the motd string, not the full buffer's size
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy(motd, mymotd);
|
||||
@@ -4450,7 +4429,7 @@ static void Command_Addfile(void)
|
||||
}
|
||||
|
||||
// Add file on your client directly if it is trivial, or you aren't in a netgame.
|
||||
if (!netgame || musiconly)
|
||||
if (!(netgame || multiplayer) || musiconly)
|
||||
{
|
||||
P_AddWadFile(fn, false);
|
||||
return;
|
||||
@@ -4493,7 +4472,7 @@ static void Command_Addfile(void)
|
||||
if (IsPlayerAdmin(consoleplayer) && (!server)) // Request to add file
|
||||
SendNetXCmd(XD_REQADDFILE, buf, buf_p - buf);
|
||||
else
|
||||
SendNetXCmd(XD_ADDFILE, buf, buf_p - buf);
|
||||
SendNetXCmd(XD_ADDFILE, buf, buf_p - buf);;
|
||||
}
|
||||
|
||||
/** Adds something at runtime.
|
||||
@@ -5209,14 +5188,14 @@ static void Ringslinger_OnChange(void)
|
||||
static void Gravity_OnChange(void)
|
||||
{
|
||||
if (!M_SecretUnlocked(SECRET_PANDORA) && !netgame && !cv_debug
|
||||
&& !fastcmp(cv_gravity.string, cv_gravity.defaultvalue))
|
||||
&& strcmp(cv_gravity.string, cv_gravity.defaultvalue))
|
||||
{
|
||||
CONS_Printf(M_GetText("You haven't earned this yet.\n"));
|
||||
CV_StealthSet(&cv_gravity, cv_gravity.defaultvalue);
|
||||
return;
|
||||
}
|
||||
#ifndef NETGAME_GRAVITY
|
||||
if (netgame)
|
||||
if(netgame)
|
||||
{
|
||||
CV_StealthSet(&cv_gravity, cv_gravity.defaultvalue);
|
||||
return;
|
||||
|
||||
@@ -209,8 +209,6 @@ extern consvar_t cv_betainterscreen;
|
||||
|
||||
extern consvar_t cv_laglesscam;
|
||||
|
||||
extern consvar_t cv_demoangturn;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SKINMENUTYPE_SCROLL = 0,
|
||||
|
||||
+16
-17
@@ -550,8 +550,7 @@ INT32 CL_CheckFiles(void)
|
||||
for (j = mainwads+1; j < numwadfiles; j++)
|
||||
{
|
||||
nameonly(strcpy(wadfilename, wadfiles[j]->filename));
|
||||
|
||||
if (fasticmp(wadfilename, fileneeded[i].filename) &&
|
||||
if (!stricmp(wadfilename, fileneeded[i].filename) &&
|
||||
!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
|
||||
{
|
||||
CONS_Debug(DBG_NETPLAY, "already loaded\n");
|
||||
@@ -666,7 +665,7 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
|
||||
strlcpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH);
|
||||
nameonly(wadfilename);
|
||||
|
||||
if (fasticmp(wadfilename, p->id.filename))
|
||||
if (!stricmp(wadfilename, p->id.filename))
|
||||
{
|
||||
// Copy file name with full path
|
||||
strlcpy(p->id.filename, wadfiles[wadnum]->filename, MAX_WADPATH);
|
||||
@@ -947,17 +946,17 @@ void Got_Filetxpak(void)
|
||||
char *filename = file->filename;
|
||||
static INT32 filetime = 0;
|
||||
|
||||
if ((fastcmp(filename, "srb2.srb")
|
||||
//|| fastcmp(filename, "srb2.wad")
|
||||
//|| fastcmp(filename, "patch.dta")
|
||||
//|| fastcmp(filename, "music.dta")
|
||||
|| fastcmp(filename, "gfx.kart")
|
||||
|| fastcmp(filename, "textures.kart")
|
||||
|| fastcmp(filename, "chars.kart")
|
||||
|| fastcmp(filename, "maps.kart")
|
||||
|| fastcmp(filename, "sounds.kart")
|
||||
|| fastcmp(filename, "music.kart")
|
||||
|| fastcmp(filename, "patch.kart")
|
||||
if (!(strcmp(filename, "srb2.srb")
|
||||
//&& strcmp(filename, "srb2.wad")
|
||||
//&& strcmp(filename, "patch.dta")
|
||||
//&& strcmp(filename, "music.dta")
|
||||
&& strcmp(filename, "gfx.kart")
|
||||
&& strcmp(filename, "textures.kart")
|
||||
&& strcmp(filename, "chars.kart")
|
||||
&& strcmp(filename, "maps.kart")
|
||||
&& strcmp(filename, "sounds.kart")
|
||||
&& strcmp(filename, "music.kart")
|
||||
&& strcmp(filename, "patch.kart")
|
||||
))
|
||||
I_Error("Tried to download \"%s\"", filename);
|
||||
|
||||
@@ -1198,7 +1197,7 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
|
||||
}
|
||||
|
||||
// next, check SRB2's "home" directory (if non-'.')
|
||||
if (!fastcmp(srb2home, "."))
|
||||
if (strcmp(srb2home, "."))
|
||||
{
|
||||
homecheck = filesearch(filename, srb2home, wantedmd5sum, completepath, 10);
|
||||
|
||||
@@ -1210,7 +1209,7 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
|
||||
}
|
||||
|
||||
// next, check SRB2's "path" directory (also if non-'.')
|
||||
if (!fastcmp(srb2path, "."))
|
||||
if (strcmp(srb2path, "."))
|
||||
{
|
||||
homecheck = filesearch(filename, srb2path, wantedmd5sum, completepath, 10);
|
||||
|
||||
@@ -1555,7 +1554,7 @@ CURLGetLogin (const char *url, HTTP_login ***return_prev_next)
|
||||
( login = (*prev_next));
|
||||
prev_next = &login->next
|
||||
){
|
||||
if (fastcmp(login->url, url) != 0)
|
||||
if (strcmp(login->url, url) == 0)
|
||||
{
|
||||
if (return_prev_next)
|
||||
(*return_prev_next) = prev_next;
|
||||
|
||||
+2
-2
@@ -211,12 +211,12 @@ void D_SetupProtocol(void)
|
||||
|
||||
if (result)
|
||||
{
|
||||
if (!fastcmp(buffer, "no"))
|
||||
if (strcmp(buffer, "no") == 0)
|
||||
{
|
||||
fclose(fp);
|
||||
return;
|
||||
}
|
||||
else if (fastcmp(buffer, exe_path))
|
||||
else if (strcmp(buffer, exe_path) != 0)
|
||||
{
|
||||
// overwrite
|
||||
fclose(fp);
|
||||
|
||||
@@ -1442,7 +1442,7 @@ static INT32 errorcount = 0;
|
||||
*/
|
||||
static boolean shutdowning = false;
|
||||
|
||||
FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
|
||||
void I_Error(const char *error, ...)
|
||||
{
|
||||
va_list argptr;
|
||||
char buffer[8192];
|
||||
@@ -1709,9 +1709,9 @@ char *I_GetUserName(void)
|
||||
strncpy(username, p, MAXPLAYERNAME);
|
||||
}
|
||||
|
||||
if (!fastcmp(username, ""))
|
||||
return username;
|
||||
|
||||
if (strcmp(username, "") != 0)
|
||||
return username;
|
||||
return NULL; // dummy for platform independent version
|
||||
}
|
||||
|
||||
|
||||
+3
-3
@@ -277,7 +277,7 @@ static void DRPC_HandleJoinRequest(const DiscordUser *requestUser)
|
||||
while (append != NULL)
|
||||
{
|
||||
// CHECK FOR DUPES!! Ignore any that already exist from the same user.
|
||||
if (fastcmp(newRequest->userID, append->userID))
|
||||
if (!strcmp(newRequest->userID, append->userID))
|
||||
{
|
||||
Discord_Respond(newRequest->userID, DISCORD_REPLY_IGNORE);
|
||||
DRPC_RemoveRequest(newRequest);
|
||||
@@ -419,7 +419,7 @@ static const char *DRPC_GetServerIP(void)
|
||||
// If you're connected
|
||||
if (I_GetNodeAddress && (address = I_GetNodeAddress(servernode)) != NULL)
|
||||
{
|
||||
if (!fastcmp(address, "self"))
|
||||
if (strcmp(address, "self"))
|
||||
{
|
||||
// We're not the server, so we could successfully get the IP!
|
||||
// No need to do anything else :)
|
||||
@@ -684,7 +684,7 @@ void DRPC_UpdatePresence(void)
|
||||
// Character image
|
||||
while (supportedSkins[checkSkin] != NULL)
|
||||
{
|
||||
if (fastcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
|
||||
if (!strcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
|
||||
{
|
||||
snprintf(charimg, 21, "char%s", supportedSkins[checkSkin]);
|
||||
discordPresence.smallImageKey = charimg;
|
||||
|
||||
@@ -69,8 +69,6 @@ extern "C" {
|
||||
#include <sys/stat.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "fastcmp.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <io.h>
|
||||
#endif
|
||||
@@ -653,9 +651,7 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
|
||||
#if defined (HAVE_CURL)
|
||||
#define MASTERSERVER
|
||||
#ifndef NOHOLEPUNCH
|
||||
#define HOLEPUNCH
|
||||
#endif
|
||||
#else
|
||||
#undef UPDATE_ALERT
|
||||
#endif
|
||||
|
||||
@@ -116,10 +116,7 @@ extern UINT8 window_notinfocus; // are we in focus? (backend independant -- hand
|
||||
extern boolean nodrawers;
|
||||
extern boolean noblit;
|
||||
extern boolean lastdraw;
|
||||
|
||||
#ifdef MOTIONBLUR
|
||||
extern INT32 postimgparam[MAXSPLITSCREENPLAYERS];
|
||||
#endif
|
||||
|
||||
extern INT32 viewwindowx, viewwindowy;
|
||||
extern INT32 viewwidth;
|
||||
|
||||
@@ -963,7 +963,6 @@ void F_StartTitleScreen(void)
|
||||
finalecount = 0;
|
||||
else
|
||||
wipegamestate = GS_TITLESCREEN;
|
||||
|
||||
G_SetGamestate(GS_TITLESCREEN);
|
||||
CON_ClearHUD();
|
||||
|
||||
|
||||
+12
-12
@@ -198,7 +198,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
|
||||
|
||||
for (; *path != NULL; path++)
|
||||
{
|
||||
if (fasticmp(*path, dent->d_name))
|
||||
if (strcasecmp(*path, dent->d_name) == 0)
|
||||
{
|
||||
skipfolder = true;
|
||||
break;
|
||||
@@ -212,7 +212,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
|
||||
}
|
||||
}
|
||||
|
||||
if (!fasticmp(".git", dent->d_name) // sanity if you're weird like me
|
||||
if (strcasecmp(".git", dent->d_name) // sanity if you're weird like me
|
||||
&& (dirhandle[depthleft-1] = opendir(searchpath)) != NULL)
|
||||
{
|
||||
// Got read permissions!
|
||||
@@ -227,7 +227,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
|
||||
|
||||
// I am a file!
|
||||
|
||||
if (!fasticmp(searchname, dent->d_name))
|
||||
if (strcasecmp(searchname, dent->d_name))
|
||||
continue; // Not what we're looking for!
|
||||
|
||||
switch (checkfilemd5(searchpath, wantedmd5sum))
|
||||
@@ -353,7 +353,7 @@ void searchfilemenu(char *tempname)
|
||||
{
|
||||
for (i = first; i < sizedirmenu; i++)
|
||||
{
|
||||
if (fastcmp(dirmenu[i]+DIR_STRING, tempname))
|
||||
if (!strcmp(dirmenu[i]+DIR_STRING, tempname))
|
||||
{
|
||||
dir_on[menudepthleft] = i;
|
||||
break;
|
||||
@@ -400,7 +400,7 @@ void searchfilemenu(char *tempname)
|
||||
{
|
||||
if (filemenucmp(coredirmenu[i]+DIR_STRING, localmenusearch))
|
||||
{
|
||||
if (tempname && fastcmp(coredirmenu[i]+DIR_STRING, tempname))
|
||||
if (tempname && !strcmp(coredirmenu[i]+DIR_STRING, tempname))
|
||||
{
|
||||
dir_on[menudepthleft] = sizedirmenu;
|
||||
Z_Free(tempname);
|
||||
@@ -478,14 +478,14 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
|
||||
if (replayhut)
|
||||
{
|
||||
if (!fasticmp(".lmp", dent->d_name+len-5))
|
||||
if (strcasecmp(".lmp", dent->d_name+len-5))
|
||||
continue; // Not a replay
|
||||
}
|
||||
else if (!cv_addons_showall.value)
|
||||
{
|
||||
UINT8 ext;
|
||||
for (ext = 0; ext < NUM_EXT_TABLE; ext++)
|
||||
if (fasticmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
|
||||
if (!strcasecmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
|
||||
break; // extension comparison
|
||||
|
||||
if (ext == NUM_EXT_TABLE)
|
||||
@@ -559,7 +559,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
|
||||
if (replayhut)
|
||||
{
|
||||
if (!fasticmp(".lmp", dent->d_name+len-5))
|
||||
if (strcasecmp(".lmp", dent->d_name+len-5))
|
||||
continue; // Not a replay
|
||||
|
||||
ext = EXT_TXT; // This isn't used anywhere but better safe than sorry for messing with this...
|
||||
@@ -567,7 +567,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
else
|
||||
{
|
||||
for (; ext < NUM_EXT_TABLE; ext++)
|
||||
if (fasticmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
|
||||
if (!strcasecmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
|
||||
break; // extension comparison
|
||||
|
||||
if (ext == NUM_EXT_TABLE && !cv_addons_showall.value)
|
||||
@@ -587,7 +587,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
nameonly(filenamebuf[i]);
|
||||
}
|
||||
|
||||
if (!fastcmp(dent->d_name, filenamebuf[i]))
|
||||
if (strcmp(dent->d_name, filenamebuf[i]))
|
||||
continue;
|
||||
|
||||
if (cv_addons_md5.value && !checkfilemd5(menupath, wadfiles[i]->md5sum))
|
||||
@@ -598,11 +598,11 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
}
|
||||
else if (ext == EXT_TXT)
|
||||
{
|
||||
if (!strncmp(dent->d_name, "log-", 4) || fastcmp(dent->d_name, "errorlog.txt"))
|
||||
if (!strncmp(dent->d_name, "log-", 4) || !strcmp(dent->d_name, "errorlog.txt"))
|
||||
ext |= EXT_LOADED;
|
||||
}
|
||||
|
||||
if (fastcmp(dent->d_name, configfile))
|
||||
if (!strcmp(dent->d_name, configfile))
|
||||
ext |= EXT_LOADED;
|
||||
}
|
||||
|
||||
|
||||
+325
-392
File diff suppressed because it is too large.
Load diff
+5
-12
@@ -2768,7 +2768,7 @@ INT32 G_GetGametypeByName(const char *gametypestr)
|
||||
INT32 i;
|
||||
|
||||
for (i = 0; i < NUMGAMETYPES; i++)
|
||||
if (fasticmp(gametypestr, Gametype_Names[i]))
|
||||
if (!stricmp(gametypestr, Gametype_Names[i]))
|
||||
return i;
|
||||
|
||||
return -1; // unknown gametype
|
||||
@@ -3463,8 +3463,7 @@ void G_LoadGameData(void)
|
||||
if (READUINT32(save.p) != 0xFCAFE211)
|
||||
{
|
||||
const char *gdfolder = "the SRB2Kart folder";
|
||||
|
||||
if (!fastcmp(srb2home,"."))
|
||||
if (strcmp(srb2home,"."))
|
||||
gdfolder = srb2home;
|
||||
|
||||
Z_Free(save.buffer);
|
||||
@@ -3548,8 +3547,7 @@ void G_LoadGameData(void)
|
||||
datacorrupt:
|
||||
{
|
||||
const char *gdfolder = "the SRB2Kart folder";
|
||||
|
||||
if (!fastcmp(srb2home,"."))
|
||||
if (strcmp(srb2home,"."))
|
||||
gdfolder = srb2home;
|
||||
|
||||
Z_Free(save.buffer);
|
||||
@@ -3760,8 +3758,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
|
||||
|
||||
memset(vcheck, 0, sizeof (vcheck));
|
||||
sprintf(vcheck, "version %d", VERSION);
|
||||
|
||||
if (!fastcmp((const char *)save.p, (const char *)vcheck))
|
||||
if (strcmp((const char *)save.p, (const char *)vcheck))
|
||||
{
|
||||
#ifdef SAVEGAME_OTHERVERSIONS
|
||||
M_StartMessage(M_GetText("Save game from different version.\nYou can load this savegame, but\nsaving afterwards will be disabled.\n\nDo you want to continue anyway?\n\n(Press 'Y' to confirm)\n"),
|
||||
@@ -4039,7 +4036,7 @@ char *G_BuildMapTitle(INT32 mapnum)
|
||||
if (!mapheaderinfo[mapnum-1])
|
||||
P_AllocMapHeader(mapnum-1);
|
||||
|
||||
if (!fastcmp(mapheaderinfo[mapnum-1]->lvlttl, ""))
|
||||
if (strcmp(mapheaderinfo[mapnum-1]->lvlttl, ""))
|
||||
{
|
||||
size_t len = 1;
|
||||
const char *zonetext = NULL;
|
||||
@@ -4064,11 +4061,7 @@ char *G_BuildMapTitle(INT32 mapnum)
|
||||
|
||||
title = Z_Malloc(len, PU_STATIC, NULL);
|
||||
|
||||
if (!title)
|
||||
return NULL;
|
||||
|
||||
sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl);
|
||||
|
||||
if (zonetext) sprintf(title + strlen(title), " %s", zonetext);
|
||||
if (actnum) sprintf(title + strlen(title), " %s", actnum);
|
||||
}
|
||||
|
||||
+3
-4
@@ -1033,7 +1033,7 @@ INT32 G_KeyStringtoNum(const char *keystr)
|
||||
return atoi(&keystr[3]);
|
||||
|
||||
for (j = 0; j < NUMKEYNAMES; j++)
|
||||
if (fasticmp(keynames[j].name, keystr))
|
||||
if (!stricmp(keynames[j].name, keystr))
|
||||
return keynames[j].keynum;
|
||||
|
||||
return 0;
|
||||
@@ -1333,15 +1333,14 @@ static void setcontrol(INT32 (*gc)[2])
|
||||
player = 0;
|
||||
|
||||
namectrl = COM_Argv(1);
|
||||
for (numctrl = 0; numctrl < num_gamecontrols && !fasticmp(namectrl, gamecontrolname[numctrl]); numctrl++)
|
||||
for (numctrl = 0; numctrl < num_gamecontrols && stricmp(namectrl, gamecontrolname[numctrl]);
|
||||
numctrl++)
|
||||
;
|
||||
|
||||
if (numctrl == num_gamecontrols)
|
||||
{
|
||||
CONS_Printf(M_GetText("Control '%s' unknown\n"), namectrl);
|
||||
return;
|
||||
}
|
||||
|
||||
keynum1 = G_KeyStringtoNum(COM_Argv(2));
|
||||
keynum2 = G_KeyStringtoNum(COM_Argv(3));
|
||||
keynum = G_FilterKeyByVersion(numctrl, 0, player, &keynum1, &keynum2, &nestedoverride);
|
||||
|
||||
+21
-26
@@ -437,16 +437,8 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
|
||||
// CACHING HANDLING
|
||||
// =================================================
|
||||
|
||||
typedef struct
|
||||
{
|
||||
GLMapTexture_t normal;
|
||||
#ifdef GLENCORE
|
||||
GLMapTexture_t encore;
|
||||
#endif
|
||||
} GLMapTextureSet_t; // idk i suck at naming things
|
||||
|
||||
static size_t gl_numtextures = 0; // Texture count
|
||||
static GLMapTextureSet_t *gl_textures; // For all textures
|
||||
static GLMapTexture_t *gl_textures; // For all textures
|
||||
|
||||
static void HWR_FreeTextureData(patch_t *patch)
|
||||
{
|
||||
@@ -586,12 +578,13 @@ void HWR_FreeMapTextures(void)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < gl_numtextures; i++)
|
||||
{
|
||||
FreeMapTexture(&gl_textures[i].normal);
|
||||
#ifdef GLENCORE
|
||||
FreeMapTexture(&gl_textures[i].encore);
|
||||
for (i = 0; i < gl_numtextures*2; i++)
|
||||
#else
|
||||
for (i = 0; i < gl_numtextures; i++)
|
||||
#endif
|
||||
{
|
||||
FreeMapTexture(&gl_textures[i]);
|
||||
}
|
||||
|
||||
// now the heap don't have any 'user' pointing to our
|
||||
@@ -610,7 +603,7 @@ static void HWR_PrecacheLevelFlats(void)
|
||||
|
||||
// special case for encore
|
||||
#ifdef GLENCORE
|
||||
if (encoremap)
|
||||
if (encoremode)
|
||||
{
|
||||
// go through all sectors to determine if it should be remapped for encore
|
||||
for (i = 0; i < numsectors; i++)
|
||||
@@ -685,6 +678,8 @@ static void HWR_PrecacheLevelTextures(void)
|
||||
const line_t *line = &lines[i];
|
||||
#ifdef GLENCORE
|
||||
const int noencoremap = ((encoremap && (line->flags & ML_TFERLINE)) ? 2 : 1);
|
||||
#else
|
||||
const int noencoremap = 1;
|
||||
#endif
|
||||
// two sides
|
||||
for (j = 0; j < 2; j++)
|
||||
@@ -700,14 +695,11 @@ static void HWR_PrecacheLevelTextures(void)
|
||||
for (f = 0; f < 3; f++)
|
||||
{
|
||||
const INT32 texnum = sidetex[f];
|
||||
|
||||
if (texnum < 0 || texnum >= numtextures || texturepresent[texnum])
|
||||
continue;
|
||||
#ifdef GLENCORE
|
||||
|
||||
texturepresent[texnum] = 1|noencoremap;
|
||||
#else
|
||||
texturepresent[texnum] = 1;
|
||||
#endif
|
||||
|
||||
HWR_GetTexture(texnum, false);
|
||||
#ifdef GLENCORE
|
||||
if (noencoremap & 2)
|
||||
@@ -745,7 +737,7 @@ static void HWR_PrecacheLevelTextures(void)
|
||||
free(texturepresent);
|
||||
}
|
||||
|
||||
/*static void HWR_PrecacheLevelSprites(void)
|
||||
static void HWR_PrecacheLevelSprites(void)
|
||||
{
|
||||
patch_t *spritepatch;
|
||||
char *spritepresent;
|
||||
@@ -808,11 +800,11 @@ static void HWR_PrecacheLevelTextures(void)
|
||||
}
|
||||
}
|
||||
free(spritepresent);
|
||||
}*/
|
||||
}
|
||||
|
||||
void HWR_PrecacheLevel(void)
|
||||
{
|
||||
if (gamestate != GS_LEVEL || !cv_precachetextures.value)
|
||||
if (gamestate != GS_LEVEL)
|
||||
return;
|
||||
|
||||
// Precache flats.
|
||||
@@ -822,7 +814,7 @@ void HWR_PrecacheLevel(void)
|
||||
HWR_PrecacheLevelTextures();
|
||||
|
||||
// Precache sprites.
|
||||
//HWR_PrecacheLevelSprites();
|
||||
HWR_PrecacheLevelSprites();
|
||||
}
|
||||
|
||||
void HWR_LoadMapTextures(size_t pnumtextures)
|
||||
@@ -831,8 +823,11 @@ void HWR_LoadMapTextures(size_t pnumtextures)
|
||||
HWR_FreeMapTextures();
|
||||
|
||||
gl_numtextures = pnumtextures;
|
||||
gl_textures = calloc(gl_numtextures, sizeof(*gl_textures)); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
|
||||
|
||||
#ifdef GLENCORE
|
||||
gl_textures = calloc(gl_numtextures, sizeof (*gl_textures)*2); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore)
|
||||
#else
|
||||
gl_textures = calloc(gl_numtextures, sizeof (*gl_textures));
|
||||
#endif
|
||||
if (gl_textures == NULL)
|
||||
I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
|
||||
}
|
||||
@@ -856,7 +851,7 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
|
||||
// Every texture in memory, stored in the
|
||||
// hardware renderer's bit depth format. Wow!
|
||||
#ifdef GLENCORE
|
||||
gltex = (encoremap && !noencore) ? &gl_textures[tex].encore : &gl_textures[tex].normal;
|
||||
gltex = &gl_textures[tex*2 + (encoremap && !noencore ? 0 : 1)];
|
||||
#else
|
||||
gltex = &gl_textures[tex];
|
||||
#endif
|
||||
|
||||
+28
-29
@@ -46,9 +46,9 @@ typedef struct
|
||||
UINT8 image_descriptor; //18
|
||||
} ATTRPACK TGAHeader; // sizeof is 18
|
||||
|
||||
static const UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255};
|
||||
static const UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
|
||||
static const UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
|
||||
static UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255};
|
||||
static UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
|
||||
static UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
|
||||
|
||||
static const float FLOATBASEVIDWIDTH = (float)BASEVIDWIDTH;
|
||||
static const float FLOATBASEVIDHEIGHT = (float)BASEVIDHEIGHT;
|
||||
@@ -87,15 +87,15 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
|
||||
|
||||
switch (option & V_SCALEPATCHMASK)
|
||||
{
|
||||
case V_NOSCALEPATCH:
|
||||
dup = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
dup = (float)vid.smalldup;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
dup = (float)vid.meddup;
|
||||
break;
|
||||
case V_NOSCALEPATCH:
|
||||
dup = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
dup = (float)vid.smalldup;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
dup = (float)vid.meddup;
|
||||
break;
|
||||
}
|
||||
|
||||
fscalew = fscaleh = FIXED_TO_FLOAT(pscale);
|
||||
@@ -269,15 +269,15 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
|
||||
|
||||
switch (option & V_SCALEPATCHMASK)
|
||||
{
|
||||
case V_NOSCALEPATCH:
|
||||
dup = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
dup = (float)vid.smalldup;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
dup = (float)vid.meddup;
|
||||
break;
|
||||
case V_NOSCALEPATCH:
|
||||
dup = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
dup = (float)vid.smalldup;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
dup = (float)vid.meddup;
|
||||
break;
|
||||
}
|
||||
|
||||
fscale = FIXED_TO_FLOAT(pscale);
|
||||
@@ -506,7 +506,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
|
||||
|
||||
if (color & 0xFF00) // Do COLORMAP fade.
|
||||
{
|
||||
if (cv_glscreentextures.value && HWR_ShouldUsePaletteRendering())
|
||||
if (HWR_ShouldUsePaletteRendering() && cv_glscreentextures.value)
|
||||
{
|
||||
const hwdscreentexture_t scr_tex = HWD_SCREENTEXTURE_GENERIC2;
|
||||
|
||||
@@ -518,10 +518,12 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
|
||||
GL_UnSetShader();
|
||||
return;
|
||||
}
|
||||
|
||||
Surf.PolyColor.rgba = UINT2RGBA(0x01010160);
|
||||
Surf.PolyColor.s.alpha = (strength*8);
|
||||
poly_flags |= PF_Translucent;
|
||||
else
|
||||
{
|
||||
Surf.PolyColor.rgba = UINT2RGBA(0x01010160);
|
||||
Surf.PolyColor.s.alpha = (strength*8);
|
||||
poly_flags |= PF_Translucent;
|
||||
}
|
||||
}
|
||||
else // Do TRANSMAP** fade.
|
||||
{
|
||||
@@ -888,13 +890,11 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
|
||||
if (fx >= vid.width || fy >= vid.height)
|
||||
return;
|
||||
|
||||
if (fx < 0)
|
||||
{
|
||||
fw += fx;
|
||||
fx = 0;
|
||||
}
|
||||
|
||||
if (fy < 0)
|
||||
{
|
||||
fh += fy;
|
||||
@@ -906,7 +906,6 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
|
||||
if (fx + fw > vid.width)
|
||||
fw = fvw - fx;
|
||||
|
||||
if (fy + fh > vid.height)
|
||||
fh = fvh - fy;
|
||||
|
||||
|
||||
@@ -5840,7 +5840,7 @@ static void COM_HWR_glinfo(void)
|
||||
{
|
||||
argv = COM_Argv(i);
|
||||
|
||||
if (fastcmp(argv, "--list-extensions")|| fastcmp(argv, "-l"))
|
||||
if (strcmp(argv, "--list-extensions") == 0 || strcmp(argv, "-l") == 0)
|
||||
{
|
||||
list_extensions = 1;
|
||||
}
|
||||
|
||||
@@ -549,7 +549,7 @@ void HWR_InitMD2(void)
|
||||
{
|
||||
for (i = 0; i < NUMSPRITES; i++)
|
||||
{
|
||||
if (fasticmp(name, sprnames[i]))
|
||||
if (stricmp(name, sprnames[i]) == 0)
|
||||
{
|
||||
md2_models[i].scale = scale;
|
||||
md2_models[i].offset = offset;
|
||||
@@ -561,7 +561,7 @@ void HWR_InitMD2(void)
|
||||
|
||||
for (s = 0; s < MAXSKINS; s++)
|
||||
{
|
||||
if (fasticmp(name, skins[s].name))
|
||||
if (stricmp(name, skins[s].name) == 0)
|
||||
{
|
||||
md2_playermodels[s].skin = s;
|
||||
md2_playermodels[s].scale = scale;
|
||||
@@ -607,12 +607,11 @@ void HWR_AddPlayerMD2(int skin, boolean local) // For MD2's that were added afte
|
||||
}
|
||||
}
|
||||
|
||||
md2s = (local ? md2_localplayermodels : md2_playermodels);
|
||||
|
||||
md2s = ( (local) ? md2_localplayermodels : md2_playermodels );
|
||||
// Check for any MD2s that match the names of player skins!
|
||||
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
|
||||
{
|
||||
if (fasticmp(name, K_GetSkinArray(local)[skin].name))
|
||||
if (stricmp(name, K_GetSkinArray(local)[skin].name) == 0)
|
||||
{
|
||||
md2s[skin].skin = skin;
|
||||
md2s[skin].scale = scale;
|
||||
@@ -651,7 +650,6 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
|
||||
if (!f)
|
||||
{
|
||||
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
|
||||
|
||||
if (!f)
|
||||
{
|
||||
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
|
||||
@@ -663,7 +661,7 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
|
||||
// Check for any MD2s that match the names of sprite names!
|
||||
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
|
||||
{
|
||||
if (fasticmp(name, sprnames[spritenum]))
|
||||
if (stricmp(name, sprnames[spritenum]) == 0)
|
||||
{
|
||||
md2_models[spritenum].scale = scale;
|
||||
md2_models[spritenum].offset = offset;
|
||||
|
||||
@@ -126,7 +126,7 @@ tag_t *GetTagByName(model_t *model, char *name, int frame)
|
||||
int i;
|
||||
for (i = 0; i < model->numTags; i++)
|
||||
{
|
||||
if (fasticmp(iterator[i].name, name))
|
||||
if (!stricmp(iterator[i].name, name))
|
||||
return &iterator[i];
|
||||
}
|
||||
}
|
||||
@@ -163,22 +163,22 @@ model_t *LoadModel(const char *filename, int ztag)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (fastcmp(extension, ".md3"))
|
||||
if (!strcmp(extension, ".md3"))
|
||||
{
|
||||
if (!(model = MD3_LoadModel(filename, ztag, false)))
|
||||
return NULL;
|
||||
}
|
||||
else if (fastcmp(extension, ".md3s")) // MD3 that will be converted in memory to use full floats
|
||||
else if (!strcmp(extension, ".md3s")) // MD3 that will be converted in memory to use full floats
|
||||
{
|
||||
if (!(model = MD3_LoadModel(filename, ztag, true)))
|
||||
return NULL;
|
||||
}
|
||||
else if (fastcmp(extension, ".md2"))
|
||||
else if (!strcmp(extension, ".md2"))
|
||||
{
|
||||
if (!(model = MD2_LoadModel(filename, ztag, false)))
|
||||
return NULL;
|
||||
}
|
||||
else if (fastcmp(extension, ".md2s"))
|
||||
else if (!strcmp(extension, ".md2s"))
|
||||
{
|
||||
if (!(model = MD2_LoadModel(filename, ztag, true)))
|
||||
return NULL;
|
||||
|
||||
@@ -586,7 +586,7 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
|
||||
goto skip_field;
|
||||
}
|
||||
|
||||
if (fasticmp(stoken, "GLSL"))
|
||||
if (!stricmp(stoken, "GLSL"))
|
||||
{
|
||||
value = strtok(NULL, "\r\n ");
|
||||
if (!value)
|
||||
@@ -596,9 +596,9 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
|
||||
goto skip_lump;
|
||||
}
|
||||
|
||||
if (fasticmp(value, "VERTEX"))
|
||||
if (!stricmp(value, "VERTEX"))
|
||||
shadertype = 1;
|
||||
else if (fasticmp(value, "FRAGMENT"))
|
||||
else if (!stricmp(value, "FRAGMENT"))
|
||||
shadertype = 2;
|
||||
|
||||
skip_lump:
|
||||
@@ -624,7 +624,7 @@ skip_lump:
|
||||
|
||||
for (i = 0; shaderxlat[i].type; i++)
|
||||
{
|
||||
if (fasticmp(shaderxlat[i].type, stoken))
|
||||
if (!stricmp(shaderxlat[i].type, stoken))
|
||||
{
|
||||
size_t shader_string_length;
|
||||
char *shader_source;
|
||||
|
||||
+17
-25
@@ -431,7 +431,7 @@ void HU_Start(void)
|
||||
|
||||
void HU_Shiftform(void)
|
||||
{
|
||||
shiftxform = (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
|
||||
shiftxform = cv_keyboardlayout.value == 3 ? french_shiftxform : english_shiftxform;
|
||||
}
|
||||
|
||||
//======================================================================
|
||||
@@ -465,8 +465,8 @@ static INT16 addy = 0; // use this to make the messages scroll smoothly when one
|
||||
static void HU_removeChatText_Mini(void)
|
||||
{
|
||||
// MPC: Don't create new arrays, just iterate through an existing one
|
||||
for (size_t i = 0; i < chat_nummsg_min - 1; i++)
|
||||
{
|
||||
size_t i;
|
||||
for(i=0;i<chat_nummsg_min-1;i++) {
|
||||
strcpy(chat_mini[i], chat_mini[i+1]);
|
||||
chat_timers[i] = chat_timers[i+1];
|
||||
}
|
||||
@@ -485,8 +485,8 @@ static void HU_removeChatText_Log(void)
|
||||
return;
|
||||
|
||||
free(chat_log[0]);
|
||||
|
||||
for (size_t i = 0; i < chat_nummsg_log - 1;i++)
|
||||
size_t i;
|
||||
for(i=0;i<chat_nummsg_log-1;i++)
|
||||
{
|
||||
chat_log[i] = chat_log[i+1];
|
||||
}
|
||||
@@ -1101,14 +1101,14 @@ void HU_Ticker(void)
|
||||
size_t i = 0;
|
||||
|
||||
// handle spam while we're at it:
|
||||
for(; (i < MAXPLAYERS); i++)
|
||||
for(; (i<MAXPLAYERS); i++)
|
||||
{
|
||||
if (stop_spamming[i] > 0)
|
||||
stop_spamming[i]--;
|
||||
}
|
||||
|
||||
// handle chat timers
|
||||
for (i = 0; (i < chat_nummsg_min); i++)
|
||||
for (i=0; (i<chat_nummsg_min); i++)
|
||||
{
|
||||
if (chat_timers[i] > 0)
|
||||
chat_timers[i]--;
|
||||
@@ -1231,7 +1231,7 @@ static void HU_SendChatMessage(void)
|
||||
nodenum[2] = '\0';
|
||||
|
||||
// check for undesirable characters in our "number"
|
||||
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
|
||||
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
|
||||
{
|
||||
// check if nodenum[1] is a space
|
||||
if (nodenum[1] == ' ')
|
||||
@@ -1499,7 +1499,7 @@ static void HU_drawMiniChat(void)
|
||||
if (splitscreen > 1)
|
||||
boxw = max(64, boxw/2);
|
||||
|
||||
for (; i > 0; i--)
|
||||
for (; i>0; i--)
|
||||
{
|
||||
char *msg = CHAT_WordWrap(x+2, boxw-(charwidth*2), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i-1]);
|
||||
size_t j = 0;
|
||||
@@ -1572,7 +1572,7 @@ static void HU_drawMiniChat(void)
|
||||
i = 0;
|
||||
prev_linereturn = false;
|
||||
|
||||
for (; i <= (chat_nummsg_min-1); i++) // iterate through our hot messages
|
||||
for (; i<=(chat_nummsg_min-1); i++) // iterate through our hot messages
|
||||
{
|
||||
INT32 clrflag = 0;
|
||||
INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9; // see below...
|
||||
@@ -1749,6 +1749,7 @@ static void HU_drawChatLog(INT32 offset)
|
||||
Z_Free(msg);
|
||||
}
|
||||
|
||||
|
||||
if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime)) // was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.
|
||||
{
|
||||
atbottom = true; // we should scroll
|
||||
@@ -2283,7 +2284,6 @@ static void HU_DrawSongCreditsBox(void)
|
||||
V_DrawFill(x, y, strwidth*dup, BOXCREDITHEIGHT*dup, 28|flags|(bgt<<V_ALPHASHIFT));
|
||||
V_DrawFill(x+dup, y+dup, (strwidth-2)*dup, (BOXCREDITHEIGHT-2)*dup, 30|flags|(bgt<<V_ALPHASHIFT));
|
||||
}
|
||||
|
||||
if (cursongcredit.trans < NUMTRANSMAPS)
|
||||
{
|
||||
V_DrawSmallString(x+2*dup, y+2*dup, V_ALLOWLOWERCASE|flags|(cursongcredit.trans<<V_ALPHASHIFT), str);
|
||||
@@ -2845,8 +2845,12 @@ void HU_SetCEchoFlags(INT32 flags)
|
||||
|
||||
void HU_DoCEcho(const char *msg)
|
||||
{
|
||||
strlcpy(cechotext, msg, sizeof(cechotext));
|
||||
strlcat(cechotext, "\\", sizeof(cechotext));
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstringop-truncation" // This is fine, we set null byte later
|
||||
strncpy(cechotext, msg, sizeof(cechotext));
|
||||
#pragma GCC diagnostic pop
|
||||
strncat(cechotext, "\\", sizeof(cechotext) - strlen(cechotext) - 1);
|
||||
cechotext[sizeof(cechotext) - 1] = '\0';
|
||||
|
||||
// just print it to console
|
||||
if (cv_cechotoggle.value == 2)
|
||||
@@ -2855,20 +2859,8 @@ void HU_DoCEcho(const char *msg)
|
||||
strncpy(temp, cechotext, sizeof(temp));
|
||||
|
||||
for (char *p = temp; *p != '\0'; ++p)
|
||||
{
|
||||
if (*p == '\\')
|
||||
{
|
||||
*p = '\n';
|
||||
++p;
|
||||
char *skip_p = p; // Point at which we will move part of string after all \'s
|
||||
|
||||
while (*p == '\\')
|
||||
++p;
|
||||
|
||||
memmove(skip_p, p, strlen(p)+1); // move the rest of string with null byte
|
||||
p = skip_p; // Restore p
|
||||
}
|
||||
}
|
||||
|
||||
CONS_Printf("%s\n", temp);
|
||||
|
||||
|
||||
+34
-66
@@ -28,14 +28,14 @@
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#define USE_WINSOCK
|
||||
#define USE_WINSOCK
|
||||
#endif //WIN32 OS
|
||||
|
||||
#ifdef USE_WINSOCK
|
||||
#include <ws2tcpip.h>
|
||||
#define addrinfo_t ADDRINFOA
|
||||
#include <ws2tcpip.h>
|
||||
#define addrinfo_t ADDRINFOA
|
||||
#else
|
||||
#define addrinfo_t struct addrinfo
|
||||
#define addrinfo_t struct addrinfo
|
||||
#endif
|
||||
|
||||
#include "doomdef.h"
|
||||
@@ -148,16 +148,16 @@ static UINT8 UPNP_support = TRUE;
|
||||
|
||||
#define DEFAULTPORT "5029"
|
||||
|
||||
#ifdef USE_WINSOCK
|
||||
typedef SOCKET SOCKET_TYPE;
|
||||
#define ERRSOCKET (SOCKET_ERROR)
|
||||
#if defined (USE_WINSOCK)
|
||||
typedef SOCKET SOCKET_TYPE;
|
||||
#define ERRSOCKET (SOCKET_ERROR)
|
||||
#else
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (__HAIKU__)
|
||||
typedef int SOCKET_TYPE;
|
||||
#else
|
||||
typedef unsigned long SOCKET_TYPE;
|
||||
#endif
|
||||
#define ERRSOCKET (-1)
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (__HAIKU__)
|
||||
typedef int SOCKET_TYPE;
|
||||
#else
|
||||
typedef unsigned long SOCKET_TYPE;
|
||||
#endif
|
||||
#define ERRSOCKET (-1)
|
||||
#endif
|
||||
|
||||
#define IPV6_MULTICAST_ADDRESS "ff15::57e1:1a12"
|
||||
@@ -345,15 +345,17 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
|
||||
{
|
||||
static char s[64]; // 255.255.255.255:65535 or
|
||||
// [ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535
|
||||
|
||||
#ifdef HAVE_IPV6
|
||||
int v6 = (sk->any.sa_family == AF_INET6);
|
||||
#else
|
||||
int v6 = 0;
|
||||
#endif
|
||||
|
||||
void *addr;
|
||||
int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
|
||||
|
||||
if (sk->any.sa_family == AF_INET)
|
||||
if(sk->any.sa_family == AF_INET)
|
||||
addr = &sk->ip4.sin_addr;
|
||||
#ifdef HAVE_IPV6
|
||||
else if(sk->any.sa_family == AF_INET6)
|
||||
@@ -362,11 +364,9 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
|
||||
else
|
||||
addr = NULL;
|
||||
|
||||
if (addr == NULL)
|
||||
{
|
||||
if(addr == NULL)
|
||||
sprintf(s, "No address");
|
||||
}
|
||||
else if (inet_ntop(sk->any.sa_family, addr, &s[v6], sizeof (s) - v6) == NULL)
|
||||
else if(inet_ntop(sk->any.sa_family, addr, &s[v6], sizeof (s) - v6) == NULL)
|
||||
{
|
||||
e = errno;
|
||||
sprintf(s, "Unknown family type, error #%u: %s", e, strerror(e));
|
||||
@@ -381,7 +381,7 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
|
||||
strcat(s, va(":%d", ntohs(sk->ip6.sin6_port)));
|
||||
}
|
||||
#endif
|
||||
else if (sk->any.sa_family == AF_INET && sk->ip4.sin_port != 0)
|
||||
else if(sk->any.sa_family == AF_INET && sk->ip4.sin_port != 0)
|
||||
strcat(s, va(":%d", ntohs(sk->ip4.sin_port)));
|
||||
|
||||
return s;
|
||||
@@ -481,6 +481,7 @@ static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// This is a hack. For some reason, nodes aren't being freed properly.
|
||||
// This goes through and cleans up what nodes were supposed to be freed.
|
||||
/** \warning This function causes the file downloading to stop if someone joins.
|
||||
@@ -635,7 +636,7 @@ static boolean SOCK_Get(void)
|
||||
c = recvfrom(mysockets[n], (char *)&doomcom->data, MAXPACKETLENGTH, 0,
|
||||
(void *)&fromaddress, &fromlen);
|
||||
|
||||
if (c != ERRSOCKET)
|
||||
if (c > 0)
|
||||
{
|
||||
#ifdef USE_STUN
|
||||
if (STUN_got_response(doomcom->data, c))
|
||||
@@ -651,21 +652,20 @@ static boolean SOCK_Get(void)
|
||||
#endif
|
||||
|
||||
// find remote node number
|
||||
for (j = 1; j <= MAXNETNODES; j++) // include LAN
|
||||
for (j = 1; j <= MAXNETNODES; j++) //include LAN
|
||||
{
|
||||
if (SOCK_cmpaddr(&fromaddress, &clientaddress[j], 0))
|
||||
{
|
||||
doomcom->remotenode = (INT16)j; // good packet from a game player
|
||||
doomcom->datalength = (INT16)c;
|
||||
nodesocket[j] = mysockets[n];
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// not found
|
||||
|
||||
// find a free slot
|
||||
j = getfreenode();
|
||||
|
||||
if (j > 0)
|
||||
{
|
||||
const time_t curTime = time(NULL);
|
||||
@@ -752,7 +752,7 @@ static void SOCK_Send(void)
|
||||
int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
|
||||
size_t i, j;
|
||||
|
||||
if (doomcom->remotenode < 0 || !nodeconnected[doomcom->remotenode])
|
||||
if (!nodeconnected[doomcom->remotenode])
|
||||
return;
|
||||
|
||||
if (doomcom->remotenode == BROADCASTADDR)
|
||||
@@ -970,7 +970,7 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
|
||||
e = errno;
|
||||
I_OutputMsg("getting SO_RCVBUF failed: #%u, %s\n", e, strerror(e));
|
||||
}
|
||||
CONS_Printf(M_GetText("Network receive buffer: %dKb\n"), opt>>10);
|
||||
CONS_Printf(M_GetText("Network system buffer: %dKb\n"), opt>>10);
|
||||
|
||||
if (opt < 64<<10) // 64k
|
||||
{
|
||||
@@ -991,44 +991,9 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
|
||||
}
|
||||
|
||||
if (opt < 64<<10)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Can't set receive buffer length to 64k, file transfer will be bad\n"));
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Can't set buffer length to 64k, file transfer will be bad\n"));
|
||||
else
|
||||
CONS_Printf(M_GetText("Network receive buffer set to: %dKb\n"), opt>>10);
|
||||
}
|
||||
|
||||
opt = 0;
|
||||
opts = (socklen_t)sizeof(opt);
|
||||
rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &opts);
|
||||
if (rc <= -1)
|
||||
{
|
||||
e = errno;
|
||||
I_OutputMsg("getting SO_SNDBUF failed: #%u, %s\n", e, strerror(e));
|
||||
}
|
||||
CONS_Printf(M_GetText("Network send buffer: %dKb\n"), opt>>10);
|
||||
|
||||
if (opt < 64<<10) // 64k
|
||||
{
|
||||
opt = 64<<10;
|
||||
opts = (socklen_t)sizeof(opt);
|
||||
rc = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, opts);
|
||||
if (rc <= -1)
|
||||
{
|
||||
e = errno;
|
||||
I_OutputMsg("setting SO_SNDBUF to %dKb failed: #%u, %s\n", opt>>10, e, strerror(e));
|
||||
}
|
||||
|
||||
opt = 0;
|
||||
rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &opts);
|
||||
if (rc <= -1)
|
||||
{
|
||||
e = errno;
|
||||
I_OutputMsg("getting SO_SNDBUF failed: #%u, %s\n", e, strerror(e));
|
||||
}
|
||||
|
||||
if (opt < 64<<10)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Can't set send buffer length to 64k, file transfer will be bad\n"));
|
||||
else
|
||||
CONS_Printf(M_GetText("Network send system buffer set to: %dKb\n"), opt>>10);
|
||||
CONS_Printf(M_GetText("Network system buffer set to: %dKb\n"), opt>>10);
|
||||
}
|
||||
|
||||
rc = getsockname(s, &straddr.any, &len);
|
||||
@@ -1304,9 +1269,9 @@ void I_ShutdownTcpDriver(void)
|
||||
init_tcp_driver = false;
|
||||
}
|
||||
|
||||
static boolean SOCK_GetAddr(mysockaddr_t *sin, const char *address, const char *port, boolean test)
|
||||
static boolean SOCK_GetAddr(struct sockaddr_in *sin, const char *address, const char *port, boolean test)
|
||||
{
|
||||
addrinfo_t *ai, *runp, hints;
|
||||
addrinfo_t *ai = NULL, *runp, hints;
|
||||
int gaie;
|
||||
size_t i;
|
||||
|
||||
@@ -1322,7 +1287,10 @@ static boolean SOCK_GetAddr(mysockaddr_t *sin, const char *address, const char *
|
||||
gaie = getaddrinfo(address, port, &hints, &ai);
|
||||
|
||||
if (gaie != 0)
|
||||
{
|
||||
freeaddrinfo(ai);
|
||||
return false;
|
||||
}
|
||||
|
||||
runp = ai;
|
||||
|
||||
@@ -1362,7 +1330,7 @@ static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
|
||||
|
||||
if (newnode != -1)
|
||||
{
|
||||
if (!SOCK_GetAddr(&clientaddress[newnode], address, port, true))
|
||||
if (!SOCK_GetAddr(&clientaddress[newnode].ip4, address, port, true))
|
||||
{
|
||||
nodeconnected[newnode] = false;
|
||||
return -1;
|
||||
@@ -1390,7 +1358,7 @@ static void rendezvous(int size)
|
||||
|
||||
if (tic != refreshtic)
|
||||
{
|
||||
if (SOCK_GetAddr(&rzv, host, (port ? port : "7777"), false))
|
||||
if (SOCK_GetAddr(&rzv.ip4, host, (port ? port : "7777"), false))
|
||||
{
|
||||
refreshtic = tic;
|
||||
}
|
||||
|
||||
+4
-4
@@ -608,6 +608,9 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
|
||||
if (color >= MAXTRANSLATIONS)
|
||||
I_Error("Invalid skin color #%hu.", (UINT16)color);
|
||||
|
||||
if (skinnum < 0 && skinnum > TC_DEFAULT)
|
||||
I_Error("Invalid translation colormap index %d.", skinnum);
|
||||
|
||||
starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
|
||||
|
||||
if (starttranscolor >= NUM_PALETTE_ENTRIES)
|
||||
@@ -637,14 +640,11 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
|
||||
UINT8 K_GetKartColorByName(const char *name)
|
||||
{
|
||||
UINT8 color = (UINT8)atoi(name);
|
||||
|
||||
if (color > 0 && color < MAXSKINCOLORS)
|
||||
return color;
|
||||
|
||||
for (color = 1; color < MAXSKINCOLORS; color++)
|
||||
if (fasticmp(KartColor_Names[color], name))
|
||||
if (!stricmp(KartColor_Names[color], name))
|
||||
return color;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
+21
-7
@@ -377,7 +377,9 @@ static int lib_pSpawnMobj(lua_State *L)
|
||||
NOHUD
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnMobj(x, y, z, type), META_MOBJ);
|
||||
mobj_t *th = P_SpawnMobj(x, y, z, type);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -403,7 +405,9 @@ static int lib_pSpawnMissile(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnMissile(source, dest, type), META_MOBJ);
|
||||
mobj_t *th = P_SpawnMissile(source, dest, type);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -420,7 +424,9 @@ static int lib_pSpawnXYZMissile(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnXYZMissile(source, dest, type, x, y, z), META_MOBJ);
|
||||
mobj_t *th = P_SpawnXYZMissile(source, dest, type, x, y, z);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -439,7 +445,9 @@ static int lib_pSpawnPointMissile(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnPointMissile(source, xa, ya, za, type, x, y, z), META_MOBJ);
|
||||
mobj_t *th = P_SpawnPointMissile(source, xa, ya, za, type, x, y, z);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -456,7 +464,9 @@ static int lib_pSpawnAlteredDirectionMissile(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnAlteredDirectionMissile(source, type, x, y, z, shiftingAngle), META_MOBJ);
|
||||
mobj_t *th = P_SpawnAlteredDirectionMissile(source, type, x, y, z, shiftingAngle);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -485,7 +495,9 @@ static int lib_pSPMAngle(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SPMAngle(source, type, angle, allowaim, flags2), META_MOBJ);
|
||||
mobj_t *th = P_SPMAngle(source, type, angle, allowaim, flags2);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -499,7 +511,9 @@ static int lib_pSpawnPlayerMissile(lua_State *L)
|
||||
return LUA_ErrInvalid(L, "mobj_t");
|
||||
if (type >= NUMMOBJTYPES)
|
||||
return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
|
||||
LUA_PushUserdata(L, P_SpawnPlayerMissile(source, type, flags2), META_MOBJ);
|
||||
mobj_t *th = P_SpawnPlayerMissile(source, type, flags2);
|
||||
th->islocal = !hook_important;
|
||||
LUA_PushUserdata(L, th, META_MOBJ);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
@@ -453,7 +453,7 @@ static int lib_cvRegisterVar(lua_State *L)
|
||||
if (cvar->flags & CV_MODIFIED)
|
||||
return luaL_error(L, "failed to register cvar (probable conflict with internal variable/command names)");
|
||||
|
||||
if (!(((cvar->flags & CV_HIDEN)) || (cvar->flags & CV_NOSHOWHELP)) && (cvar->PossibleValue || !(cvar->value == 0 && !fasticmp(cvar->string, "0"))))
|
||||
if (!(((cvar->flags & CV_HIDEN)) || (cvar->flags & CV_NOSHOWHELP)) && (cvar->PossibleValue || !(cvar->value == 0 && stricmp(cvar->string, "0"))))
|
||||
{
|
||||
if (!category)
|
||||
{
|
||||
|
||||
@@ -109,6 +109,7 @@ ENUM (STRING_HOOK);
|
||||
|
||||
extern boolean hook_cmd_running; // This is used by PlayerCmd and lua_playerlib to prevent anything from being wirtten to player while we run PlayerCmd.
|
||||
extern int hook_defrosting;
|
||||
extern bool hook_important;
|
||||
|
||||
void LUA_HookVoid(int hook);
|
||||
void LUA_HookHUD(int hook, huddrawlist_h drawlist);
|
||||
|
||||
+29
-7
@@ -19,6 +19,7 @@
|
||||
#include "b_bot.h"
|
||||
#include "z_zone.h"
|
||||
#include "m_perfstats.h"
|
||||
#include "w_wad.h"
|
||||
|
||||
#include "lua_script.h"
|
||||
#include "lua_libs.h"
|
||||
@@ -39,14 +40,20 @@ LIST (stringHookNames, STRING_HOOK_LIST);
|
||||
|
||||
#undef LIST
|
||||
|
||||
typedef struct {
|
||||
int id;
|
||||
bool important;
|
||||
} hookinfo_t;
|
||||
|
||||
typedef struct {
|
||||
int numHooks;
|
||||
int *ids;
|
||||
hookinfo_t *ids;
|
||||
} hook_t;
|
||||
|
||||
typedef struct {
|
||||
int numGeneric;
|
||||
int ref;
|
||||
bool important;
|
||||
} stringhook_t;
|
||||
|
||||
static hook_t hookIds[HOOK(MAX)];
|
||||
@@ -56,6 +63,8 @@ static hook_t mobjHookIds[NUMMOBJTYPES][MOBJ_HOOK(MAX)];
|
||||
// Lua tables are used to lookup string hook ids.
|
||||
static stringhook_t stringHooks[STRING_HOOK(MAX)];
|
||||
|
||||
bool hook_important = true;
|
||||
|
||||
// This will be indexed by hook id, the value of which fetches the registry.
|
||||
static int * hookRefs;
|
||||
static int nextid;
|
||||
@@ -83,7 +92,7 @@ FUNCINLINE static ATTRINLINE unsigned hook_in_list
|
||||
|
||||
for (type = 0; list[type] != NULL; ++type)
|
||||
{
|
||||
if (fastcmp(name, list[type]))
|
||||
if (strcmp(name, list[type]) == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -109,7 +118,11 @@ static void get_table(lua_State *L)
|
||||
|
||||
FUNCINLINE static ATTRINLINE void add_hook_to_table(lua_State *L, int n)
|
||||
{
|
||||
lua_newtable(L);
|
||||
lua_pushnumber(L, nextid);
|
||||
lua_rawseti(L, -2, 1);
|
||||
lua_pushboolean(L, wadfiles[numwadfiles-1]->important);
|
||||
lua_rawseti(L, -2, 2);
|
||||
lua_rawseti(L, -2, n);
|
||||
}
|
||||
|
||||
@@ -180,7 +193,8 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
|
||||
{
|
||||
Z_Realloc(map->ids, (map->numHooks + 1) * sizeof *map->ids,
|
||||
PU_STATIC, &map->ids);
|
||||
map->ids[map->numHooks++] = nextid;
|
||||
map->ids[map->numHooks].important = wadfiles[numwadfiles-1]->important;
|
||||
map->ids[map->numHooks++].id = nextid;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
|
||||
@@ -240,7 +254,7 @@ static int lib_addHook(lua_State *L)
|
||||
{
|
||||
add_hook(&hookIds[type]);
|
||||
}
|
||||
/*else if (fastcmp(name, "HUD")) // ehh this is cool and all, but i dont want modders potentially breaking vanilla clients lol
|
||||
/*else if (strcmp(name, "HUD") == 0) // ehh this is cool and all, but i dont want modders potentially breaking vanilla clients lol
|
||||
{
|
||||
add_hud_hook(L, 3);
|
||||
}*/
|
||||
@@ -287,6 +301,7 @@ struct Hook_State {
|
||||
const char * string;/* used to fetch table, ran first if set */
|
||||
int top;/* index of last argument passed to hook */
|
||||
int id;/* id to fetch ref */
|
||||
boolean important;/* is this hook from local addon */
|
||||
int values;/* num arguments passed to hook */
|
||||
int results;/* num values returned by hook */
|
||||
Hook_Callback results_handler;/* callback when hook successfully returns */
|
||||
@@ -416,22 +431,29 @@ FUNCINLINE static ATTRINLINE void init_hook_call
|
||||
hook->results_handler = results_handler;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void get_hook(Hook_State *hook, const int *ids, int n)
|
||||
FUNCINLINE static ATTRINLINE void get_hook(Hook_State *hook, const hookinfo_t *ids, int n)
|
||||
{
|
||||
hook->id = ids[n];
|
||||
hook->id = ids[n].id;
|
||||
hook->important = ids[n].important;
|
||||
lua_getref(gL, hookRefs[hook->id]);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void get_hook_from_table(Hook_State *hook, int n)
|
||||
{
|
||||
lua_rawgeti(gL, -1, n);
|
||||
lua_rawgeti(gL, -1, 1);
|
||||
hook->id = lua_tonumber(gL, -1);
|
||||
lua_pop(gL, 1);
|
||||
lua_rawgeti(gL, -2, 2);
|
||||
hook->important = lua_toboolean(gL, -1);
|
||||
lua_pop(gL, 2);
|
||||
lua_getref(gL, hookRefs[hook->id]);
|
||||
}
|
||||
|
||||
static int call_single_hook_no_copy(Hook_State *hook)
|
||||
{
|
||||
hook_important = hook->important;
|
||||
|
||||
if (lua_pcall(gL, hook->values, hook->results, EINDEX) == 0)
|
||||
{
|
||||
if (hook->results > 0)
|
||||
@@ -818,7 +840,7 @@ typedef struct {
|
||||
|
||||
FUNCINLINE static ATTRINLINE boolean checkbotkey(const char *field)
|
||||
{
|
||||
return lua_toboolean(gL, -1) && fastcmp(lua_tostring(gL, -2), field);
|
||||
return lua_toboolean(gL, -1) && strcmp(lua_tostring(gL, -2), field) == 0;
|
||||
}
|
||||
|
||||
static void res_botai(Hook_State *hook)
|
||||
|
||||
+3
-3
@@ -455,12 +455,12 @@ int mobj_localskin_setter(lua_State *L)
|
||||
strlcpy(skin, luaL_optstring(L, 2, "none"), sizeof skin);
|
||||
strlwr(skin); // all skin names are lowercase
|
||||
|
||||
if (!fasticmp(skin, "none"))
|
||||
if (stricmp(skin, "none"))
|
||||
{
|
||||
// Try localskins
|
||||
for (i = 0; i < numlocalskins; i++)
|
||||
{
|
||||
if (fasticmp(localskins[i].name, skin))
|
||||
if (stricmp(localskins[i].name, skin) == 0)
|
||||
{
|
||||
mo->localskin = &localskins[i];
|
||||
mo->skinlocal = true;
|
||||
@@ -471,7 +471,7 @@ int mobj_localskin_setter(lua_State *L)
|
||||
// Try other skins
|
||||
for (i = 0; i < numskins; i++)
|
||||
{
|
||||
if (fasticmp(skins[i].name, skin))
|
||||
if (stricmp(skins[i].name, skin) == 0)
|
||||
{
|
||||
mo->localskin = &skins[i];
|
||||
mo->skinlocal = false;
|
||||
|
||||
@@ -288,10 +288,6 @@ void LUA_LoadLump(UINT16 wad, UINT16 lump)
|
||||
lumpinfo_t *lump_p = &wadfiles[wad]->lumpinfo[lump];
|
||||
len += 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
|
||||
name = malloc(len+1);
|
||||
|
||||
if (!name)
|
||||
I_Error("LUA_LoadLump: Out of memory!\n");
|
||||
|
||||
sprintf(name, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
|
||||
name[len] = '\0';
|
||||
}
|
||||
|
||||
+2
-2
@@ -183,7 +183,7 @@ static aatree_node_t *M_AATreeSetString_Node(aatree_node_t *node, UINT32 flags,
|
||||
else
|
||||
{
|
||||
aatree_entry_t *entry = node->value;
|
||||
if (entry != NULL && !fastcmp(entry->key, key))
|
||||
if (entry != NULL && strcmp(entry->key, key) != 0)
|
||||
entry = entry->next;
|
||||
if (entry != NULL)
|
||||
{
|
||||
@@ -252,7 +252,7 @@ void *M_AATreeGetString(aatree_t *aatree, const char *key)
|
||||
I_Assert((aatree->flags & AATREE_STRING) == AATREE_STRING);
|
||||
UINT32 hash = FNV1a_HashString(key);
|
||||
aatree_entry_t *entry = M_AATreeGet_Node(aatree->root, hash);
|
||||
while (entry != NULL && !fastcmp(entry->key, key))
|
||||
while (entry != NULL && strcmp(entry->key, key) != 0)
|
||||
entry = entry->next;
|
||||
return entry != NULL ? entry->value : NULL;
|
||||
}
|
||||
|
||||
+4
-6
@@ -49,7 +49,7 @@ INT32 M_CheckParm(const char *check)
|
||||
|
||||
for (i = 1; i < myargc; i++)
|
||||
{
|
||||
if (fasticmp(check, myargv[i]))
|
||||
if (!strcasecmp(check, myargv[i]))
|
||||
{
|
||||
found = i;
|
||||
return i;
|
||||
@@ -69,18 +69,16 @@ INT32 M_CheckProtoParam(const char *check)
|
||||
|
||||
for (i = 1; i < myargc; i++)
|
||||
{
|
||||
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
|
||||
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
|
||||
{
|
||||
if (strncmp(myargv[i]+11, check, strlen(check)) == 0)
|
||||
if (strncmp(myargv[i]+11, check, strlen(check))==0)
|
||||
{
|
||||
found = i;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
found = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -95,7 +93,7 @@ const char *M_GetProtoParam(void)
|
||||
|
||||
for (i = 1; i < myargc; i++)
|
||||
{
|
||||
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
|
||||
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
|
||||
{
|
||||
string = strchr(myargv[i], '/');
|
||||
string = strchr(string+1, '/');
|
||||
|
||||
+2
-2
@@ -112,7 +112,7 @@ void M_LoadEmotes(UINT16 wadnum)
|
||||
trim(field);
|
||||
trim(value);
|
||||
|
||||
if (fasticmp(field.c_str(), "frames"))
|
||||
if (stricmp(field.c_str(), "frames") == 0)
|
||||
{
|
||||
UINT8 numframes = 0;
|
||||
|
||||
@@ -158,7 +158,7 @@ void M_LoadEmotes(UINT16 wadnum)
|
||||
|
||||
emote->numframes = numframes;
|
||||
}
|
||||
else if (fasticmp(field.c_str(), "timeperframe"))
|
||||
else if (stricmp(field.c_str(), "timeperframe") == 0)
|
||||
{
|
||||
emote->timeperframe = std::stoi(value);
|
||||
|
||||
|
||||
+16
-20
@@ -3719,10 +3719,10 @@ static void M_HandleAddons(INT32 choice)
|
||||
break;
|
||||
case EXT_TXT:
|
||||
case EXT_CFG:
|
||||
if (fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, CONFIGFILENAME)
|
||||
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, AUTOLOADCONFIGFILENAME)
|
||||
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartserv.cfg")
|
||||
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartexec.cfg"))
|
||||
if ((strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, CONFIGFILENAME) == 0)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, AUTOLOADCONFIGFILENAME) == 0)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartserv.cfg") == 0)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartexec.cfg") == 0))
|
||||
{
|
||||
M_StartMessage(va("%c%s\x80\nYou can't autoload this builds' base console scripts, silly!\n They're already autoloaded on startup! \n\n(Press a key)\n", ('\x80' + (highlightflags>>V_CHARCOLORSHIFT)), dirmenu[dir_on[menudepthleft]]+DIR_STRING),NULL,MM_NOTHING);
|
||||
S_StartSound(NULL, sfx_s26d);
|
||||
@@ -3830,7 +3830,7 @@ static void ReplayNamesLoadThread(void* userdata)
|
||||
|
||||
Lock_search_state();
|
||||
|
||||
if (fastcmp(menupath, replaydirpath))
|
||||
if (strcmp(menupath, replaydirpath) == 0)
|
||||
{
|
||||
memcpy(demolist_all, demolist_all_local, sizeof(menudemo_t)*sizedirmenu);
|
||||
replaynamesloaded = true;
|
||||
@@ -6956,9 +6956,9 @@ static void M_ConnectMenuModChecks(INT32 choice)
|
||||
(void)choice;
|
||||
// okay never mind we want to COMMUNICATE to the player pre-emptively instead of letting them try and then get confused when it doesn't work
|
||||
|
||||
if (modifiedgame)
|
||||
if (modifiedgame || autoloaded)
|
||||
{
|
||||
M_StartMessage("You have addons loaded.\nYou won't be able to join netgames!\n\nTo play online, restart the game\nand don't load any addons.\nSRB2Kart will automatically add\neverything you need when you join.\n\n(Press a key)\n", M_ConnectMenu, MM_EVENTHANDLER);
|
||||
M_StartMessage(M_GetText("You have addons loaded.\nYou won't be able to join netgames!\n\nTo play online, restart the game\nand don't load any addons.\nSRB2Kart will automatically add\neverything you need when you join.\n\n(Press a key)\n"),M_ConnectMenu,MM_EVENTHANDLER);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -7179,21 +7179,17 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
|
||||
namescroll = 0;
|
||||
}
|
||||
|
||||
if (renderisnewtic)
|
||||
namescroll++;
|
||||
if (renderisnewtic) namescroll++;
|
||||
|
||||
char *addonname = wadfiles[mapwads[cv_nextmap.value-1]]->filename;
|
||||
INT32 len;
|
||||
INT32 charlimit = min((size_t)(21 + (dupadjust/5)), sizeof(namescrollbuf)-1);
|
||||
|
||||
nameonly(addonname);
|
||||
len = strlen(addonname);
|
||||
|
||||
if (len > charlimit)
|
||||
M_ScrollString(addonname, len, namescrollbuf, charlimit, namescroll);
|
||||
else
|
||||
strncpy(namescrollbuf, addonname, sizeof(namescrollbuf) - 1);
|
||||
|
||||
strncpy(namescrollbuf, addonname, sizeof(namescrollbuf));
|
||||
V_DrawThinString(x+w+5, y+i-8, V_TRANSLUCENT|MENUCAPS, namescrollbuf); // variable reuse...
|
||||
}
|
||||
|
||||
@@ -8283,12 +8279,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
|
||||
sprframe = &sprdef->spriteframes[frame];
|
||||
|
||||
// minenice's speen css, it's a piece of shit but hey
|
||||
//minenice's speen css, it's a piece of shit but hey
|
||||
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
|
||||
|
||||
// this is a very shitty solution for checking if a sprite needs flipping
|
||||
// but it works
|
||||
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
|
||||
//this is a very shitty solution for checking if a sprite needs flipping
|
||||
//but it works
|
||||
if ((sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]) && (speenframe > 4))
|
||||
flags = V_FLIP; // This sprite is left/right flipped!
|
||||
|
||||
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
|
||||
@@ -8808,7 +8804,7 @@ static boolean M_QuitMultiPlayerMenu(void)
|
||||
size_t l;
|
||||
|
||||
// send name if changed
|
||||
if (!fastcmp(setupm_name, setupm_cvname->string))
|
||||
if (strcmp(setupm_name, setupm_cvname->string))
|
||||
{
|
||||
// remove trailing whitespaces
|
||||
for (l= strlen(setupm_name)-1;
|
||||
@@ -9469,7 +9465,7 @@ static void M_VideoModeMenu(INT32 choice)
|
||||
// VESA mode, which is always a higher modenum
|
||||
for (j = 0; j < vidm_nummodes; j++)
|
||||
{
|
||||
if (fastcmp(modedescs[j].desc, desc))
|
||||
if (!strcmp(modedescs[j].desc, desc))
|
||||
{
|
||||
// mode(0): 320x200 is always standard VGA, not vesa
|
||||
if (modedescs[j].modenum)
|
||||
@@ -9643,7 +9639,7 @@ static void M_DrawLocalSkinMenu(void)
|
||||
|
||||
//this is a very shitty solution for checking if a sprite needs flipping
|
||||
//but it works
|
||||
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
|
||||
if ((sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]) && (speenframe > 4))
|
||||
{
|
||||
flags = V_FLIP; // This sprite is left/right flipped!
|
||||
}
|
||||
|
||||
+21
-25
@@ -944,23 +944,21 @@ static menuitem_t OP_ExpOptionsMenu[] =
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Skyboxes", &cv_skybox, 40},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Precache Level Textures", &cv_precachetextures, 50},
|
||||
{IT_STRING | IT_CVAR, NULL, "FPS counter sampling", &cv_accuratefps, 50},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "FPS counter sampling", &cv_accuratefps, 60},
|
||||
{IT_STRING | IT_CVAR, NULL, "Frameskip", &cv_frameskip, 60},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Frameskip", &cv_frameskip, 70},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Votescreen Scaling", &cv_votebgscaling, 80},
|
||||
{IT_STRING | IT_CVAR, NULL, "Votescreen Scaling", &cv_votebgscaling, 70},
|
||||
|
||||
#ifdef HWRENDER
|
||||
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 90},
|
||||
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 80},
|
||||
#ifdef USE_FBO_OGL
|
||||
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 95},
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 105},
|
||||
{IT_DISABLED, NULL, "", NULL, 115}, // dummy text
|
||||
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 85},
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 95},
|
||||
{IT_DISABLED, NULL, "", NULL, 105}, // dummy text
|
||||
#else
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 100},
|
||||
{IT_DISABLED, NULL, "", NULL, 110}, // dummy text
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 90},
|
||||
{IT_DISABLED, NULL, "", NULL, 100}, // dummy text
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
@@ -970,17 +968,16 @@ static const char* OP_ExpTooltips[] =
|
||||
NULL,
|
||||
"How far Mobj interpolation should take effect.",
|
||||
"When weather is on this will cut the object amount used in half.",
|
||||
"Sets minimum sector brightness, useful for dark areas.",
|
||||
"Sets minimum sector brightness, useful for dark areas",
|
||||
//"Should the directional lightning be randomized each map?\nTakes effect on next map load.",
|
||||
"Toggle being able to see the sky.",
|
||||
"Preload all level textures on level load.\nMassively reduces texture related stuttering during gameplay\nat the cost of longer level loading times.\nDisable this if you experience timeouts during level switches.",
|
||||
"Change the FPS counter sampling method\nInaccurate updates slower\nand might miss sudden framerate changes and drops,\nproviding a more averaged result.\nAccurate updates faster, but might be less readable.", // how to ingles??
|
||||
"Skips rendering frames if game logic takes too long\npreventing gameplay issues during performance drops.", // idk im shit as describing things
|
||||
"Change the FPS counter sampling method\nInaccurate updates slower and might miss frame drops and such\nAccurate updates faster and is more accurate, but might be less readable", // how to ingles??
|
||||
"Skips rendering frames if game logic takes too long preventing issues during performance drops." // idk im shit as describing things
|
||||
"Different methods of scaling the votescreen backgrounds.",
|
||||
#ifdef HWRENDER
|
||||
"Should the game do Screen Textures? Provides a good boost to frames\nat the cost of some visual effects not working when disabled.",
|
||||
#ifdef USE_FBO_OGL
|
||||
"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.",
|
||||
"Allows the game to downsample from a higher resolution than your display\nin OpenGL renderer mode. Requires a GPU with atleast OpenGL 3.0 support.",
|
||||
#endif
|
||||
"Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.",
|
||||
#endif
|
||||
@@ -994,7 +991,6 @@ enum
|
||||
op_exp_secbright,
|
||||
//op_exp_dirlight,
|
||||
op_exp_skybox,
|
||||
op_exp_texcache,
|
||||
op_exp_accuratefps,
|
||||
op_exp_frameskip,
|
||||
op_exp_votescrn,
|
||||
@@ -1379,15 +1375,15 @@ static menuitem_t OP_Player4CamOptionsMenu[] =
|
||||
static const char* OP_PlayerCamOptionsTooltips[] =
|
||||
{
|
||||
NULL,
|
||||
"Should the Camera flip on gravity flipped sections?",
|
||||
"Should the Camera flip on gravity flipped sections?.",
|
||||
"Camera distance relative to the Player.",
|
||||
"Height of the Camera.",
|
||||
"Pitch Camera on Upwards or Downhill Slopes.",
|
||||
"Speed of the Camera.",
|
||||
"Should looking back inherit the Players Momentum?\nEither inherit Player Momentum or double of it\nmay make looking back while boosting or going in high speed less jarring.",
|
||||
"Height of the Camera",
|
||||
"Pitch Camera on Upwards or Downhill Slopes",
|
||||
"Speed of the Camera",
|
||||
"Should looking back inherit the Players Momentum?\nEither inherit Player Momentum or double of it\nmay make looking back while boosting or going in high speed less jarring",
|
||||
"Allows looking up/down by holding\naim forward/backward while standing still.",
|
||||
"Speed of the Freecam/Spectator Camera.",
|
||||
"Toggle between Third or First Person camera.",
|
||||
"Speed of the Freecam/Spectator Camera",
|
||||
"Toggle between Third or First Person camera",
|
||||
};
|
||||
|
||||
// Ok it's still called chatoptions but we'll put ping display in here to be clean
|
||||
@@ -1767,7 +1763,7 @@ static const char* OP_PlayerDistortTooltips[] =
|
||||
"Distance object rotation should be visable.",
|
||||
"Player rotation when sliptiding.",
|
||||
"Rotation of a player's boost trails and drift sparks.",
|
||||
"Should banans rotate when thrown?\nAnd should they stay rotated when on the ground?",
|
||||
"Should banans rotate when thrown?\nAnd should they stay rotated when on the ground?.",
|
||||
"Player squash and stretch.",
|
||||
"Player landing sound effect.",
|
||||
"Kart hopping while drifting. This is purely visual.",
|
||||
|
||||
+1
-1
@@ -423,7 +423,7 @@ void Command_SaveConfig_f(void)
|
||||
FIL_ForceExtension(tmpstr, ".cfg");
|
||||
|
||||
M_SaveConfig(tmpstr);
|
||||
if (!fasticmp(COM_Argv(2), "-silent"))
|
||||
if (stricmp(COM_Argv(2), "-silent"))
|
||||
CONS_Printf(M_GetText("config saved as %s\n"), configfile);
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -916,7 +916,7 @@ static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
|
||||
int len = (int)strlen(str);
|
||||
char* str_ptr;
|
||||
|
||||
if (fastcmp(".lua", str + len - 4))
|
||||
if (strcmp(".lua", str + len - 4) == 0)
|
||||
{
|
||||
str[len-4] = '\0'; // remove .lua at end
|
||||
}
|
||||
|
||||
+23
-41
@@ -708,7 +708,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
HU_SetCEchoFlags(0);
|
||||
HU_SetCEchoDuration(5);
|
||||
HU_DoCEcho(va("%s\\was hit by a kitchen sink.\\\\\\\\", player_names[thing->player-players]));
|
||||
//I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[thing->player-players]);
|
||||
I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[thing->player-players]);
|
||||
P_DamageMobj(thing, tmthing, tmthing->target, DMG_INSTAKILL);
|
||||
P_KillMobj(tmthing, thing, thing);
|
||||
}
|
||||
@@ -977,7 +977,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
HU_SetCEchoFlags(0);
|
||||
HU_SetCEchoDuration(5);
|
||||
HU_DoCEcho(va("%s\\was hit by a kitchen sink.\\\\\\\\", player_names[tmthing->player-players]));
|
||||
//I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[tmthing->player-players]);
|
||||
I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[tmthing->player-players]);
|
||||
P_DamageMobj(tmthing, thing, thing->target, DMG_INSTAKILL);
|
||||
P_KillMobj(thing, tmthing, tmthing);
|
||||
}
|
||||
@@ -2189,7 +2189,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
//
|
||||
boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
{
|
||||
subsector_t *subsec;
|
||||
subsector_t *s;
|
||||
UINT8 i;
|
||||
|
||||
floatok = false;
|
||||
@@ -2198,9 +2198,9 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
return false;
|
||||
|
||||
if (thiscam->x != x || thiscam->y != y || thiscam->subsector == NULL)
|
||||
subsec = R_PointInSubsectorFast(x, y);
|
||||
s = R_PointInSubsectorFast(x, y);
|
||||
else
|
||||
subsec = thiscam->subsector;
|
||||
s = thiscam->subsector;
|
||||
|
||||
if (players[displayplayers[0]].mo)
|
||||
{
|
||||
@@ -2220,7 +2220,7 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
thiscam->ceilingz = thiscam->z + thiscam->height;
|
||||
thiscam->x = x;
|
||||
thiscam->y = y;
|
||||
thiscam->subsector = subsec;
|
||||
thiscam->subsector = s;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -2232,7 +2232,6 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
tryx -= MAXRADIUS;
|
||||
else
|
||||
tryx = x;
|
||||
|
||||
if (y-tryy > MAXRADIUS)
|
||||
tryy += MAXRADIUS;
|
||||
else if (y-tryy < -MAXRADIUS)
|
||||
@@ -2250,14 +2249,14 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
|
||||
if (tmceilingz - thiscam->z < thiscam->height)
|
||||
{
|
||||
if (subsec == thiscam->subsector && tmceilingz >= thiscam->z)
|
||||
if (s == thiscam->subsector && tmceilingz >= thiscam->z)
|
||||
{
|
||||
floatok = true;
|
||||
thiscam->floorz = tmfloorz;
|
||||
thiscam->ceilingz = tmfloorz + thiscam->height;
|
||||
thiscam->x = x;
|
||||
thiscam->y = y;
|
||||
thiscam->subsector = subsec;
|
||||
thiscam->subsector = s;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
@@ -2282,7 +2281,7 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
thiscam->ceilingz = tmceilingz;
|
||||
thiscam->x = x;
|
||||
thiscam->y = y;
|
||||
thiscam->subsector = subsec;
|
||||
thiscam->subsector = s;
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -2395,7 +2394,6 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
tryx -= radius;
|
||||
else
|
||||
tryx = x;
|
||||
|
||||
if (y-tryy > radius)
|
||||
tryy += radius;
|
||||
else if (y-tryy < -radius)
|
||||
@@ -2411,34 +2409,28 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
{
|
||||
//All things are affected by their scale.
|
||||
fixed_t maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale);
|
||||
INT32 special = 0;
|
||||
|
||||
if (thing->player)
|
||||
{
|
||||
special = GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1);
|
||||
const INT32 special = GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1);
|
||||
|
||||
// If using type Section1:13, double the maxstep.
|
||||
if (P_PlayerTouchingSectorSpecial(thing->player, 1, 13) || special == 13)
|
||||
{
|
||||
if (P_PlayerTouchingSectorSpecial(thing->player, 1, 13)
|
||||
|| special == 13)
|
||||
maxstep <<= 1;
|
||||
}
|
||||
// If using type Section1:12, no maxstep. For ledges you don't want the player to climb! (see: Egg Zeppelin & SMK port walls)
|
||||
else if (P_PlayerTouchingSectorSpecial(thing->player, 1, 12) || special == 12)
|
||||
{
|
||||
else if (P_PlayerTouchingSectorSpecial(thing->player, 1, 12)
|
||||
|| special == 12)
|
||||
maxstep = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (thing->type == MT_SKIM)
|
||||
{
|
||||
maxstep = 0;
|
||||
}
|
||||
|
||||
if (tmceilingz - tmfloorz < thing->height)
|
||||
{
|
||||
if (tmfloorthing)
|
||||
tmhitthing = tmfloorthing;
|
||||
|
||||
return false; // doesn't fit
|
||||
}
|
||||
|
||||
@@ -2471,8 +2463,11 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
return false; // mobj must lower itself to fit
|
||||
}
|
||||
}
|
||||
else if (maxstep > 0 && !(thing->player &&
|
||||
(P_PlayerTouchingSectorSpecial(thing->player, 1, 14) || special == 14))) // Step down
|
||||
else if (maxstep > 0 && !(
|
||||
thing->player && (
|
||||
P_PlayerTouchingSectorSpecial(thing->player, 1, 14)
|
||||
|| GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1) == 14)
|
||||
)) // Step down
|
||||
{
|
||||
// If the floor difference is MAXSTEPMOVE or less, and the sector isn't Section1:14, ALWAYS
|
||||
// step down! Formerly required a Section1:13 sector for the full MAXSTEPMOVE, but no more.
|
||||
@@ -2494,14 +2489,10 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
if (thing->eflags & MFE_VERTICALFLIP)
|
||||
{
|
||||
if (tmdrpoffceilz - tmceilingz > maxstep)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (tmfloorz - tmdropoffz > maxstep)
|
||||
{
|
||||
return false; // don't stand over a dropoff
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (tryx != x || tryy != y);
|
||||
@@ -2577,7 +2568,6 @@ boolean P_SceneryTryMove(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
|
||||
tryx = thing->x;
|
||||
tryy = thing->y;
|
||||
|
||||
do {
|
||||
if (x-tryx > MAXRADIUS)
|
||||
tryx += MAXRADIUS;
|
||||
@@ -2585,7 +2575,6 @@ boolean P_SceneryTryMove(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
tryx -= MAXRADIUS;
|
||||
else
|
||||
tryx = x;
|
||||
|
||||
if (y-tryy > MAXRADIUS)
|
||||
tryy += MAXRADIUS;
|
||||
else if (y-tryy < -MAXRADIUS)
|
||||
@@ -2598,14 +2587,14 @@ boolean P_SceneryTryMove(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
|
||||
if (!(thing->flags & MF_NOCLIP))
|
||||
{
|
||||
const fixed_t maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale);
|
||||
|
||||
if (tmceilingz - tmfloorz < thing->height)
|
||||
return false; // doesn't fit
|
||||
|
||||
if (tmceilingz - thing->z < thing->height)
|
||||
return false; // mobj must lower itself to fit
|
||||
|
||||
const fixed_t maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale);
|
||||
|
||||
if (tmfloorz - thing->z > maxstep)
|
||||
return false; // too big a step up
|
||||
}
|
||||
@@ -2939,7 +2928,6 @@ static boolean PTR_SlideTraverse(intercept_t *in)
|
||||
{
|
||||
if (P_PointOnLineSide(slidemo->x, slidemo->y, li))
|
||||
return true; // don't hit the back side
|
||||
|
||||
goto isblocking;
|
||||
}
|
||||
|
||||
@@ -3358,12 +3346,10 @@ void P_BouncePlayerMove(mobj_t *mo)
|
||||
|
||||
{
|
||||
mobj_t *fx = P_SpawnMobj(mo->x, mo->y, mo->z, MT_BUMP);
|
||||
|
||||
if (mo->eflags & MFE_VERTICALFLIP)
|
||||
fx->eflags |= MFE_VERTICALFLIP;
|
||||
else
|
||||
fx->eflags &= ~MFE_VERTICALFLIP;
|
||||
|
||||
fx->scale = mo->scale;
|
||||
|
||||
S_StartSound(mo, sfx_s3k49);
|
||||
@@ -3377,8 +3363,7 @@ void P_BouncePlayerMove(mobj_t *mo)
|
||||
mo->player->cmomx = tmxmove;
|
||||
mo->player->cmomy = tmymove;
|
||||
|
||||
if (!P_TryMove(mo, mo->x + tmxmove, mo->y + tmymove, true))
|
||||
{
|
||||
if (!P_TryMove(mo, mo->x + tmxmove, mo->y + tmymove, true)) {
|
||||
P_TryMove(mo, mo->x - oldmomx, mo->y - oldmomy, true);
|
||||
}
|
||||
}
|
||||
@@ -3755,7 +3740,6 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
|
||||
{
|
||||
size_t i;
|
||||
sector_t *sec;
|
||||
|
||||
for (i = 0; i < sector->numattached; i++)
|
||||
{
|
||||
sec = §ors[sector->attached[i]];
|
||||
@@ -3962,7 +3946,6 @@ static msecnode_t *P_DelSecnode(msecnode_t *node)
|
||||
|
||||
tp = node->m_sectorlist_prev;
|
||||
tn = node->m_sectorlist_next;
|
||||
|
||||
if (tp)
|
||||
tp->m_sectorlist_next = tn;
|
||||
if (tn)
|
||||
@@ -3973,7 +3956,6 @@ static msecnode_t *P_DelSecnode(msecnode_t *node)
|
||||
|
||||
sp = node->m_thinglist_prev;
|
||||
sn = node->m_thinglist_next;
|
||||
|
||||
if (sp)
|
||||
sp->m_thinglist_next = sn;
|
||||
else
|
||||
@@ -4021,7 +4003,7 @@ static inline boolean PIT_GetSectors(line_t *ld)
|
||||
// allowed to move to this position, then the sector_list
|
||||
// will be attached to the Thing's mobj_t at touching_sectorlist.
|
||||
|
||||
sector_list = P_AddSecnode(ld->frontsector, tmthing, sector_list);
|
||||
sector_list = P_AddSecnode(ld->frontsector,tmthing,sector_list);
|
||||
|
||||
// Don't assume all lines are 2-sided, since some Things
|
||||
// like MT_TFOG are allowed regardless of whether their radius takes
|
||||
|
||||
+1
-1
@@ -3391,7 +3391,7 @@ FUNCINLINE static ATTRINLINE void P_UnArchiveSPGame(savebuffer_t *save, INT16 ma
|
||||
|
||||
READSTRINGN(save->p, testname, sizeof(testname));
|
||||
|
||||
if (!fastcmp(testname, timeattackfolder))
|
||||
if (strcmp(testname, timeattackfolder))
|
||||
{
|
||||
if (modifiedgame)
|
||||
I_Error("Save game not for this modification.");
|
||||
|
||||
+16
-39
@@ -324,7 +324,6 @@ void P_InitPicAnims(void)
|
||||
lastanim->speed = LONG(animdefs[i].speed);
|
||||
lastanim++;
|
||||
}
|
||||
|
||||
lastanim->istexture = -1;
|
||||
R_ClearTextureNumCache(false);
|
||||
|
||||
@@ -332,7 +331,6 @@ void P_InitPicAnims(void)
|
||||
// We'll only be using anims from now on.
|
||||
if (animdefs != harddefs)
|
||||
Z_Free(animdefs);
|
||||
|
||||
animdefs = NULL;
|
||||
}
|
||||
|
||||
@@ -363,21 +361,20 @@ void P_ParseANIMDEFSLump(INT32 wadNum, UINT16 lumpnum)
|
||||
|
||||
// Now, let's start parsing this thing
|
||||
p = animdefsText;
|
||||
|
||||
animdefsToken = M_GetToken(p);
|
||||
while (animdefsToken != NULL)
|
||||
{
|
||||
if (fasticmp(animdefsToken, "TEXTURE"))
|
||||
if (stricmp(animdefsToken, "TEXTURE") == 0)
|
||||
{
|
||||
Z_Free(animdefsToken);
|
||||
P_ParseAnimationDefintion(1);
|
||||
}
|
||||
else if (fasticmp(animdefsToken, "FLAT"))
|
||||
else if (stricmp(animdefsToken, "FLAT") == 0)
|
||||
{
|
||||
Z_Free(animdefsToken);
|
||||
P_ParseAnimationDefintion(0);
|
||||
}
|
||||
else if (fasticmp(animdefsToken, "OSCILLATE"))
|
||||
else if (stricmp(animdefsToken, "OSCILLATE") == 0)
|
||||
{
|
||||
// This probably came off the tail of an earlier definition. It's technically legal syntax, but we don't support it.
|
||||
I_Error("Error parsing ANIMDEFS lump: Animation definitions utilizing \"OSCILLATE\" (the animation plays in reverse when it reaches the end) are not supported by SRB2");
|
||||
@@ -386,17 +383,11 @@ void P_ParseANIMDEFSLump(INT32 wadNum, UINT16 lumpnum)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Expected \"TEXTURE\" or \"FLAT\", got \"%s\"",animdefsToken);
|
||||
}
|
||||
|
||||
// parse next line
|
||||
while (*p != '\0' && *p != '\n')
|
||||
++p;
|
||||
|
||||
if (*p == '\n')
|
||||
++p;
|
||||
|
||||
while (*p != '\0' && *p != '\n') ++p;
|
||||
if (*p == '\n') ++p;
|
||||
animdefsToken = M_GetToken(p);
|
||||
}
|
||||
|
||||
Z_Free(animdefsToken);
|
||||
Z_Free((void *)animdefsText);
|
||||
}
|
||||
@@ -415,8 +406,7 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where start texture/flat name should be");
|
||||
}
|
||||
|
||||
if (fasticmp(animdefsToken, "OPTIONAL"))
|
||||
if (stricmp(animdefsToken, "OPTIONAL") == 0)
|
||||
{
|
||||
// This is meaningful to ZDoom - it tells the program NOT to bomb out
|
||||
// if the textures can't be found - but it's useless in SRB2, so we'll
|
||||
@@ -428,7 +418,7 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where start texture/flat name should be");
|
||||
}
|
||||
else if (fasticmp(animdefsToken, "RANGE"))
|
||||
else if (stricmp(animdefsToken, "RANGE") == 0)
|
||||
{
|
||||
// Oh. Um. Apparently "OPTIONAL" is a texture name. Naughty.
|
||||
// I should probably handle this more gracefully, but right now
|
||||
@@ -437,17 +427,15 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
I_Error("Error parsing ANIMDEFS lump: \"OPTIONAL\" is a keyword; you cannot use it as the startname of an animation");
|
||||
}
|
||||
}
|
||||
|
||||
animdefsTokenLength = strlen(animdefsToken);
|
||||
if (animdefsTokenLength > 8)
|
||||
if (animdefsTokenLength>8)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: lump name \"%s\" exceeds 8 characters", animdefsToken);
|
||||
}
|
||||
|
||||
// Search for existing animdef
|
||||
for (i = 0; i < maxanims; i++)
|
||||
{
|
||||
if (fasticmp(animdefsToken, animdefs[i].startname))
|
||||
if (stricmp(animdefsToken, animdefs[i].startname) == 0)
|
||||
{
|
||||
//CONS_Alert(CONS_NOTICE, "Duplicate animation: %s\n", animdefsToken);
|
||||
|
||||
@@ -456,7 +444,6 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
Z_Free(animdefsToken);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Not found
|
||||
if (i == maxanims)
|
||||
@@ -480,25 +467,21 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where \"RANGE\" after \"%s\"'s startname should be", animdefs[i].startname);
|
||||
}
|
||||
|
||||
if (fasticmp(animdefsToken, "ALLOWDECALS"))
|
||||
if (stricmp(animdefsToken, "ALLOWDECALS") == 0)
|
||||
{
|
||||
// Another ZDoom keyword, ho-hum. Skip it, move on to the next token.
|
||||
Z_Free(animdefsToken);
|
||||
animdefsToken = M_GetToken(NULL);
|
||||
}
|
||||
|
||||
if (fasticmp(animdefsToken, "PIC"))
|
||||
if (stricmp(animdefsToken, "PIC") == 0)
|
||||
{
|
||||
// This is technically legitimate ANIMDEFS syntax, but SRB2 doesn't support it.
|
||||
I_Error("Error parsing ANIMDEFS lump: Animation definitions utilizing \"PIC\" (specific frames instead of a consecutive range) are not supported by SRB2");
|
||||
}
|
||||
|
||||
if (!fasticmp(animdefsToken, "RANGE"))
|
||||
if (stricmp(animdefsToken, "RANGE") != 0)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Expected \"RANGE\" after \"%s\"'s startname, got \"%s\"", animdefs[i].startname, animdefsToken);
|
||||
}
|
||||
|
||||
Z_Free(animdefsToken);
|
||||
|
||||
// Endname
|
||||
@@ -507,13 +490,11 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where \"%s\"'s end texture/flat name should be", animdefs[i].startname);
|
||||
}
|
||||
|
||||
animdefsTokenLength = strlen(animdefsToken);
|
||||
if (animdefsTokenLength>8)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: lump name \"%s\" exceeds 8 characters", animdefsToken);
|
||||
}
|
||||
|
||||
strncpy(animdefs[i].endname, animdefsToken, 9);
|
||||
Z_Free(animdefsToken);
|
||||
|
||||
@@ -523,18 +504,15 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where \"%s\"'s \"TICS\" should be", animdefs[i].startname);
|
||||
}
|
||||
|
||||
if (fasticmp(animdefsToken, "RAND"))
|
||||
if (stricmp(animdefsToken, "RAND") == 0)
|
||||
{
|
||||
// This is technically legitimate ANIMDEFS syntax, but SRB2 doesn't support it.
|
||||
I_Error("Error parsing ANIMDEFS lump: Animation definitions utilizing \"RAND\" (random duration per frame) are not supported by SRB2");
|
||||
}
|
||||
|
||||
if (!fasticmp(animdefsToken, "TICS"))
|
||||
if (stricmp(animdefsToken, "TICS") != 0)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Expected \"TICS\" in animation definition for \"%s\", got \"%s\"", animdefs[i].startname, animdefsToken);
|
||||
}
|
||||
|
||||
Z_Free(animdefsToken);
|
||||
|
||||
// Speed
|
||||
@@ -543,7 +521,6 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Unexpected end of file where \"%s\"'s animation speed should be", animdefs[i].startname);
|
||||
}
|
||||
|
||||
endPos = NULL;
|
||||
#ifndef AVOID_ERRNO
|
||||
errno = 0;
|
||||
@@ -558,7 +535,6 @@ void P_ParseAnimationDefintion(SINT8 istexture)
|
||||
{
|
||||
I_Error("Error parsing ANIMDEFS lump: Expected a positive integer for \"%s\"'s animation speed, got \"%s\"", animdefs[i].startname, animdefsToken);
|
||||
}
|
||||
|
||||
animdefs[i].speed = animSpeed;
|
||||
Z_Free(animdefsToken);
|
||||
}
|
||||
@@ -2115,7 +2091,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
// Change the music and apply position/fade operations
|
||||
else
|
||||
{
|
||||
strlcpy(mapmusic.name, sides[line->sidenum[0]].text, sizeof(mapmusic.name));
|
||||
strncpy(mapmusic.name, sides[line->sidenum[0]].text, 7);
|
||||
mapmusic.name[6] = 0;
|
||||
|
||||
mapmusic.flags = tracknum & MUSIC_TRACKMASK;
|
||||
if (!(line->flags & ML_BLOCKMONSTERS))
|
||||
|
||||
+7
-17
@@ -3315,7 +3315,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam, UINT8 num)
|
||||
cmd->sidemove = (SINT8)(cmd->sidemove + side);
|
||||
}
|
||||
|
||||
lang += (cmd->angleturn << 16);
|
||||
lang += (cmd->angleturn<<16);
|
||||
|
||||
cam->localangle = lang;
|
||||
if (!cam->reset_aiming)
|
||||
@@ -3821,13 +3821,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
|
||||
|
||||
if (demo.playback)
|
||||
{
|
||||
// Hack-adjacent.
|
||||
// Sometimes stale ticcmds send a weird angle at the start of the race.
|
||||
// P_UpdatePlayerAngle knows to ignore cmd angle when you literally can't turn, so we do the same here.
|
||||
if (cv_demoangturn.value && leveltime > starttime)
|
||||
focusangle = player->cmd.angleturn << 16;
|
||||
else
|
||||
focusangle = mo->angle; // Just use something known sane.
|
||||
focusangle = mo->angle;
|
||||
focusaiming = 0;
|
||||
}
|
||||
else if (P_IsLocalPlayer(player))
|
||||
@@ -4315,19 +4309,17 @@ static void P_CalcPostImg(player_t *player, camera_t *thiscam)
|
||||
{
|
||||
sector_t *sector = NULL;
|
||||
UINT8 postimgtype = 0;
|
||||
//INT32 *param;
|
||||
fixed_t pviewheight = 0;
|
||||
#ifdef MOTIONBLUR
|
||||
INT32 *param;
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
/*for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player == &players[displayplayers[i]])
|
||||
{
|
||||
param = &postimgparam[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}*/
|
||||
|
||||
if (encoremode) // srb2kart
|
||||
postimgtype |= POSTIMG_MIRROR;
|
||||
@@ -4363,18 +4355,16 @@ static void P_CalcPostImg(player_t *player, camera_t *thiscam)
|
||||
else if (P_CameraCheckHeatFirstperson(player, sector, pviewheight))
|
||||
postimgtype |= POSTIMG_HEAT;
|
||||
|
||||
#ifdef MOTIONBLUR
|
||||
// Motion blur
|
||||
// unused
|
||||
if (player->speed > (35<<FRACBITS))
|
||||
/*if (player->speed > (35<<FRACBITS))
|
||||
{
|
||||
postimgtype |= POSTIMG_MOTION;
|
||||
*param = (player->speed - 32)/4;
|
||||
|
||||
if (*param > 5)
|
||||
*param = 5;
|
||||
}
|
||||
#endif
|
||||
}*/
|
||||
|
||||
thiscam->postimg = postimgtype;
|
||||
}
|
||||
|
||||
+13
-31
@@ -867,7 +867,7 @@ static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where comma after \"%s\"'s patch name should be",patchName);
|
||||
}
|
||||
|
||||
if (!fastcmp(texturesToken,","))
|
||||
if (strcmp(texturesToken,",")!=0)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \",\" after %s's patch name, got \"%s\"",patchName,texturesToken);
|
||||
}
|
||||
@@ -907,7 +907,7 @@ static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where comma after patch \"%s\"'s x coordinate should be",patchName);
|
||||
}
|
||||
|
||||
if (!fastcmp(texturesToken,","))
|
||||
if (strcmp(texturesToken,",")!=0)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \",\" after patch \"%s\"'s x coordinate, got \"%s\"",patchName,texturesToken);
|
||||
}
|
||||
@@ -976,9 +976,8 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where texture name should be");
|
||||
}
|
||||
|
||||
texturesTokenLength = strlen(texturesToken);
|
||||
if (texturesTokenLength > 8)
|
||||
if (texturesTokenLength>8)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Texture name \"%s\" exceeds 8 characters",texturesToken);
|
||||
}
|
||||
@@ -989,7 +988,6 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
// ^^ we've confirmed that the token is <= 8 characters so it will never overflow a 9 byte char buffer
|
||||
strupr(newTextureName); // Just do this now so we don't have to worry about it
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
|
||||
// Comma 1
|
||||
@@ -998,11 +996,10 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where comma after texture \"%s\"'s name should be",newTextureName);
|
||||
}
|
||||
else if (!fastcmp(texturesToken, ","))
|
||||
else if (strcmp(texturesToken,",")!=0)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \",\" after texture \"%s\"'s name, got \"%s\"",newTextureName,texturesToken);
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
|
||||
// Width
|
||||
@@ -1033,12 +1030,10 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where comma after texture \"%s\"'s width should be",newTextureName);
|
||||
}
|
||||
|
||||
if (!fastcmp(texturesToken, ","))
|
||||
if (strcmp(texturesToken,",")!=0)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \",\" after texture \"%s\"'s width, got \"%s\"",newTextureName,texturesToken);
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
|
||||
// Height
|
||||
@@ -1071,7 +1066,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where open curly brace for texture \"%s\" should be",newTextureName);
|
||||
}
|
||||
|
||||
if (fastcmp(texturesToken, "{"))
|
||||
if (strcmp(texturesToken,"{")==0)
|
||||
{
|
||||
if (actuallyLoadTexture)
|
||||
{
|
||||
@@ -1083,18 +1078,15 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
resultTexture->height = newTextureHeight;
|
||||
resultTexture->type = TEXTURETYPE_COMPOSITE;
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
|
||||
texturesToken = M_GetToken(NULL);
|
||||
if (texturesToken == NULL)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where patch definition for texture \"%s\" should be",newTextureName);
|
||||
}
|
||||
|
||||
while (!fastcmp(texturesToken, "}"))
|
||||
while (strcmp(texturesToken,"}")!=0)
|
||||
{
|
||||
if (fasticmp(texturesToken, "PATCH"))
|
||||
if (stricmp(texturesToken, "PATCH")==0)
|
||||
{
|
||||
Z_Free(texturesToken);
|
||||
if (resultTexture)
|
||||
@@ -1126,7 +1118,6 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
I_Error("Error parsing TEXTURES lump: Unexpected end of file where patch declaration or right curly brace for texture \"%s\" should be",newTextureName);
|
||||
}
|
||||
}
|
||||
|
||||
if (resultTexture && resultTexture->patchcount == 0)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Texture \"%s\" must have at least one patch",newTextureName);
|
||||
@@ -1136,13 +1127,10 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \"{\" for texture \"%s\", got \"%s\"",newTextureName,texturesToken);
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
|
||||
if (actuallyLoadTexture)
|
||||
return resultTexture;
|
||||
|
||||
return NULL;
|
||||
if (actuallyLoadTexture) return resultTexture;
|
||||
else return NULL;
|
||||
}
|
||||
|
||||
// Parses the TEXTURES lump... but just to count the number of textures.
|
||||
@@ -1174,7 +1162,7 @@ int R_CountTexturesInTEXTURESLump(UINT16 wadNum, UINT16 lumpNum)
|
||||
texturesToken = M_GetToken(texturesText);
|
||||
while (texturesToken != NULL)
|
||||
{
|
||||
if (fasticmp(texturesToken, "WALLTEXTURE"))
|
||||
if (stricmp(texturesToken, "WALLTEXTURE")==0)
|
||||
{
|
||||
numTexturesInLump++;
|
||||
Z_Free(texturesToken);
|
||||
@@ -1184,10 +1172,8 @@ int R_CountTexturesInTEXTURESLump(UINT16 wadNum, UINT16 lumpNum)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \"WALLTEXTURE\", got \"%s\"",texturesToken);
|
||||
}
|
||||
|
||||
texturesToken = M_GetToken(NULL);
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
Z_Free((void *)texturesText);
|
||||
|
||||
@@ -1225,7 +1211,7 @@ void R_ParseTEXTURESLump(UINT16 wadNum, UINT16 lumpNum, INT32 *texindex)
|
||||
texturesToken = M_GetToken(texturesText);
|
||||
while (texturesToken != NULL)
|
||||
{
|
||||
if (fasticmp(texturesToken, "WALLTEXTURE"))
|
||||
if (stricmp(texturesToken, "WALLTEXTURE")==0)
|
||||
{
|
||||
Z_Free(texturesToken);
|
||||
// Get the new texture
|
||||
@@ -1241,10 +1227,8 @@ void R_ParseTEXTURESLump(UINT16 wadNum, UINT16 lumpNum, INT32 *texindex)
|
||||
{
|
||||
I_Error("Error parsing TEXTURES lump: Expected \"WALLTEXTURE\", got \"%s\"",texturesToken);
|
||||
}
|
||||
|
||||
texturesToken = M_GetToken(NULL);
|
||||
}
|
||||
|
||||
Z_Free(texturesToken);
|
||||
Z_Free((void *)texturesText);
|
||||
}
|
||||
@@ -1350,9 +1334,8 @@ lumpnum_t R_GetFlatNumForName(const char *name)
|
||||
|
||||
if (lump == LUMPERROR)
|
||||
{
|
||||
if (!fastcmp(name, SKYFLATNAME))
|
||||
if (strcmp(name, SKYFLATNAME))
|
||||
CONS_Debug(DBG_SETUP, "R_GetFlatNumForName: Could not find flat %.8s\n", name);
|
||||
|
||||
lump = W_CheckNumForName("REDFLR");
|
||||
}
|
||||
|
||||
@@ -1408,7 +1391,6 @@ void R_ReInitColormaps(UINT16 num, lumpnum_t newencoremap)
|
||||
|
||||
// Load in the light tables, now 64k aligned for smokie...
|
||||
lump = W_GetNumForName(colormap);
|
||||
|
||||
if (lump == LUMPERROR)
|
||||
lump = basecolormaplump;
|
||||
else
|
||||
|
||||
@@ -260,7 +260,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
|
||||
// texture has no height, so just go
|
||||
while (--count >= 0)
|
||||
{
|
||||
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS), source, colormap);
|
||||
*dest = R_DrawColumnPixel<Type>(dc, dest, frac>>FRACBITS, source, colormap);
|
||||
|
||||
dest += stride;
|
||||
frac += fracstep;
|
||||
|
||||
+18
-24
@@ -208,15 +208,15 @@ static void R_CalcTiltedLighting(std::vector<INT32>& lightbuffer, INT32 x1, INT3
|
||||
|
||||
for (i = x1; i <= x2; i++)
|
||||
{
|
||||
const fixed_t light = start >> FRACBITS;
|
||||
fixed_t light = start >> FRACBITS;
|
||||
lightbuffer[i] = CLAMP(light, 0, MAXLIGHTSCALE - 1);
|
||||
start += step;
|
||||
}
|
||||
}
|
||||
|
||||
static void R_GetTiltedLighting(std::vector<INT32>& tiltlighting, const drawspandata_t* ds, const float iz, const INT32 width, const INT32 stride)
|
||||
static void R_GetTiltedLighting(std::vector<INT32>& tiltlighting, const drawspandata_t* ds, const float iz, const int width, const INT32 stride)
|
||||
{
|
||||
const float planelightfloat = PLANELIGHTFLOAT;
|
||||
float planelightfloat = PLANELIGHTFLOAT;
|
||||
const fixed_t lightstart = FloatToFixed(iz * planelightfloat);
|
||||
const fixed_t lightend = FloatToFixed((iz + ds->szp.x * width) * planelightfloat);
|
||||
|
||||
@@ -232,7 +232,7 @@ static void R_GetTiltedLighting(std::vector<INT32>& tiltlighting, const drawspan
|
||||
template<DrawSpanType Type>
|
||||
static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
{
|
||||
INT32 width = ds->x2 - ds->x1;
|
||||
int width = ds->x2 - ds->x1;
|
||||
float iz, uz, vz;
|
||||
UINT32 u, v;
|
||||
int i;
|
||||
@@ -246,6 +246,7 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
UINT32 stepu, stepv;
|
||||
UINT32 bit;
|
||||
|
||||
INT32 x1 = ds->x1;
|
||||
const INT32 nflatxshift = ds->nflatxshift;
|
||||
const INT32 nflatyshift = ds->nflatyshift;
|
||||
const INT32 nflatmask = ds->nflatmask;
|
||||
@@ -262,11 +263,6 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
const UINT8 * restrict source = ds->source;
|
||||
const UINT8 * restrict colormap = ds->colormap;
|
||||
|
||||
const ptrdiff_t colormap_diff = (colormap - colormaps);
|
||||
|
||||
const INT32 * restrict tiltlight = tiltlighting.data();
|
||||
lighttable_t * const * restrict planezlight = ds->planezlight;
|
||||
|
||||
if constexpr (Type & DS_RIPPLE)
|
||||
{
|
||||
dsrc = vid.screens[1] + (ds->y + ds->bgofs) * stride + ds->x1;
|
||||
@@ -304,6 +300,7 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
izstep = ds->szp.x * SPANSIZE;
|
||||
uzstep = ds->sup.x * SPANSIZE;
|
||||
vzstep = ds->svp.x * SPANSIZE;
|
||||
//x1 = 0;
|
||||
width++;
|
||||
|
||||
while (width >= SPANSIZE)
|
||||
@@ -320,12 +317,12 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
u = (INT64)(startu);
|
||||
v = (INT64)(startv);
|
||||
|
||||
const INT32 x1 = ds->x1;
|
||||
x1 = ds->x1;
|
||||
|
||||
for (i = 0; i < SPANSIZE; i++)
|
||||
{
|
||||
bit = (((v + stepv * i) >> nflatyshift) & nflatmask) | ((u + stepu * i) >> nflatxshift);
|
||||
colormap = planezlight[tiltlight[x1 + i]] + colormap_diff;
|
||||
colormap = ds->planezlight[tiltlighting[x1 + i]] + (ds->colormap - colormaps);
|
||||
if constexpr (Type & DS_RIPPLE)
|
||||
dest[i] = R_DrawSpanPixel<Type>(ds, &dsrc[i], colormap, bit, source);
|
||||
else
|
||||
@@ -348,7 +345,7 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
u = (INT64)(startu);
|
||||
v = (INT64)(startv);
|
||||
bit = ((v >> nflatyshift) & nflatmask) | (u >> nflatxshift);
|
||||
colormap = planezlight[tiltlight[ds->x1]] + colormap_diff;
|
||||
colormap = ds->planezlight[tiltlighting[ds->x1]] + (ds->colormap - colormaps);
|
||||
if constexpr (Type & DS_RIPPLE)
|
||||
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
|
||||
else
|
||||
@@ -374,7 +371,7 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
|
||||
for (; width != 0; width--)
|
||||
{
|
||||
bit = ((v >> ds->nflatyshift) & ds->nflatmask) | (u >> ds->nflatxshift);
|
||||
colormap = planezlight[tiltlight[ds->x1]] + colormap_diff;
|
||||
colormap = ds->planezlight[tiltlighting[ds->x1]] + (ds->colormap - colormaps);
|
||||
if constexpr (Type & DS_RIPPLE)
|
||||
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
|
||||
else
|
||||
@@ -413,7 +410,7 @@ DEFINE_SPAN_COMBO(R_DrawTranslucentWaterSpan, DS_TRANSMAP|DS_RIPPLE)
|
||||
*/
|
||||
void R_DrawFogSpan(drawspandata_t* ds)
|
||||
{
|
||||
intptr_t count = ds->x2 - ds->x1 + 1;
|
||||
INT32 count = ds->x2 - ds->x1 + 1;
|
||||
|
||||
const UINT8 * restrict colormap = ds->colormap;
|
||||
UINT8 * restrict dest = R_Address(ds->x1, ds->y);
|
||||
@@ -438,23 +435,20 @@ void R_DrawFogSpan(drawspandata_t* ds)
|
||||
|
||||
void R_DrawFogSpan_Tilted(drawspandata_t* ds)
|
||||
{
|
||||
INT32 width = ds->x2 - ds->x1;
|
||||
const INT32 stride = vid.width;
|
||||
const float iz = ds->szp.z + ds->szp.y*(centery-ds->y) + ds->szp.x*(ds->x1-centerx);
|
||||
UINT8 * restrict dest = R_Address(ds->x1, ds->y);
|
||||
const ptrdiff_t colormap_diff = (ds->colormap - colormaps);
|
||||
|
||||
int width = ds->x2 - ds->x1;
|
||||
float iz = ds->szp.z + ds->szp.y*(centery-ds->y) + ds->szp.x*(ds->x1-centerx);
|
||||
UINT8 * restrict dest;
|
||||
local_for_thread std::vector<INT32> tiltlighting;
|
||||
|
||||
dest = R_Address(ds->x1, ds->y);
|
||||
const INT32 stride = vid.width;
|
||||
|
||||
// Lighting is simple. It's just linear interpolation from start to end
|
||||
R_GetTiltedLighting(tiltlighting, ds, iz, width, stride);
|
||||
|
||||
const INT32 * restrict tiltlight = tiltlighting.data();
|
||||
lighttable_t * const * restrict planezlight = ds->planezlight;
|
||||
|
||||
do
|
||||
{
|
||||
UINT8 *colormap = planezlight[tiltlight[ds->x1++]] + colormap_diff;
|
||||
UINT8 *colormap = ds->planezlight[tiltlighting[ds->x1++]] + (ds->colormap - colormaps);
|
||||
*dest = colormap[*dest];
|
||||
dest++;
|
||||
}
|
||||
|
||||
+1
-4
@@ -253,7 +253,6 @@ void SplitScreen_OnChange(void)
|
||||
if (playeringame[i] && i != consoleplayer)
|
||||
{
|
||||
UINT8 j;
|
||||
|
||||
for (j = 1; j < MAXSPLITSCREENPLAYERS; j++)
|
||||
{
|
||||
if (displayplayers[j] == consoleplayer)
|
||||
@@ -269,7 +268,6 @@ void SplitScreen_OnChange(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void Fov_OnChange(void)
|
||||
{
|
||||
R_SetViewSize();
|
||||
@@ -945,10 +943,9 @@ void R_ExecuteSetViewSize(void)
|
||||
memset(scalelight, 0xFF, sizeof(scalelight));
|
||||
|
||||
// Calculate the light levels to use for each level/scale combination.
|
||||
for (i = 0; i < LIGHTLEVELS; i++)
|
||||
for (i = 0; i< LIGHTLEVELS; i++)
|
||||
{
|
||||
startmapl = ((LIGHTLEVELS - 1 - i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
|
||||
|
||||
for (j = 0; j < MAXLIGHTSCALE; j++)
|
||||
{
|
||||
level = startmapl - j*vid.width/(viewwidth)/DISTMAP;
|
||||
|
||||
+46
-58
@@ -46,14 +46,13 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite frame should be");
|
||||
}
|
||||
|
||||
sprinfoTokenLength = strlen(sprinfoToken);
|
||||
if (sprinfoTokenLength != 1)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Invalid frame \"%s\"",sprinfoToken);
|
||||
}
|
||||
|
||||
frameChar = sprinfoToken;
|
||||
else
|
||||
frameChar = sprinfoToken;
|
||||
|
||||
frameFrame = R_Char2Frame(frameChar[0]);
|
||||
Z_Free(sprinfoToken);
|
||||
@@ -62,53 +61,53 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (sprinfoToken == NULL)
|
||||
I_Error("Error parsing SPRTINFO lump: Missing sprite info");
|
||||
|
||||
if (fastcmp(sprinfoToken, "{"))
|
||||
else
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (sprinfoToken == NULL)
|
||||
if (strcmp(sprinfoToken,"{")==0)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite info should be");
|
||||
}
|
||||
while (!fastcmp(sprinfoToken, "}"))
|
||||
{
|
||||
if (fasticmp(sprinfoToken, "XPIVOT"))
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
frameXPivot = atoi(sprinfoToken);
|
||||
}
|
||||
else if (fasticmp(sprinfoToken, "YPIVOT"))
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
frameYPivot = atoi(sprinfoToken);
|
||||
}
|
||||
else if (fasticmp(sprinfoToken, "ROTAXIS"))
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (fasticmp(sprinfoToken, "X") || fasticmp(sprinfoToken, "XAXIS") || fasticmp(sprinfoToken, "ROLL"))
|
||||
frameRotAxis = ROTAXIS_X;
|
||||
else if (fasticmp(sprinfoToken, "Y") || fasticmp(sprinfoToken, "YAXIS") || fasticmp(sprinfoToken, "PITCH"))
|
||||
frameRotAxis = ROTAXIS_Y;
|
||||
else if (fasticmp(sprinfoToken, "Z") || fasticmp(sprinfoToken, "ZAXIS") || fasticmp(sprinfoToken, "YAW"))
|
||||
frameRotAxis = ROTAXIS_Z;
|
||||
}
|
||||
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (sprinfoToken == NULL)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite info or right curly brace should be");
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite info should be");
|
||||
}
|
||||
while (strcmp(sprinfoToken,"}")!=0)
|
||||
{
|
||||
if (stricmp(sprinfoToken, "XPIVOT")==0)
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
frameXPivot = atoi(sprinfoToken);
|
||||
}
|
||||
else if (stricmp(sprinfoToken, "YPIVOT")==0)
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
frameYPivot = atoi(sprinfoToken);
|
||||
}
|
||||
else if (stricmp(sprinfoToken, "ROTAXIS")==0)
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if ((stricmp(sprinfoToken, "X")==0) || (stricmp(sprinfoToken, "XAXIS")==0) || (stricmp(sprinfoToken, "ROLL")==0))
|
||||
frameRotAxis = ROTAXIS_X;
|
||||
else if ((stricmp(sprinfoToken, "Y")==0) || (stricmp(sprinfoToken, "YAXIS")==0) || (stricmp(sprinfoToken, "PITCH")==0))
|
||||
frameRotAxis = ROTAXIS_Y;
|
||||
else if ((stricmp(sprinfoToken, "Z")==0) || (stricmp(sprinfoToken, "ZAXIS")==0) || (stricmp(sprinfoToken, "YAW")==0))
|
||||
frameRotAxis = ROTAXIS_Z;
|
||||
}
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (sprinfoToken == NULL)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite info or right curly brace should be");
|
||||
}
|
||||
}
|
||||
}
|
||||
Z_Free(sprinfoToken);
|
||||
}
|
||||
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
// set fields
|
||||
info->pivot[frameFrame].x = frameXPivot;
|
||||
info->pivot[frameFrame].y = frameYPivot;
|
||||
@@ -138,7 +137,6 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite name should be");
|
||||
}
|
||||
|
||||
sprinfoTokenLength = strlen(sprinfoToken);
|
||||
if (sprinfoTokenLength != 4)
|
||||
{
|
||||
@@ -151,7 +149,6 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
// ^^ we've confirmed that the token is == 4 characters so it will never overflow a 5 byte char buffer
|
||||
strupr(newSpriteName); // Just do this now so we don't have to worry about it
|
||||
}
|
||||
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
if (!spr2)
|
||||
@@ -160,8 +157,7 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
{
|
||||
if (i == NUMSPRITES)
|
||||
I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName);
|
||||
|
||||
if (!memcmp(newSpriteName,sprnames[i], 4))
|
||||
if (!memcmp(newSpriteName,sprnames[i],4))
|
||||
{
|
||||
sprnum = static_cast<spritenum_t>(i);
|
||||
break;
|
||||
@@ -179,20 +175,17 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where open curly brace for sprite \"%s\" should be",newSpriteName);
|
||||
}
|
||||
|
||||
if (fastcmp(sprinfoToken, "{"))
|
||||
if (strcmp(sprinfoToken,"{")==0)
|
||||
{
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
if (sprinfoToken == NULL)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where definition for sprite \"%s\" should be",newSpriteName);
|
||||
}
|
||||
|
||||
while (!fastcmp(sprinfoToken, "}"))
|
||||
while (strcmp(sprinfoToken,"}")!=0)
|
||||
{
|
||||
if (fasticmp(sprinfoToken, "SKIN"))
|
||||
if (stricmp(sprinfoToken, "SKIN")==0)
|
||||
{
|
||||
INT32 skinnum;
|
||||
char *skinName = NULL;
|
||||
@@ -223,11 +216,10 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
skinnumbers[foundskins] = skinnum;
|
||||
foundskins++;
|
||||
}
|
||||
else if (fasticmp(sprinfoToken, "FRAME"))
|
||||
else if (stricmp(sprinfoToken, "FRAME")==0)
|
||||
{
|
||||
R_ParseSpriteInfoFrame(info);
|
||||
Z_Free(sprinfoToken);
|
||||
|
||||
if (spr2)
|
||||
{
|
||||
if (!foundskins)
|
||||
@@ -262,7 +254,6 @@ static void R_ParseSpriteInfo(boolean spr2)
|
||||
{
|
||||
I_Error("Error parsing SPRTINFO lump: Expected \"{\" for sprite \"%s\", got \"%s\"",newSpriteName,sprinfoToken);
|
||||
}
|
||||
|
||||
Z_Free(sprinfoToken);
|
||||
Z_Free(info);
|
||||
}
|
||||
@@ -300,18 +291,15 @@ void R_ParseSPRTINFOLump(UINT16 wadNum, UINT16 lumpNum)
|
||||
while (sprinfoToken != NULL)
|
||||
{
|
||||
CONS_Printf("Attempting to parse le SPRTINFO lump for ya..\n");
|
||||
|
||||
if (fasticmp(sprinfoToken, "SPRITE"))
|
||||
if (!stricmp(sprinfoToken, "SPRITE"))
|
||||
R_ParseSpriteInfo(false);
|
||||
else if (fasticmp(sprinfoToken, "SPRITE2"))
|
||||
else if (!stricmp(sprinfoToken, "SPRITE2"))
|
||||
R_ParseSpriteInfo(true);
|
||||
else
|
||||
I_Error("Error parsing SPRTINFO lump: Unknown keyword \"%s\"", sprinfoToken);
|
||||
|
||||
Z_Free(sprinfoToken);
|
||||
sprinfoToken = M_GetToken(NULL);
|
||||
}
|
||||
|
||||
Z_Free((void *)sprinfoText);
|
||||
}
|
||||
|
||||
|
||||
+134
-154
@@ -33,7 +33,7 @@
|
||||
|
||||
#include "qs22j.h"
|
||||
|
||||
CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2]; // huehuehuehuehue
|
||||
CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2];
|
||||
|
||||
#include "discord.h"
|
||||
|
||||
@@ -41,7 +41,6 @@ INT32 numskins = 0;
|
||||
INT32 numallskins = 0;
|
||||
INT32 numlocalskins = 0;
|
||||
skin_t skins[MAXSKINS];
|
||||
|
||||
UINT8 skinstats[9][9][MAXSKINS];
|
||||
UINT8 skinstatscount[9][9] = {
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
@@ -54,7 +53,6 @@ UINT8 skinstatscount[9][9] = {
|
||||
{0, 1, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0}
|
||||
};
|
||||
|
||||
UINT8 skinsorted[MAXSKINS];
|
||||
skin_t localskins[MAXLOCALSKINS];
|
||||
skin_t allskins[MAXSKINS+MAXLOCALSKINS];
|
||||
@@ -72,15 +70,14 @@ static void Sk_SetDefaultValue(skin_t *skin, boolean local)
|
||||
//
|
||||
// set default skin values
|
||||
//
|
||||
memset(skin, 0, sizeof(skin_t));
|
||||
|
||||
memset(skin, 0, sizeof (skin_t));
|
||||
snprintf(skin->name, sizeof skin->name, "skin %u", K_GetMobjSkinNum(skin, local));
|
||||
skin->name[sizeof skin->name - 1] = '\0';
|
||||
|
||||
skin->wadnum = INT16_MAX;
|
||||
|
||||
strcpy(skin->sprite, "");
|
||||
|
||||
skin->flags = 0;
|
||||
|
||||
strcpy(skin->realname, "Someone");
|
||||
strcpy(skin->hudname, "???");
|
||||
strncpy(skin->facerank, "PLAYRANK", 9);
|
||||
@@ -98,12 +95,8 @@ static void Sk_SetDefaultValue(skin_t *skin, boolean local)
|
||||
skin->highresscale = FRACUNIT>>1;
|
||||
|
||||
for (i = 0; i < sfx_skinsoundslot0; i++)
|
||||
{
|
||||
const INT32 skinsound = S_sfx[i].skinsound;
|
||||
|
||||
if (skinsound != -1)
|
||||
skin->soundsid[skinsound] = i;
|
||||
}
|
||||
if (S_sfx[i].skinsound != -1)
|
||||
skin->soundsid[S_sfx[i].skinsound] = i;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -131,7 +124,6 @@ void R_InitSkins(void)
|
||||
skin = &skins[0];
|
||||
numskins = 1;
|
||||
Sk_SetDefaultValue(skin, false);
|
||||
|
||||
memset(skinstats, 0, sizeof(skinstats));
|
||||
memset(skinsorted, 0, sizeof(skinsorted));
|
||||
|
||||
@@ -140,16 +132,13 @@ void R_InitSkins(void)
|
||||
#ifdef SKINVALUES
|
||||
skin_cons_t[0].strvalue = skins[0].name;
|
||||
#endif
|
||||
|
||||
skin->flags = 0;
|
||||
strcpy(skin->realname, "Sonic");
|
||||
strcpy(skin->hudname, "SONIC");
|
||||
|
||||
strncpy(skin->facerank, "PLAYRANK", 9);
|
||||
strncpy(skin->facewant, "PLAYWANT", 9);
|
||||
strncpy(skin->facemmap, "PLAYMMAP", 9);
|
||||
|
||||
skin->flags = 0;
|
||||
|
||||
skin->wadnum = 0; // god what have you brought to this world
|
||||
skin->prefcolor = SKINCOLOR_BLUE;
|
||||
skin->localskin = false;
|
||||
@@ -188,10 +177,9 @@ INT32 R_SkinAvailable(const char *name)
|
||||
|
||||
for (i = 0; i < numskins; i++)
|
||||
{
|
||||
if (fasticmp(skins[i].name, name))
|
||||
if (stricmp(skins[i].name,name) == 0)
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -203,10 +191,9 @@ INT32 R_AnySkinAvailable(const char *name)
|
||||
|
||||
for (i = 0; i < numallskins; i++)
|
||||
{
|
||||
if (fasticmp(allskins[i].name, name))
|
||||
if (stricmp(allskins[i].name,name) == 0)
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -218,32 +205,32 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local)
|
||||
{
|
||||
for (i = 0; i < numlocalskins; i++)
|
||||
{
|
||||
if (fasticmp(localskins[i].name, name))
|
||||
if (stricmp(localskins[i].name,name) == 0)
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return R_SkinAvailable(name);
|
||||
else
|
||||
return R_SkinAvailable(name);
|
||||
}
|
||||
|
||||
// network code calls this when a 'skin change' is received
|
||||
boolean SetPlayerSkin(INT32 playernum, const char *skinname)
|
||||
{
|
||||
INT32 i;
|
||||
player_t *player = &players[playernum];
|
||||
|
||||
for (i = 0; i < numskins; i++)
|
||||
{
|
||||
// search in the skin list
|
||||
if (fasticmp(skins[i].name, skinname))
|
||||
if (stricmp(skins[i].name, skinname) == 0)
|
||||
{
|
||||
SetPlayerSkinByNum(playernum, i);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (P_IsLocalPlayer(&players[playernum]))
|
||||
if (P_IsLocalPlayer(player))
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Skin '%s' not found.\n"), skinname);
|
||||
else if (server || IsPlayerAdmin(consoleplayer))
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Player %d (%s) skin '%s' not found\n"), playernum, player_names[playernum], skinname);
|
||||
@@ -257,16 +244,15 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
|
||||
INT32 i;
|
||||
player_t *player = &players[playernum];
|
||||
|
||||
if (!fasticmp(skinname, "none"))
|
||||
if (stricmp(skinname, "none"))
|
||||
{
|
||||
for (i = 0; i < numlocalskins; i++)
|
||||
{
|
||||
// search in the localskin list
|
||||
if (fasticmp(localskins[i].name, skinname))
|
||||
if (stricmp(localskins[i].name, skinname) == 0)
|
||||
{
|
||||
player->localskin = 1 + i;
|
||||
player->skinlocal = true;
|
||||
|
||||
if (player->mo)
|
||||
{
|
||||
player->mo->localskin = &localskins[i];
|
||||
@@ -280,11 +266,10 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
|
||||
for (i = 0; i < numskins; i++)
|
||||
{
|
||||
// search in the skin list
|
||||
if (fasticmp(skins[i].name, skinname))
|
||||
if (stricmp(skins[i].name, skinname) == 0)
|
||||
{
|
||||
player->localskin = 1 + i;
|
||||
player->skinlocal = false;
|
||||
|
||||
if (player->mo)
|
||||
{
|
||||
player->mo->localskin = &skins[i];
|
||||
@@ -299,7 +284,6 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
|
||||
{
|
||||
player->localskin = 0;
|
||||
player->skinlocal = false;
|
||||
|
||||
if (player->mo)
|
||||
{
|
||||
player->mo->localskin = 0;
|
||||
@@ -334,7 +318,6 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
|
||||
if (skinnum >= 0 && skinnum < numskins) // Make sure it exists!
|
||||
{
|
||||
player->skin = skinnum;
|
||||
|
||||
if (player->mo)
|
||||
player->mo->skin = skin;
|
||||
|
||||
@@ -377,97 +360,117 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
|
||||
static UINT16 W_CheckForSkinMarkerInPwad(UINT16 wadid, UINT16 startlump)
|
||||
{
|
||||
UINT16 i;
|
||||
const char *S_SKIN = "S_SKIN";
|
||||
lumpinfo_t *lump_p;
|
||||
|
||||
// scan forward, start at <startlump>
|
||||
if (startlump < wadfiles[wadid]->numlumps)
|
||||
{
|
||||
lump_p = wadfiles[wadid]->lumpinfo + startlump;
|
||||
|
||||
for (i = startlump; i < wadfiles[wadid]->numlumps; i++, lump_p++)
|
||||
{
|
||||
if (memcmp(lump_p->name, "S_SKIN", 6) == 0)
|
||||
if (memcmp(lump_p->name,S_SKIN,6)==0)
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return INT16_MAX; // not found
|
||||
}
|
||||
|
||||
//sort function for sorting skin names
|
||||
static int skinSortFunc(const void *a, const void *b) // tbh i have no clue what the naming conventions for local functions are
|
||||
static int skinSortFunc(const void *a, const void *b) //tbh i have no clue what the naming conventions for local functions are
|
||||
{
|
||||
int diff = 0;
|
||||
const UINT8 val_a = *(const UINT8 *)a;
|
||||
const UINT8 val_b = *(const UINT8 *)b;
|
||||
const skin_t *in1 = &skins[val_a];
|
||||
const skin_t *in2 = &skins[val_b];
|
||||
const skin_t *in1 = &skins[*(const UINT8 *)a];
|
||||
const skin_t *in2 = &skins[*(const UINT8 *)b];
|
||||
INT32 temp = 0;
|
||||
const UINT8 val_a = *((const UINT8 *)a);
|
||||
const UINT8 val_b = *((const UINT8 *)b);
|
||||
|
||||
// return (strcmp(in1->realname, in2->realname) < 0) || (strcmp(in1->realname, in2->realname) ==);
|
||||
//return (strcmp(in1->realname, in2->realname) < 0) || (strcmp(in1->realname, in2->realname) ==);
|
||||
|
||||
switch (cv_skinselectgridsort.value)
|
||||
{
|
||||
case SKINMENUSORT_REALNAME:
|
||||
// CONS_Printf("Sorting by realname\n");
|
||||
//CONS_Printf("Sorting by realname\n");
|
||||
// check name
|
||||
diff = strcmp(in1->realname, in2->realname);
|
||||
if (diff != 0) return diff;
|
||||
|
||||
if ((temp = strcmp(in1->realname, in2->realname)))
|
||||
return temp;
|
||||
// sort by internal name
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
case SKINMENUSORT_SPEED:
|
||||
// CONS_Printf("Sorting by speed\n");
|
||||
// check speed
|
||||
diff = in1->kartspeed - in2->kartspeed;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
// then check weight
|
||||
diff = in1->kartweight - in2->kartweight;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
// then check name
|
||||
diff = strcmp(in1->realname, in2->realname);
|
||||
if (diff != 0) return diff;
|
||||
|
||||
break;
|
||||
case SKINMENUSORT_WEIGHT:
|
||||
// CONS_Printf("Sorting by weight\n");
|
||||
// check weight
|
||||
diff = in1->kartweight - in2->kartweight;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
// then check speed
|
||||
diff = in1->kartspeed - in2->kartspeed;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
// then check name
|
||||
diff = strcmp(in1->realname, in2->realname);
|
||||
if (diff != 0) return diff;
|
||||
|
||||
break;
|
||||
case SKINMENUSORT_PREFCOLOR:
|
||||
// CONS_Printf("Sorting by prefcolor\n");
|
||||
// check prefcolor
|
||||
diff = in1->prefcolor - in2->prefcolor;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
// then check name
|
||||
diff = strcmp(in1->realname, in2->realname);
|
||||
if (diff != 0) return diff;
|
||||
|
||||
break;
|
||||
case SKINMENUSORT_ID:
|
||||
// CONS_Printf("Sorting by id\n");
|
||||
// how do i do by ID?????
|
||||
// wait why dont i just convert the inputs to UINT32s
|
||||
// please tell me im allowed to define variables in here since its a block
|
||||
return (int)val_a - (int)val_b;
|
||||
case SKINMENUSORT_NAME:
|
||||
//CONS_Printf("Sorting by name\n");
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
|
||||
case SKINMENUSORT_SPEED:
|
||||
//CONS_Printf("Sorting by speed\n");
|
||||
// check speed
|
||||
if (in1->kartspeed < in2->kartspeed)
|
||||
return -1;
|
||||
else if (in2->kartspeed < in1->kartspeed)
|
||||
return 1;
|
||||
// then check weight
|
||||
if (in1->kartweight < in2->kartweight)
|
||||
return -1;
|
||||
else if (in2->kartweight < in1->kartweight)
|
||||
return 1;
|
||||
// then check name
|
||||
if ((temp = strcmp(in1->realname, in2->realname)))
|
||||
return temp;
|
||||
// sort by internal name
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
|
||||
case SKINMENUSORT_WEIGHT:
|
||||
//CONS_Printf("Sorting by weight\n");
|
||||
// check weight
|
||||
if (in1->kartweight < in2->kartweight)
|
||||
return -1;
|
||||
else if (in2->kartweight < in1->kartweight)
|
||||
return 1;
|
||||
// then check speed
|
||||
if (in1->kartspeed < in2->kartspeed)
|
||||
return -1;
|
||||
else if (in2->kartspeed < in1->kartspeed)
|
||||
return 1;
|
||||
// then check name
|
||||
if ((temp = strcmp(in1->realname, in2->realname)))
|
||||
return temp;
|
||||
// sort by internal name
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
|
||||
case SKINMENUSORT_PREFCOLOR:
|
||||
//CONS_Printf("Sorting by prefcolor\n");
|
||||
// check prefcolor
|
||||
if (in1->prefcolor < in2->prefcolor)
|
||||
return -1;
|
||||
else if (in2->prefcolor < in1->prefcolor)
|
||||
return 1;
|
||||
// then check name
|
||||
if ((temp = strcmp(in1->realname, in2->realname)))
|
||||
return temp;
|
||||
// sort by internal name
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
|
||||
case SKINMENUSORT_ID:
|
||||
//CONS_Printf("Sorting by id\n");
|
||||
//how do i do by ID?????
|
||||
//wait why dont i just convert the inputs to UINT32s
|
||||
//please tell me im allowed to define variables in here since its a block
|
||||
|
||||
if (val_a == val_b)
|
||||
return 0;
|
||||
else if (val_a < val_b)
|
||||
return -1;
|
||||
else
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return strcmp(in1->name, in2->name);
|
||||
break;
|
||||
}
|
||||
|
||||
// im scared this somehow will sometimes end up here so im gonna add this here just to be safe
|
||||
// now it will often end up here >:3
|
||||
//im scared this somehow will sometimes end up here so im gonna add this here just to be safe
|
||||
return strcmp(in1->name, in2->name);
|
||||
}
|
||||
|
||||
@@ -528,9 +531,8 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
Sk_SetDefaultValue(skin, local);
|
||||
skin->wadnum = wadnum;
|
||||
hudname = realname = false;
|
||||
|
||||
// parse
|
||||
stoken = strtok(buf2, "\r\n= ");
|
||||
stoken = strtok (buf2, "\r\n= ");
|
||||
while (stoken)
|
||||
{
|
||||
if ((stoken[0] == '/' && stoken[1] == '/')
|
||||
@@ -546,7 +548,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
if (!value)
|
||||
I_Error("R_AddSkins: syntax error in S_SKIN lump# %d(%s) in WAD %s\n", lump, W_CheckNameForNumPwad(wadnum,lump), wadfiles[wadnum]->filename);
|
||||
|
||||
if (fasticmp(stoken, "name"))
|
||||
if (!stricmp(stoken, "name"))
|
||||
{
|
||||
// the skin name must uniquely identify a single skin
|
||||
// I'm lazy so if name is already used I leave the 'skin x'
|
||||
@@ -560,18 +562,18 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
// using the default skin name's number set above
|
||||
else
|
||||
{
|
||||
const size_t stringspace = strlen(value) + sizeof lnumskins + 1;
|
||||
const size_t stringspace =
|
||||
strlen(value) + sizeof lnumskins + 1;
|
||||
char *value2 = Z_Malloc(stringspace, PU_STATIC, NULL);
|
||||
|
||||
snprintf(value2, stringspace, "%s%d", value, lnumskins);
|
||||
snprintf(value2, stringspace,
|
||||
"%s%d", value, lnumskins);
|
||||
value2[stringspace - 1] = '\0';
|
||||
|
||||
if (R_LocalSkinAvailable(value2, local) == -1)
|
||||
{
|
||||
STRBUFCPY(skin->name, value2);
|
||||
STRBUFCPY(skin->name,
|
||||
value2);
|
||||
strlwr(skin->name);
|
||||
}
|
||||
|
||||
Z_Free(value2);
|
||||
}
|
||||
|
||||
@@ -587,134 +589,115 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
{
|
||||
STRBUFCPY(skin->hudname, skin->name);
|
||||
strupr(skin->hudname);
|
||||
|
||||
for (value = skin->hudname; *value; value++)
|
||||
if (*value == '_') *value = ' '; // turn _ into spaces.
|
||||
}
|
||||
}
|
||||
else if (fasticmp(stoken, "realname"))
|
||||
else if (!stricmp(stoken, "realname"))
|
||||
{ // Display name (eg. "Knuckles")
|
||||
realname = true;
|
||||
STRBUFCPY(skin->realname, value);
|
||||
|
||||
for (value = skin->realname; *value; value++)
|
||||
if (*value == '_') *value = ' '; // turn _ into spaces.
|
||||
|
||||
if (!hudname)
|
||||
STRBUFCPY(skin->hudname, skin->realname);
|
||||
}
|
||||
else if (fasticmp(stoken, "hudname"))
|
||||
else if (!stricmp(stoken, "hudname"))
|
||||
{ // Life icon name (eg. "K.T.E")
|
||||
hudname = true;
|
||||
STRBUFCPY(skin->hudname, value);
|
||||
|
||||
for (value = skin->hudname; *value; value++)
|
||||
if (*value == '_') *value = ' '; // turn _ into spaces.
|
||||
|
||||
if (!realname)
|
||||
STRBUFCPY(skin->realname, skin->hudname);
|
||||
}
|
||||
else if (fasticmp(stoken, "sprite"))
|
||||
|
||||
else if (!stricmp(stoken, "sprite"))
|
||||
{
|
||||
strupr(value);
|
||||
memcpy(skin->sprite, value, sizeof skin->sprite);
|
||||
}
|
||||
else if (fasticmp(stoken, "facerank"))
|
||||
else if (!stricmp(stoken, "facerank"))
|
||||
{
|
||||
strupr(value);
|
||||
memcpy(skin->facerank, value, sizeof(skin->facerank)-1);
|
||||
skin->facerank[sizeof(skin->facerank)-1] = '\0';
|
||||
}
|
||||
else if (fasticmp(stoken, "facewant"))
|
||||
else if (!stricmp(stoken, "facewant"))
|
||||
{
|
||||
strupr(value);
|
||||
memcpy(skin->facewant, value, sizeof(skin->facewant)-1);
|
||||
skin->facewant[sizeof(skin->facewant)-1] = '\0';
|
||||
}
|
||||
else if (fasticmp(stoken, "facemmap"))
|
||||
else if (!stricmp(stoken, "facemmap"))
|
||||
{
|
||||
strupr(value);
|
||||
strncpy(skin->facemmap, value, sizeof(skin->facemmap)-1);
|
||||
skin->facemmap[sizeof(skin->facemmap)-1] = '\0';
|
||||
}
|
||||
else if (fasticmp(stoken, "flags")) // character type identification
|
||||
else if (!stricmp(stoken, "flags")) // character type identification
|
||||
{
|
||||
skin->flags = get_number(value);
|
||||
}
|
||||
else if (fasticmp(stoken, "kartspeed"))
|
||||
else if (!stricmp(stoken, "kartspeed"))
|
||||
{
|
||||
skin->kartspeed = atoi(value);
|
||||
|
||||
if (skin->kartspeed < 1)
|
||||
skin->kartspeed = 1;
|
||||
if (skin->kartspeed > 9)
|
||||
skin->kartspeed = 9;
|
||||
}
|
||||
else if (fasticmp(stoken, "kartweight"))
|
||||
else if (!stricmp(stoken, "kartweight"))
|
||||
{
|
||||
skin->kartweight = atoi(value);
|
||||
|
||||
if (skin->kartweight < 1)
|
||||
skin->kartweight = 1;
|
||||
if (skin->kartweight > 9)
|
||||
skin->kartweight = 9;
|
||||
}
|
||||
// custom translation table
|
||||
else if (fasticmp(stoken, "startcolor"))
|
||||
{
|
||||
else if (!stricmp(stoken, "startcolor"))
|
||||
skin->starttranscolor = atoi(value);
|
||||
}
|
||||
else if (fasticmp(stoken, "prefcolor"))
|
||||
{
|
||||
else if (!stricmp(stoken, "prefcolor"))
|
||||
skin->prefcolor = K_GetKartColorByName(value);
|
||||
}
|
||||
else if (fasticmp(stoken, "highresscale"))
|
||||
{
|
||||
else if (!stricmp(stoken, "highresscale"))
|
||||
skin->highresscale = FLOAT_TO_FIXED(atof(value));
|
||||
}
|
||||
else
|
||||
{
|
||||
INT32 found = false;
|
||||
sfxenum_t i;
|
||||
|
||||
// copy name of sounds that are remapped
|
||||
// for this skin
|
||||
for (i = 0; i < sfx_skinsoundslot0; i++)
|
||||
{
|
||||
const sfxinfo_t *sfx = &S_sfx[i];
|
||||
|
||||
if (!sfx->name)
|
||||
if (!S_sfx[i].name)
|
||||
continue;
|
||||
|
||||
if (sfx->skinsound != -1
|
||||
&& fasticmp(sfx->name, stoken + 2))
|
||||
if (S_sfx[i].skinsound != -1
|
||||
&& !stricmp(S_sfx[i].name,
|
||||
stoken + 2))
|
||||
{
|
||||
skin->soundsid[sfx->skinsound] = S_AddSoundFx(value+2, sfx->singularity, sfx->pitch, true);
|
||||
skin->soundsid[S_sfx[i].skinsound] =
|
||||
S_AddSoundFx(value+2, S_sfx[i].singularity, S_sfx[i].pitch, true);
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
CONS_Debug(DBG_SETUP, "R_AddSkins: Unknown keyword '%s' in S_SKIN lump# %d (WAD %s)\n", stoken, lump, wadfiles[wadnum]->filename);
|
||||
}
|
||||
|
||||
stoken = strtok(NULL, "\r\n= ");
|
||||
}
|
||||
|
||||
free(buf2);
|
||||
|
||||
lump++; // if no sprite defined use spirte just after this one
|
||||
|
||||
if (skin->sprite[0] == '\0')
|
||||
{
|
||||
const char *csprname = W_CheckNameForNumPwad(wadnum, lump);
|
||||
|
||||
// skip to end of this skin's frames
|
||||
lastlump = lump;
|
||||
|
||||
while (W_CheckNameForNumPwad(wadnum, lastlump) && memcmp(W_CheckNameForNumPwad(wadnum, lastlump), csprname,4)==0)
|
||||
lastlump++;
|
||||
|
||||
// allocate (or replace) sprite frames, and set spritedef
|
||||
R_AddSingleSpriteDef(csprname, &skin->spritedef, wadnum, lump, lastlump);
|
||||
}
|
||||
@@ -724,15 +707,12 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
size_t name;
|
||||
boolean found = false;
|
||||
const char *sprname = skin->sprite;
|
||||
|
||||
for (name = 0; sprnames[name][0] != '\0'; name++)
|
||||
{
|
||||
for (name = 0;sprnames[name][0] != '\0';name++)
|
||||
if (strncmp(sprnames[name], sprname, 4) == 0)
|
||||
{
|
||||
skin->spritedef = sprites[name];
|
||||
found = true;
|
||||
skin->spritedef = sprites[name];
|
||||
}
|
||||
}
|
||||
|
||||
// not found so make a new one
|
||||
// go through the entire current wad looking for our sprite
|
||||
@@ -746,7 +726,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
while ((lname = W_CheckNameForNumPwad(wadnum, localllump)))
|
||||
{
|
||||
// If this is a valid sprite...
|
||||
if (!memcmp(lname, sprname, 4) && lname[4] && lname[5] && lname[5] >= '0' && lname[5] <= '8')
|
||||
if (!memcmp(lname, sprname,4) && lname[4] && lname[5] && lname[5] >= '0' && lname[5] <= '8')
|
||||
{
|
||||
if (lstart == UINT16_MAX)
|
||||
lstart = localllump;
|
||||
@@ -761,7 +741,6 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
}
|
||||
// If not already set do nothing
|
||||
}
|
||||
|
||||
++localllump;
|
||||
}
|
||||
|
||||
@@ -781,6 +760,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
(local ? localskin_cons_t : skin_cons_t)[lnumskins].value = lnumskins;
|
||||
(local ? localskin_cons_t : skin_cons_t)[lnumskins].strvalue = skin->name;
|
||||
#endif
|
||||
|
||||
if (!local)
|
||||
{
|
||||
// Update the forceskin possiblevalues
|
||||
|
||||
+18
-23
@@ -1095,12 +1095,9 @@ void S_StartSoundName(void *mo, const char *soundname)
|
||||
// Search existing sounds...
|
||||
for (i = sfx_None + 1; i < NUMSFX; i++)
|
||||
{
|
||||
const sfxinfo_t *sfx = &S_sfx[i];
|
||||
|
||||
if (!sfx->name)
|
||||
if (!S_sfx[i].name)
|
||||
continue;
|
||||
|
||||
if (fasticmp(sfx->name, soundname))
|
||||
if (!stricmp(S_sfx[i].name, soundname))
|
||||
{
|
||||
soundnum = i;
|
||||
break;
|
||||
@@ -1113,7 +1110,6 @@ void S_StartSoundName(void *mo, const char *soundname)
|
||||
{
|
||||
if (newsounds[i] == 0)
|
||||
break;
|
||||
|
||||
if (!S_IdPlaying(newsounds[i]))
|
||||
{
|
||||
S_RemoveSoundFx(newsounds[i]);
|
||||
@@ -1270,7 +1266,7 @@ ReadMusicDefFields (UINT16 wadnum, int line, char *stoken, musicdef_t **defp)
|
||||
char *value;
|
||||
char *textline;
|
||||
|
||||
if (fasticmp(stoken, "lump"))
|
||||
if (!stricmp(stoken, "lump"))
|
||||
{
|
||||
value = strtok(NULL, " ");
|
||||
|
||||
@@ -1345,24 +1341,24 @@ skip_lump:
|
||||
for (textline = def->field; *textline; textline++)\
|
||||
if (*textline == '_') *textline = ' ';
|
||||
|
||||
if (fasticmp(stoken, "usage"))
|
||||
if (!stricmp(stoken, "usage"))
|
||||
{
|
||||
ADDDEF(usage);
|
||||
}
|
||||
else if (fasticmp(stoken, "source"))
|
||||
else if (!stricmp(stoken, "source"))
|
||||
{
|
||||
ADDDEF(source);
|
||||
}
|
||||
else if (fasticmp(stoken, "title"))
|
||||
else if (!stricmp(stoken, "title"))
|
||||
{
|
||||
def->use_info = true;
|
||||
ADDDEF(title);
|
||||
}
|
||||
else if (fasticmp(stoken, "alttitle"))
|
||||
else if (!stricmp(stoken, "alttitle"))
|
||||
{
|
||||
ADDDEF(alttitle);
|
||||
}
|
||||
else if (fasticmp(stoken, "authors"))
|
||||
else if (!stricmp(stoken, "authors"))
|
||||
{
|
||||
ADDDEF(authors);
|
||||
}
|
||||
@@ -1483,8 +1479,7 @@ musicdef_t *S_FindMusicCredit(const char *musname)
|
||||
|
||||
if (hash != def->hash)
|
||||
continue;
|
||||
|
||||
if (!fasticmp(def->name, musname))
|
||||
if (stricmp(def->name, musname))
|
||||
continue;
|
||||
|
||||
return def;
|
||||
@@ -1833,7 +1828,7 @@ void S_StopMusic(void)
|
||||
|| demo.title) // SRB2Kart: Demos don't interrupt title screen music
|
||||
return;
|
||||
|
||||
mapmusic.resume = (cv_birdmusic.value && fasticmp(music.name, mapmusic.name)) ? I_GetSongPosition() : 0;
|
||||
mapmusic.resume = (cv_birdmusic.value && (strcasecmp(music.name, mapmusic.name) == 0)) ? I_GetSongPosition() : 0;
|
||||
|
||||
S_SetKeepMusResume();
|
||||
|
||||
@@ -1939,7 +1934,7 @@ static const char *musicexception_list[] = {
|
||||
// check if the current music is smth we dont want to keep (vote music, etc)
|
||||
static boolean S_CheckMusicException(void)
|
||||
{
|
||||
if (!fasticmp(music.name, mapmusic.name))
|
||||
if (stricmp(music.name, mapmusic.name))
|
||||
return true;
|
||||
|
||||
// dumb hack but dont keepmusic music that is supposed to reset
|
||||
@@ -1949,7 +1944,7 @@ static boolean S_CheckMusicException(void)
|
||||
// in case somehow the mapmusic was replaced with smth we dont want to keep
|
||||
for (size_t i = 0; i < sizeof(musicexception_list)/sizeof(musicexception_list[0]); i++)
|
||||
{
|
||||
if (fasticmp(music.name, musicexception_list[i]) || fasticmp(checkmusic, musicexception_list[i]))
|
||||
if (!stricmp(music.name, musicexception_list[i]) || !stricmp(checkmusic, musicexception_list[i]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
@@ -1969,7 +1964,7 @@ static void S_SetKeepMusResume(void)
|
||||
{
|
||||
keepmusic.resume = 0;
|
||||
|
||||
if (fasticmp(music.name, mapmusic.name))
|
||||
if (strcasecmp(music.name, mapmusic.name) == 0)
|
||||
{
|
||||
keepmusic.resume = I_GetSongPosition();
|
||||
}
|
||||
@@ -2035,12 +2030,12 @@ static boolean S_SkipIntroMusic(void)
|
||||
return false;
|
||||
|
||||
// check if menu music is playing, otherwise it may continue playing
|
||||
if (fasticmp(music.name, "titles"))
|
||||
if (!stricmp(music.name, "titles"))
|
||||
return false;
|
||||
|
||||
char *maptitle = G_BuildMapTitle(gamemap); // Zzz...
|
||||
|
||||
if (maptitle && fasticmp(maptitle, "Wandering Falls")) // wandering balls changes its song when the race starts Zzz...
|
||||
if (maptitle && !stricmp(maptitle, "Wandering Falls")) // wandering balls changes its song when the race starts Zzz...
|
||||
{
|
||||
Z_Free(maptitle);
|
||||
return false;
|
||||
@@ -2153,19 +2148,19 @@ static void Command_Tunes_f(void)
|
||||
tunenum = (UINT16)atoi(tunearg);
|
||||
track = 0;
|
||||
|
||||
if (fasticmp(tunearg, "-show"))
|
||||
if (!strcasecmp(tunearg, "-show"))
|
||||
{
|
||||
CONS_Printf(M_GetText("The current tune is: %s [track %d]\n"),
|
||||
mapmusic.name, (mapmusic.flags & MUSIC_TRACKMASK));
|
||||
return;
|
||||
}
|
||||
|
||||
if (fasticmp(tunearg, "-none"))
|
||||
if (!strcasecmp(tunearg, "-none"))
|
||||
{
|
||||
S_StopMusic();
|
||||
return;
|
||||
}
|
||||
else if (fasticmp(tunearg, "-default"))
|
||||
else if (!strcasecmp(tunearg, "-default"))
|
||||
{
|
||||
tunearg = mapheaderinfo[gamemap-1]->musname;
|
||||
track = mapheaderinfo[gamemap-1]->mustrack;
|
||||
|
||||
@@ -35,6 +35,9 @@
|
||||
|
||||
#define _CREATE_DLL_ // necessary for Unix AND Windows
|
||||
|
||||
#define GETFUNC(func) \
|
||||
else if (0 == strcmp(#func, funcName)) \
|
||||
funcPointer = &func \
|
||||
//
|
||||
//
|
||||
/** \brief The *hwSym function
|
||||
|
||||
+2
-10
@@ -545,7 +545,7 @@ static inline void I_ShutdownConsole(void){}
|
||||
|
||||
|
||||
//
|
||||
// I_OutputMsg
|
||||
//I_OutputMsg
|
||||
//
|
||||
void I_OutputMsg(const char *fmt, ...)
|
||||
{
|
||||
@@ -553,9 +553,6 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
char *txt;
|
||||
va_list argptr;
|
||||
|
||||
if (!fmt)
|
||||
return;
|
||||
|
||||
va_start(argptr,fmt);
|
||||
len = vsnprintf(NULL, 0, fmt, argptr);
|
||||
va_end(argptr);
|
||||
@@ -563,10 +560,6 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
return;
|
||||
|
||||
txt = static_cast<char*>(malloc(len+1));
|
||||
|
||||
if (!txt)
|
||||
I_Error("I_OutputMsg: Out of memory!\n");
|
||||
|
||||
va_start(argptr,fmt);
|
||||
vsprintf(txt, fmt, argptr);
|
||||
va_end(argptr);
|
||||
@@ -2288,9 +2281,8 @@ char *I_GetUserName(void)
|
||||
}
|
||||
|
||||
|
||||
if (!fastcmp(username, ""))
|
||||
if (strcmp(username, "") != 0)
|
||||
return username;
|
||||
|
||||
return NULL; // dummy for platform independent version
|
||||
}
|
||||
|
||||
|
||||
+13
-24
@@ -156,9 +156,9 @@ static SDL_bool usesdl2soft = SDL_FALSE;
|
||||
static SDL_bool borderlesswindow = SDL_FALSE;
|
||||
|
||||
// SDL2 vars
|
||||
SDL_Window *window = NULL;
|
||||
SDL_Renderer *renderer = NULL;
|
||||
static SDL_Texture *texture = NULL;
|
||||
SDL_Window *window;
|
||||
SDL_Renderer *renderer;
|
||||
static SDL_Texture *texture;
|
||||
static SDL_bool havefocus = SDL_TRUE;
|
||||
static const char *fallback_resolution_name = "Fallback";
|
||||
|
||||
@@ -412,10 +412,6 @@ static INT32 GetTypedChar(SDL_Keysym keysym)
|
||||
break;
|
||||
}
|
||||
|
||||
// Special case for console key
|
||||
if (scancode == SDL_SCANCODE_GRAVE)
|
||||
return '`';
|
||||
|
||||
if (SDL_PeepEvents(&next_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 1 && next_event.type == SDL_TEXTINPUT)
|
||||
{
|
||||
if (next_event.text.text[1] == '\0') // limit to ASCII
|
||||
@@ -905,11 +901,10 @@ static void Impl_HandleControllerAddedEvent(SDL_Event evt)
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (fastcmp(cv_usejoystick[i].string, "0") || !cv_usejoystick[i].value)
|
||||
if (!strcmp(cv_usejoystick[i].string, "0") || !cv_usejoystick[i].value)
|
||||
cv_usejoystick[i].value = 0;
|
||||
else if (atoi(cv_usejoystick[i].string) <= I_NumJoys() // don't mess if we intentionally set higher than NumJoys
|
||||
&& cv_usejoystick[i].value) // update the cvar ONLY if a device exists
|
||||
|
||||
CV_SetValue(&cv_usejoystick[i], cv_usejoystick[i].value);
|
||||
}
|
||||
|
||||
@@ -977,7 +972,7 @@ static void Impl_HandleControllerRemovedEvent(void)
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (fastcmp(cv_usejoystick[i].string, "0"))
|
||||
if (!strcmp(cv_usejoystick[i].string, "0"))
|
||||
{
|
||||
cv_usejoystick[i].value = 0;
|
||||
}
|
||||
@@ -1112,11 +1107,9 @@ void I_OsPolling(void)
|
||||
I_GetEvent();
|
||||
|
||||
mod = SDL_GetModState();
|
||||
|
||||
/* Handle here so that our state is always synched with the system. */
|
||||
shiftdown = ctrldown = altdown = 0;
|
||||
capslock = false;
|
||||
|
||||
if (mod & KMOD_LSHIFT) shiftdown |= 1;
|
||||
if (mod & KMOD_RSHIFT) shiftdown |= 2;
|
||||
if (mod & KMOD_LCTRL) ctrldown |= 1;
|
||||
@@ -1150,7 +1143,7 @@ static void VID_Command_Mode_f (void)
|
||||
{
|
||||
INT32 modenum;
|
||||
|
||||
if (COM_Argc() != 2)
|
||||
if (COM_Argc()!= 2)
|
||||
{
|
||||
CONS_Printf("vid_mode <modenum> : set video mode, current video mode %i\n", vid.modenum);
|
||||
return;
|
||||
@@ -1295,8 +1288,8 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
|
||||
#endif
|
||||
OglSdlSurface(vid.width, vid.height);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
SDL_RenderClear(renderer);
|
||||
@@ -1361,8 +1354,7 @@ void I_FinishUpdate(void)
|
||||
|
||||
const boolean isserverplayer = consoleplayer == serverplayer;
|
||||
|
||||
if (cv_showping.value && ((netgame && !isserverplayer) ||
|
||||
(simulated_lag != 0 && isserverplayer && Playing())))
|
||||
if (cv_showping.value && ((netgame && !isserverplayer) || (simulated_lag != 0 && isserverplayer && Playing())))
|
||||
SCR_DisplayLocalPing();
|
||||
}
|
||||
|
||||
@@ -1629,13 +1621,11 @@ static SDL_bool Impl_CreateContext(void)
|
||||
|
||||
if (!renderer)
|
||||
renderer = SDL_CreateRenderer(window, -1, flags);
|
||||
|
||||
if (renderer == NULL)
|
||||
{
|
||||
CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
|
||||
}
|
||||
|
||||
@@ -1738,7 +1728,6 @@ void I_StartupGraphics(void)
|
||||
#endif
|
||||
{
|
||||
const char *vd = SDL_GetCurrentVideoDriver();
|
||||
|
||||
//CONS_Printf(M_GetText("Starting up with video driver: %s\n"), vd);
|
||||
if (vd && (strncasecmp(vd, "fbcon", 6) == 0))
|
||||
framebuffer = SDL_TRUE;
|
||||
@@ -1785,11 +1774,11 @@ void I_StartupGraphics(void)
|
||||
|
||||
if (rendermode == render_none)
|
||||
{
|
||||
if (fasticmp(word, "software"))
|
||||
if (strcasecmp(word, "software") == 0)
|
||||
{
|
||||
rendermode = render_soft;
|
||||
}
|
||||
else if (fasticmp(word, "opengl"))
|
||||
else if (strcasecmp(word, "opengl") == 0)
|
||||
{
|
||||
rendermode = render_opengl;
|
||||
}
|
||||
@@ -1802,7 +1791,7 @@ void I_StartupGraphics(void)
|
||||
|
||||
if (!msaa_set)
|
||||
{
|
||||
if (fasticmp(word, "msaa"))
|
||||
if (strcasecmp(word, "msaa") == 0)
|
||||
{
|
||||
const char *nextword = strtok(NULL, " \n");
|
||||
|
||||
@@ -1819,7 +1808,7 @@ void I_StartupGraphics(void)
|
||||
|
||||
if (!a2c_set)
|
||||
{
|
||||
if (fasticmp(word, "a2c"))
|
||||
if (strcasecmp(word, "a2c") == 0)
|
||||
{
|
||||
a2c = true;
|
||||
CONS_Printf("Using a2c because it was specified to be used earlier\n");
|
||||
@@ -1969,7 +1958,7 @@ static void Impl_SetVsync(void)
|
||||
#endif
|
||||
#ifdef HWRENDER
|
||||
if (!renderer && rendermode == render_opengl &&
|
||||
sdlglcontext != NULL && SDL_GL_GetCurrentContext() == sdlglcontext)
|
||||
sdlglcontext != NULL && SDL_GL_GetCurrentContext() == sdlglcontext)
|
||||
{
|
||||
SDL_GL_SetSwapInterval(cv_vidwait.value ? 1 : 0);
|
||||
}
|
||||
|
||||
+122
-234
@@ -123,12 +123,13 @@ static int result;
|
||||
static void var_cleanup(void)
|
||||
{
|
||||
song_length = loop_point = 0.0f;
|
||||
music_bytes = fading_source = fading_target =
|
||||
fading_timer = fading_duration = 0;
|
||||
music_bytes = fading_source = fading_target =\
|
||||
fading_timer = fading_duration = 0;
|
||||
music_end_bytes = 0;
|
||||
music_stutter_bytes = 0;
|
||||
|
||||
songpaused = is_looping = is_fading = false;
|
||||
songpaused = is_looping =\
|
||||
is_fading = false;
|
||||
|
||||
fading_callback = NULL;
|
||||
fading_do_callback = false;
|
||||
@@ -228,7 +229,6 @@ void I_ShutdownSound(void)
|
||||
{
|
||||
if (!sound_started)
|
||||
return; // not an error condition
|
||||
|
||||
sound_started = false;
|
||||
|
||||
Mix_CloseAudio();
|
||||
@@ -254,7 +254,6 @@ void I_UpdateSound(void)
|
||||
{
|
||||
if (fading_callback)
|
||||
(*fading_callback)();
|
||||
|
||||
fading_callback = NULL;
|
||||
fading_do_callback = false;
|
||||
}
|
||||
@@ -281,7 +280,6 @@ static Mix_Chunk *ds2chunk(void *stream)
|
||||
ver = READUINT16(stream); // sound version format?
|
||||
if (ver != 3) // It should be 3 if it's a doomsound...
|
||||
return NULL; // onos! it's not a doomsound!
|
||||
|
||||
freq = READUINT16(stream);
|
||||
samples = READUINT32(stream);
|
||||
|
||||
@@ -289,100 +287,91 @@ static Mix_Chunk *ds2chunk(void *stream)
|
||||
return NULL; // division by zero
|
||||
|
||||
// convert from signed 8bit ???hz to signed 16bit 44100hz.
|
||||
switch (freq)
|
||||
switch(freq)
|
||||
{
|
||||
case 44100:
|
||||
if (samples >= UINT32_MAX>>2)
|
||||
return NULL; // would wrap, can't store.
|
||||
|
||||
newsamples = samples;
|
||||
break;
|
||||
case 22050:
|
||||
if (samples >= UINT32_MAX>>3)
|
||||
return NULL; // would wrap, can't store.
|
||||
|
||||
newsamples = samples<<1;
|
||||
break;
|
||||
case 11025:
|
||||
if (samples >= UINT32_MAX>>4)
|
||||
return NULL; // would wrap, can't store.
|
||||
|
||||
newsamples = samples<<2;
|
||||
break;
|
||||
default:
|
||||
frac = (44100 << FRACBITS) / (UINT32)freq;
|
||||
|
||||
if (!(frac & 0xFFFF)) // other solid multiples (change if FRACBITS != 16)
|
||||
newsamples = samples * (frac >> FRACBITS);
|
||||
else // strange and unusual fractional frequency steps, plus anything higher than 44100hz.
|
||||
newsamples = FixedMul(FixedDiv(samples, freq), 44100) + 1; // add 1 to counter truncation.
|
||||
|
||||
if (newsamples >= UINT32_MAX>>2)
|
||||
return NULL; // would and/or did wrap, can't store.
|
||||
|
||||
break;
|
||||
case 44100:
|
||||
if (samples >= UINT32_MAX>>2)
|
||||
return NULL; // would wrap, can't store.
|
||||
newsamples = samples;
|
||||
break;
|
||||
case 22050:
|
||||
if (samples >= UINT32_MAX>>3)
|
||||
return NULL; // would wrap, can't store.
|
||||
newsamples = samples<<1;
|
||||
break;
|
||||
case 11025:
|
||||
if (samples >= UINT32_MAX>>4)
|
||||
return NULL; // would wrap, can't store.
|
||||
newsamples = samples<<2;
|
||||
break;
|
||||
default:
|
||||
frac = (44100 << FRACBITS) / (UINT32)freq;
|
||||
if (!(frac & 0xFFFF)) // other solid multiples (change if FRACBITS != 16)
|
||||
newsamples = samples * (frac >> FRACBITS);
|
||||
else // strange and unusual fractional frequency steps, plus anything higher than 44100hz.
|
||||
newsamples = FixedMul(FixedDiv(samples, freq), 44100) + 1; // add 1 to counter truncation.
|
||||
if (newsamples >= UINT32_MAX>>2)
|
||||
return NULL; // would and/or did wrap, can't store.
|
||||
break;
|
||||
}
|
||||
|
||||
sound = Z_Malloc(newsamples<<2, PU_SOUND, NULL); // samples * frequency shift * bytes per sample * channels
|
||||
|
||||
s = (SINT8 *)stream;
|
||||
d = (INT16 *)sound;
|
||||
|
||||
i = 0;
|
||||
|
||||
switch(freq)
|
||||
{
|
||||
case 44100: // already at the same rate? well that makes it simple.
|
||||
while(i++ < samples)
|
||||
case 44100: // already at the same rate? well that makes it simple.
|
||||
while(i++ < samples)
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
}
|
||||
break;
|
||||
case 22050: // unwrap 2x
|
||||
while(i++ < samples)
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
}
|
||||
break;
|
||||
case 11025: // unwrap 4x
|
||||
while(i++ < samples)
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
}
|
||||
break;
|
||||
default: // convert arbitrary hz to 44100.
|
||||
step = 0;
|
||||
frac = ((UINT32)freq << FRACBITS) / 44100 + 1; //Add 1 to counter truncation.
|
||||
while (i < samples)
|
||||
{
|
||||
o = (INT16)(*s+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
while (step < FRACUNIT) // this is as fast as I can make it.
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
step += frac;
|
||||
}
|
||||
break;
|
||||
case 22050: // unwrap 2x
|
||||
while(i++ < samples)
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
}
|
||||
break;
|
||||
case 11025: // unwrap 4x
|
||||
while(i++ < samples)
|
||||
{
|
||||
o = ((INT16)(*s++)+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
}
|
||||
break;
|
||||
default: // convert arbitrary hz to 44100.
|
||||
step = 0;
|
||||
frac = ((UINT32)freq << FRACBITS) / 44100 + 1; //Add 1 to counter truncation.
|
||||
|
||||
while (i < samples)
|
||||
{
|
||||
o = (INT16)(*s+0x80)<<8; // changed signedness and shift up to 16 bits
|
||||
while (step < FRACUNIT) // this is as fast as I can make it.
|
||||
{
|
||||
*d++ = o; // left channel
|
||||
*d++ = o; // right channel
|
||||
step += frac;
|
||||
}
|
||||
do {
|
||||
i++; s++;
|
||||
step -= FRACUNIT;
|
||||
} while (step >= FRACUNIT);
|
||||
}
|
||||
break;
|
||||
do {
|
||||
i++; s++;
|
||||
step -= FRACUNIT;
|
||||
} while (step >= FRACUNIT);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// return Mixer Chunk.
|
||||
@@ -401,14 +390,12 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
|
||||
if (sfx->lumpnum == LUMPERROR)
|
||||
sfx->lumpnum = S_GetSfxLumpNum(sfx);
|
||||
|
||||
sfx->length = W_LumpLength(sfx->lumpnum);
|
||||
|
||||
lump = W_CacheLumpNum(sfx->lumpnum, PU_SOUND);
|
||||
|
||||
// convert from standard DoomSound format.
|
||||
chunk = ds2chunk(lump);
|
||||
|
||||
if (chunk)
|
||||
{
|
||||
Z_Free(lump);
|
||||
@@ -428,7 +415,6 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
int zErr; // Somewhere to handle any error messages zlib tosses out
|
||||
|
||||
memset(&stream, 0x00, sizeof (z_stream)); // Init zlib stream
|
||||
|
||||
// Begin the inflation process
|
||||
inflatedLen = *(UINT32 *)lump + (sfx->length-4); // Last 4 bytes are the decompressed size, typically
|
||||
inflatedData = (UINT8 *)Z_Malloc(inflatedLen, PU_SOUND, NULL); // Make room for the decompressed data
|
||||
@@ -438,13 +424,10 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
stream.next_out = inflatedData;
|
||||
|
||||
zErr = inflateInit2(&stream, 32 + MAX_WBITS);
|
||||
|
||||
if (zErr == Z_OK) // We're good to go
|
||||
{
|
||||
zErr = inflate(&stream, Z_FINISH);
|
||||
|
||||
if (zErr == Z_STREAM_END)
|
||||
{
|
||||
if (zErr == Z_STREAM_END) {
|
||||
// Run GME on new data
|
||||
if (!gme_open_data(inflatedData, inflatedLen, &emu, SAMPLERATE))
|
||||
{
|
||||
@@ -461,7 +444,6 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
|
||||
len = (info->play_length * 441 / 10) << 2;
|
||||
mem = Z_Malloc(len, PU_SOUND, 0);
|
||||
|
||||
gme_play(emu, len >> 1, mem);
|
||||
gme_free_info(info);
|
||||
gme_delete(emu);
|
||||
@@ -471,14 +453,10 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
}
|
||||
else
|
||||
CONS_Alert(CONS_ERROR,"Encountered %s when running inflate: %s\n", get_zlib_error(zErr), stream.msg);
|
||||
|
||||
(void)inflateEnd(&stream);
|
||||
}
|
||||
else // Hold up, zlib's got a problem
|
||||
{
|
||||
CONS_Alert(CONS_ERROR,"Encountered %s when running inflateInit: %s\n", get_zlib_error(zErr), stream.msg);
|
||||
}
|
||||
|
||||
Z_Free(inflatedData); // GME didn't open jack, but don't let that stop us from freeing this up
|
||||
#else
|
||||
return NULL; // No zlib support
|
||||
@@ -499,7 +477,6 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
|
||||
len = (info->play_length * 441 / 10) << 2;
|
||||
mem = Z_Malloc(len, PU_SOUND, 0);
|
||||
|
||||
gme_play(emu, len >> 1, mem);
|
||||
gme_free_info(info);
|
||||
gme_delete(emu);
|
||||
@@ -510,7 +487,6 @@ void *I_GetSfx(sfxinfo_t *sfx)
|
||||
|
||||
// Try to load it as a WAVE or OGG using Mixer.
|
||||
rw = SDL_RWFromMem(lump, sfx->length);
|
||||
|
||||
if (rw != NULL)
|
||||
{
|
||||
chunk = Mix_LoadWAV_RW(rw, 1);
|
||||
@@ -526,23 +502,19 @@ void I_FreeSfx(sfxinfo_t *sfx)
|
||||
{
|
||||
Mix_Chunk *chunk = (Mix_Chunk*)sfx->data;
|
||||
UINT8 *abufdata = NULL;
|
||||
|
||||
if (chunk->allocated == 0)
|
||||
{
|
||||
// We allocated the data in this chunk, so get the abuf from mixer, then let it free the chunk, THEN we free the data
|
||||
// I believe this should ensure the sound is not playing when we free it
|
||||
abufdata = chunk->abuf;
|
||||
}
|
||||
|
||||
Mix_FreeChunk(sfx->data);
|
||||
|
||||
if (abufdata)
|
||||
{
|
||||
// I'm going to assume we used Z_Malloc to allocate this data.
|
||||
Z_Free(abufdata);
|
||||
}
|
||||
}
|
||||
|
||||
sfx->data = NULL;
|
||||
sfx->lumpnum = LUMPERROR;
|
||||
}
|
||||
@@ -600,12 +572,9 @@ static UINT32 get_adjusted_position(UINT32 position)
|
||||
{
|
||||
// all in milliseconds
|
||||
UINT32 length = I_GetSongLength();
|
||||
|
||||
UINT32 looppoint = I_GetSongLoopPoint();
|
||||
if (length)
|
||||
{
|
||||
UINT32 looppoint = I_GetSongLoopPoint();
|
||||
return position >= length ? (position % (length-looppoint)) : position;
|
||||
}
|
||||
else
|
||||
return position;
|
||||
}
|
||||
@@ -620,7 +589,8 @@ static void do_fading_callback(void)
|
||||
/// Music Hooks
|
||||
/// ------------------------
|
||||
|
||||
static void Countstutter(int len)
|
||||
static void
|
||||
Countstutter (int len)
|
||||
{
|
||||
UINT32 bytes;
|
||||
|
||||
@@ -647,7 +617,7 @@ static void Countstutter(int len)
|
||||
else
|
||||
bytes = ( music_bytes - music_stutter_bytes );
|
||||
|
||||
I_SetSongPosition((int)((float)bytes/4/44100.0f*1000));
|
||||
I_SetSongPosition((int)( (float)bytes/4/44100.0f*1000 ));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -658,9 +628,7 @@ static void count_music_bytes(int chan, void *stream, int len, void *udata)
|
||||
(void)stream;
|
||||
(void)udata;
|
||||
|
||||
const musictype_t mustype = I_SongType();
|
||||
|
||||
if (!music || mustype == MU_GME || mustype == MU_MOD || mustype == MU_MID)
|
||||
if (!music || I_SongType() == MU_GME || I_SongType() == MU_MOD || I_SongType() == MU_MID)
|
||||
return;
|
||||
|
||||
music_bytes += len;
|
||||
@@ -694,9 +662,7 @@ static UINT32 music_fade(UINT32 interval, void *param)
|
||||
return 0;
|
||||
}
|
||||
else if (songpaused) // don't decrement timer
|
||||
{
|
||||
return interval;
|
||||
}
|
||||
else if ((fading_timer -= 10) <= 0)
|
||||
{
|
||||
internal_volume = fading_target;
|
||||
@@ -709,14 +675,11 @@ static UINT32 music_fade(UINT32 interval, void *param)
|
||||
{
|
||||
UINT8 delta = abs(fading_target - fading_source);
|
||||
fixed_t factor = FixedDiv(fading_duration - fading_timer, fading_duration);
|
||||
|
||||
if (fading_target < fading_source)
|
||||
internal_volume = max(min(internal_volume, fading_source - FixedMul(delta, factor)), fading_target);
|
||||
else if (fading_target > fading_source)
|
||||
internal_volume = min(max(internal_volume, fading_source + FixedMul(delta, factor)), fading_target);
|
||||
|
||||
Mix_VolumeMusic(get_real_volume(music_volume));
|
||||
|
||||
return interval;
|
||||
}
|
||||
}
|
||||
@@ -800,22 +763,14 @@ musictype_t I_SongType(void)
|
||||
#endif
|
||||
if (!music)
|
||||
return MU_NONE;
|
||||
|
||||
const Mix_MusicType mustype = Mix_GetMusicType(music);
|
||||
|
||||
switch (mustype)
|
||||
{
|
||||
case MUS_MID:
|
||||
return MU_MID;
|
||||
case MUS_MOD:
|
||||
case MUS_MODPLUG:
|
||||
return MU_MOD;
|
||||
case MUS_MP3:
|
||||
case MUS_MP3_MAD:
|
||||
return MU_MP3;
|
||||
default:
|
||||
return (musictype_t)mustype;
|
||||
}
|
||||
else if (Mix_GetMusicType(music) == MUS_MID)
|
||||
return MU_MID;
|
||||
else if (Mix_GetMusicType(music) == MUS_MOD || Mix_GetMusicType(music) == MUS_MODPLUG)
|
||||
return MU_MOD;
|
||||
else if (Mix_GetMusicType(music) == MUS_MP3 || Mix_GetMusicType(music) == MUS_MP3_MAD)
|
||||
return MU_MP3;
|
||||
else
|
||||
return (musictype_t)Mix_GetMusicType(music);
|
||||
}
|
||||
|
||||
boolean I_SongPlaying(void)
|
||||
@@ -844,7 +799,6 @@ boolean I_SetSongSpeed(float speed)
|
||||
{
|
||||
if (speed > 250.0f)
|
||||
speed = 250.0f; //limit speed up to 250x
|
||||
|
||||
#ifdef HAVE_LIBGME
|
||||
if (gme)
|
||||
{
|
||||
@@ -903,63 +857,51 @@ UINT32 I_GetSongLength(void)
|
||||
// reconstruct info->play_length, from GME source
|
||||
// we only want intro + 1 loop, not 2
|
||||
length = info->length;
|
||||
|
||||
if (length <= 0)
|
||||
{
|
||||
length = info->intro_length + info->loop_length; // intro + 1 loop
|
||||
|
||||
if (length <= 0)
|
||||
length = 150 * 1000; // 2.5 minutes
|
||||
}
|
||||
}
|
||||
|
||||
gme_free_info(info);
|
||||
|
||||
return max(length, 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#ifdef HAVE_OPENMPT
|
||||
if (openmpt_mhandle)
|
||||
{
|
||||
return (UINT32)(openmpt_module_get_duration_seconds(openmpt_mhandle) * 1000.);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (!music || I_SongType() == MU_MOD || I_SongType() == MU_MID)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// VERY IMPORTANT to set your LENGTHMS= in your song files, folks!
|
||||
// SDL mixer can't read music length itself.
|
||||
length = (UINT32)(song_length*1000);
|
||||
|
||||
if (!length)
|
||||
CONS_Debug(DBG_DETAILED, "Getting music length: music is missing LENGTHMS= tag. Needed for seeking.\n");
|
||||
|
||||
return length;
|
||||
}
|
||||
}
|
||||
|
||||
boolean I_SetSongLoopPoint(UINT32 looppoint)
|
||||
{
|
||||
if (!music|| !is_looping)
|
||||
if (!music || I_SongType() == MU_GME || I_SongType() == MU_MOD || I_SongType() == MU_MID || !is_looping)
|
||||
return false;
|
||||
else
|
||||
{
|
||||
UINT32 length = I_GetSongLength();
|
||||
|
||||
const musictype_t mustype = I_SongType();
|
||||
if (length > 0)
|
||||
looppoint %= length;
|
||||
|
||||
if (mustype == MU_GME || mustype == MU_MOD || mustype == MU_MID)
|
||||
return false;
|
||||
|
||||
UINT32 length = I_GetSongLength();
|
||||
|
||||
if (length > 0)
|
||||
looppoint %= length;
|
||||
|
||||
loop_point = max((float)(looppoint / 1000.0L), 0);
|
||||
return true;
|
||||
loop_point = max((float)(looppoint / 1000.0L), 0);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
UINT32 I_GetSongLoopPoint(void)
|
||||
@@ -985,19 +927,14 @@ UINT32 I_GetSongLoopPoint(void)
|
||||
else
|
||||
#endif
|
||||
if (!music || I_SongType() == MU_MOD || I_SongType() == MU_MID)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return (UINT32)(loop_point * 1000);
|
||||
}
|
||||
}
|
||||
|
||||
boolean I_SetSongPosition(UINT32 position)
|
||||
{
|
||||
UINT32 length;
|
||||
|
||||
#ifdef HAVE_LIBGME
|
||||
if (gme)
|
||||
{
|
||||
@@ -1034,13 +971,9 @@ boolean I_SetSongPosition(UINT32 position)
|
||||
else
|
||||
#endif
|
||||
if (!music || I_SongType() == MU_MID)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else if (I_SongType() == MU_MOD)
|
||||
{
|
||||
return Mix_SetMusicPosition(position); // Goes by channels
|
||||
}
|
||||
else
|
||||
{
|
||||
// Because SDL mixer can't identify song length, if you have
|
||||
@@ -1048,13 +981,11 @@ boolean I_SetSongPosition(UINT32 position)
|
||||
// music_bytes becomes inaccurate.
|
||||
|
||||
length = I_GetSongLength(); // get it in MS
|
||||
|
||||
if (length)
|
||||
position = get_adjusted_position(position);
|
||||
|
||||
Mix_RewindMusic(); // needed for mp3
|
||||
|
||||
if (Mix_SetMusicPosition((float)(position/1000.0L)) == 0)
|
||||
if(Mix_SetMusicPosition((float)(position/1000.0L)) == 0)
|
||||
music_bytes = (UINT32)(position/1000.0L*44100.0L*4); //assume 44.1khz, 4-byte length (see I_GetSongPosition)
|
||||
else
|
||||
// NOTE: This block fires on incorrect song format,
|
||||
@@ -1094,7 +1025,6 @@ UINT32 I_GetSongPosition(void)
|
||||
}
|
||||
|
||||
gme_free_info(info);
|
||||
|
||||
return max(position, 0);
|
||||
}
|
||||
else
|
||||
@@ -1108,16 +1038,12 @@ UINT32 I_GetSongPosition(void)
|
||||
else
|
||||
#endif
|
||||
if (!music || I_SongType() == MU_MID)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return (UINT32)(music_bytes/44100.0L*1000.0L/4); //assume 44.1khz
|
||||
// 4 = byte length for 16-bit samples (AUDIO_S16SYS), stereo (2-channel)
|
||||
// This is hardcoded in I_StartupSound. Other formats for factor:
|
||||
// 8M: 1 | 8S: 2 | 16M: 2 | 16S: 4
|
||||
}
|
||||
}
|
||||
|
||||
void I_UpdateSongLagThreshold(void)
|
||||
@@ -1131,16 +1057,12 @@ void I_UpdateSongLagThreshold(void)
|
||||
|
||||
boolean I_LoadSong(char *data, size_t len)
|
||||
{
|
||||
static const char *key1 = "LOOP";
|
||||
static const char *key2 = "POINT=";
|
||||
static const char *key3 = "MS=";
|
||||
static const size_t key1len = sizeof("LOOP")-1;
|
||||
static const size_t key2len = sizeof("POINT=")-1;
|
||||
static const size_t key3len = sizeof("MS=")-1;
|
||||
//const size_t key1len = strlen(key1);
|
||||
//const size_t key2len = strlen(key2);
|
||||
//const size_t key3len = strlen(key3);
|
||||
|
||||
const char *key1 = "LOOP";
|
||||
const char *key2 = "POINT=";
|
||||
const char *key3 = "MS=";
|
||||
const size_t key1len = strlen(key1);
|
||||
const size_t key2len = strlen(key2);
|
||||
const size_t key3len = strlen(key3);
|
||||
char *p = data;
|
||||
SDL_RWops *rw;
|
||||
|
||||
@@ -1177,7 +1099,6 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
stream.next_out = inflatedData;
|
||||
|
||||
zErr = inflateInit2(&stream, 32 + MAX_WBITS);
|
||||
|
||||
if (zErr == Z_OK) // We're good to go
|
||||
{
|
||||
zErr = inflate(&stream, Z_FINISH);
|
||||
@@ -1193,12 +1114,10 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
}
|
||||
else
|
||||
CONS_Alert(CONS_ERROR, "Encountered %s when running inflate: %s\n", get_zlib_error(zErr), stream.msg);
|
||||
|
||||
(void)inflateEnd(&stream);
|
||||
}
|
||||
else // Hold up, zlib's got a problem
|
||||
CONS_Alert(CONS_ERROR, "Encountered %s when running inflateInit: %s\n", get_zlib_error(zErr), stream.msg);
|
||||
|
||||
Z_Free(inflatedData); // GME didn't open jack, but don't let that stop us from freeing this up
|
||||
return false;
|
||||
#else
|
||||
@@ -1227,7 +1146,6 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
if (result == OPENMPT_PROBE_FILE_HEADER_RESULT_SUCCESS) // We only cared if it succeeded, continue on if not.
|
||||
{
|
||||
openmpt_mhandle = openmpt_module_create_from_memory2(data, len, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
||||
|
||||
if (!openmpt_mhandle) // Failed to create module handle? Show error and return!
|
||||
{
|
||||
mod_err = openmpt_module_error_get_last(openmpt_mhandle);
|
||||
@@ -1242,12 +1160,10 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
|
||||
// Let's see if Mixer is able to load this.
|
||||
rw = SDL_RWFromMem(data, len);
|
||||
|
||||
if (rw != NULL)
|
||||
{
|
||||
music = Mix_LoadMUS_RW(rw, 1);
|
||||
}
|
||||
|
||||
if (!music)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "Mix_LoadMUS_RW: %s\n", Mix_GetError());
|
||||
@@ -1275,7 +1191,7 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
else if (!strncmp(p, key3, key3len)) // is it LOOPMS=?
|
||||
{
|
||||
p += key3len; // skip MS=
|
||||
loop_point = (float)(atof(p) / 1000.0); // LOOPMS works by real time, as miliseconds.
|
||||
loop_point = (float)(atoi(p) / 1000.0L); // LOOPMS works by real time, as miliseconds.
|
||||
// Everything that uses LOOPMS will work perfectly with SDL_Mixer.
|
||||
}
|
||||
}
|
||||
@@ -1285,7 +1201,6 @@ boolean I_LoadSong(char *data, size_t len)
|
||||
else // continue searching
|
||||
p++;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1328,7 +1243,6 @@ boolean I_PlaySong(boolean looping)
|
||||
gme_start_track(gme, 0);
|
||||
current_track = 0;
|
||||
Mix_HookMusic(mix_gme, gme);
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
@@ -1368,17 +1282,15 @@ boolean I_PlaySong(boolean looping)
|
||||
if (!music)
|
||||
return false;
|
||||
|
||||
const musictype_t mustype = I_SongType();
|
||||
|
||||
if (fpclassify(song_length) == FP_ZERO && (mustype == MU_OGG || mustype == MU_MP3 || mustype == MU_FLAC))
|
||||
if (fpclassify(song_length) == FP_ZERO && (I_SongType() == MU_OGG || I_SongType() == MU_MP3 || I_SongType() == MU_FLAC))
|
||||
CONS_Debug(DBG_DETAILED, "This song is missing a LENGTHMS= tag! Required to make seeking work properly.\n");
|
||||
|
||||
if (mustype != MU_MOD && mustype != MU_MID && Mix_PlayMusic(music, 0) == -1)
|
||||
if (I_SongType() != MU_MOD && I_SongType() != MU_MID && Mix_PlayMusic(music, 0) == -1)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "Mix_PlayMusic: %s\n", Mix_GetError());
|
||||
return false;
|
||||
}
|
||||
else if ((mustype == MU_MOD || mustype == MU_MID) && Mix_PlayMusic(music, looping ? -1 : 0) == -1) // if MOD, loop forever
|
||||
else if ((I_SongType() == MU_MOD || I_SongType() == MU_MID) && Mix_PlayMusic(music, looping ? -1 : 0) == -1) // if MOD, loop forever
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "Mix_PlayMusic: %s\n", Mix_GetError());
|
||||
return false;
|
||||
@@ -1388,10 +1300,10 @@ boolean I_PlaySong(boolean looping)
|
||||
|
||||
I_SetMusicVolume(music_volume);
|
||||
|
||||
if (mustype != MU_MOD && mustype != MU_MID)
|
||||
if (I_SongType() != MU_MOD && I_SongType() != MU_MID)
|
||||
Mix_HookMusicFinished(music_loop); // don't bother counting if MOD
|
||||
|
||||
if (mustype != MU_MOD && mustype != MU_MID && !Mix_RegisterEffect(MIX_CHANNEL_POST, count_music_bytes, NULL, NULL))
|
||||
if(I_SongType() != MU_MOD && I_SongType() != MU_MID && !Mix_RegisterEffect(MIX_CHANNEL_POST, count_music_bytes, NULL, NULL))
|
||||
CONS_Alert(CONS_WARNING, "Error registering SDL music position counter: %s\n", Mix_GetError());
|
||||
|
||||
return true;
|
||||
@@ -1427,12 +1339,10 @@ void I_StopSong(void)
|
||||
|
||||
void I_PauseSong(void)
|
||||
{
|
||||
const musictype_t mustype = I_SongType();
|
||||
|
||||
if (mustype == MU_MID) // really, SDL Mixer? why can't you pause MIDI???
|
||||
if(I_SongType() == MU_MID) // really, SDL Mixer? why can't you pause MIDI???
|
||||
return;
|
||||
|
||||
if (mustype != MU_GME && mustype != MU_MOD && mustype != MU_MID)
|
||||
if(I_SongType() != MU_GME && I_SongType() != MU_MOD && I_SongType() != MU_MID)
|
||||
Mix_UnregisterEffect(MIX_CHANNEL_POST, count_music_bytes);
|
||||
|
||||
Mix_PauseMusic();
|
||||
@@ -1441,17 +1351,15 @@ void I_PauseSong(void)
|
||||
|
||||
void I_ResumeSong(void)
|
||||
{
|
||||
const musictype_t mustype = I_SongType();
|
||||
|
||||
if (mustype == MU_MID)
|
||||
if (I_SongType() == MU_MID)
|
||||
return;
|
||||
|
||||
if (mustype != MU_GME && mustype != MU_MOD && mustype != MU_MID)
|
||||
if (I_SongType() != MU_GME && I_SongType() != MU_MOD && I_SongType() != MU_MID)
|
||||
{
|
||||
while (Mix_UnregisterEffect(MIX_CHANNEL_POST, count_music_bytes) != 0) { }
|
||||
while(Mix_UnregisterEffect(MIX_CHANNEL_POST, count_music_bytes) != 0) { }
|
||||
// HACK: fixes issue of multiple effect callbacks being registered
|
||||
|
||||
if (music && mustype != MU_MOD && mustype != MU_MID && !Mix_RegisterEffect(MIX_CHANNEL_POST, count_music_bytes, NULL, NULL))
|
||||
if(music && I_SongType() != MU_MOD && I_SongType() != MU_MID && !Mix_RegisterEffect(MIX_CHANNEL_POST, count_music_bytes, NULL, NULL))
|
||||
CONS_Alert(CONS_WARNING, "Error registering SDL music position counter: %s\n", Mix_GetError());
|
||||
}
|
||||
|
||||
@@ -1484,24 +1392,20 @@ boolean I_SetSongTrack(INT32 track)
|
||||
{
|
||||
if (current_track == track)
|
||||
return false;
|
||||
|
||||
SDL_LockAudio();
|
||||
if (track >= 0 && track < gme_track_count(gme)-1)
|
||||
{
|
||||
gme_err_t gme_e = gme_start_track(gme, track);
|
||||
|
||||
if (gme_e != NULL)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "GME error: %s\n", gme_e);
|
||||
return false;
|
||||
}
|
||||
|
||||
current_track = track;
|
||||
SDL_UnlockAudio();
|
||||
return true;
|
||||
}
|
||||
SDL_UnlockAudio();
|
||||
|
||||
return false;
|
||||
}
|
||||
else
|
||||
@@ -1511,7 +1415,6 @@ boolean I_SetSongTrack(INT32 track)
|
||||
{
|
||||
if (current_subsong == track)
|
||||
return false;
|
||||
|
||||
SDL_LockAudio();
|
||||
if (track >= 0 && track < openmpt_module_get_num_subsongs(openmpt_mhandle))
|
||||
{
|
||||
@@ -1525,10 +1428,8 @@ boolean I_SetSongTrack(INT32 track)
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (I_SongType() == MU_MOD)
|
||||
return !Mix_SetMusicPosition(track);
|
||||
|
||||
(void)track;
|
||||
return false;
|
||||
}
|
||||
@@ -1540,10 +1441,8 @@ boolean I_SetSongTrack(INT32 track)
|
||||
void I_SetInternalMusicVolume(UINT8 volume)
|
||||
{
|
||||
internal_volume = volume;
|
||||
|
||||
if (!I_SongPlaying())
|
||||
return;
|
||||
|
||||
Mix_VolumeMusic(get_real_volume(music_volume));
|
||||
}
|
||||
|
||||
@@ -1551,7 +1450,6 @@ void I_StopFadingSong(void)
|
||||
{
|
||||
if (fading_id)
|
||||
SDL_RemoveTimer(fading_id);
|
||||
|
||||
is_fading = false;
|
||||
fading_source = fading_target = fading_timer = fading_duration = fading_id = 0;
|
||||
}
|
||||
@@ -1568,10 +1466,8 @@ boolean I_FadeSongFromVolume(UINT8 target_volume, UINT8 source_volume, UINT32 ms
|
||||
if (!ms && volume_delta)
|
||||
{
|
||||
I_SetInternalMusicVolume(target_volume);
|
||||
|
||||
if (callback)
|
||||
(*callback)();
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
@@ -1579,28 +1475,20 @@ boolean I_FadeSongFromVolume(UINT8 target_volume, UINT8 source_volume, UINT32 ms
|
||||
{
|
||||
if (callback)
|
||||
(*callback)();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Round MS to nearest 10
|
||||
// If n - lower > higher - n, then round up
|
||||
//ms = (ms - ((ms / 10) * 10) > (((ms / 10) * 10) + 10) - ms) ?
|
||||
// (((ms / 10) * 10) + 10) // higher
|
||||
// : ((ms / 10) * 10); // lower
|
||||
|
||||
const int lower = (ms / 10) * 10;
|
||||
const int upper = lower + 10;
|
||||
ms = (ms - lower > upper - ms) ? upper : lower;
|
||||
ms = (ms - ((ms / 10) * 10) > (((ms / 10) * 10) + 10) - ms) ?
|
||||
(((ms / 10) * 10) + 10) // higher
|
||||
: ((ms / 10) * 10); // lower
|
||||
|
||||
if (!ms)
|
||||
{
|
||||
I_SetInternalMusicVolume(target_volume);
|
||||
}
|
||||
else if (source_volume != target_volume)
|
||||
{
|
||||
fading_id = SDL_AddTimer(10, music_fade, NULL);
|
||||
|
||||
if (fading_id)
|
||||
{
|
||||
is_fading = true;
|
||||
@@ -1631,7 +1519,7 @@ boolean I_FadeInPlaySong(UINT32 ms, boolean looping)
|
||||
{
|
||||
if (I_PlaySong(looping))
|
||||
return I_FadeSongFromVolume(100, 0, ms, NULL);
|
||||
|
||||
return false;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
+2
-2
@@ -170,8 +170,8 @@ boolean OglSdlSurface(INT32 w, INT32 h)
|
||||
}
|
||||
}
|
||||
|
||||
if (fastcmp((const char*)gl_renderer, "GDI Generic") &&
|
||||
fastcmp((const char*)gl_version, "1.1.0"))
|
||||
if (strcmp((const char*)gl_renderer, "GDI Generic") == 0 &&
|
||||
strcmp((const char*)gl_version, "1.1.0") == 0)
|
||||
{
|
||||
// Oh no... Windows gave us the GDI Generic rasterizer, so something is wrong...
|
||||
// The game will crash later on when unsupported OpenGL commands are encountered.
|
||||
|
||||
+28
-47
@@ -23,6 +23,7 @@
|
||||
#include "r_main.h"
|
||||
#include "r_fps.h"
|
||||
#include "console.h"
|
||||
|
||||
#include "i_video.h" // rendermode
|
||||
#include "z_zone.h"
|
||||
#include "m_misc.h"
|
||||
@@ -133,7 +134,7 @@ static boolean InitCube(void)
|
||||
if (!loaded_config)
|
||||
return false;
|
||||
|
||||
#define diffcons(cv) (!fastcmp(cv.string, cv.defaultvalue))
|
||||
#define diffcons(cv) (strcmp(cv.string, cv.defaultvalue))
|
||||
#define diffconsgamma(cv) (cv.value != 0)
|
||||
#define diffconssat(cv) (cv.value != 10)
|
||||
|
||||
@@ -595,7 +596,7 @@ void V_ResetPaletteCVars(void)
|
||||
if (!loaded_config)
|
||||
return;
|
||||
|
||||
#define diffcons(cv) (!fastcmp(cv.string, cv.defaultvalue))
|
||||
#define diffcons(cv) (strcmp(cv.string, cv.defaultvalue))
|
||||
if diffcons(cv_palette)
|
||||
CV_StealthSetValue(&cv_palette, atoi(cv_palette.defaultvalue));
|
||||
if diffcons(cv_palettenum)
|
||||
@@ -640,8 +641,8 @@ void VID_BlitLinearScreen(const UINT8 *restrict srcptr, UINT8 *restrict destptr,
|
||||
}
|
||||
}
|
||||
|
||||
static const UINT8 hudplusalpha[11] = { 10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0};
|
||||
static const UINT8 hudminusalpha[11] = { 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5};
|
||||
static UINT8 hudplusalpha[11] = { 10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0};
|
||||
static UINT8 hudminusalpha[11] = { 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5};
|
||||
UINT8 hudtrans = 0;
|
||||
|
||||
static const UINT8 *v_colormap = NULL;
|
||||
@@ -1738,69 +1739,59 @@ void V_DrawHorizontallyScaledFullScreenPatch(patch_t *patch)
|
||||
|
||||
void V_DrawVhsEffect(boolean rewind)
|
||||
{
|
||||
static fixed_t upbary = 100, downbary = 150;
|
||||
|
||||
UINT8 barsize, updistort, downdistort;
|
||||
static fixed_t upbary = 100*FRACUNIT, downbary = 150*FRACUNIT;
|
||||
|
||||
UINT8 *buf = vid.screens[0], *tmp = vid.screens[4];
|
||||
UINT16 y;
|
||||
UINT32 x, pos;
|
||||
UINT32 x, pos = 0;
|
||||
|
||||
UINT8 *buf, *tmp;
|
||||
UINT8 *normalmapstart, *thismapstart;
|
||||
UINT8 *normalmapstart = ((UINT8 *)transtables + (8<<FF_TRANSSHIFT|(19<<8)));
|
||||
#ifdef HQ_VHS
|
||||
UINT8 *tmapstart;
|
||||
UINT8 *tmapstart = ((UINT8 *)transtables + (6<<FF_TRANSSHIFT));
|
||||
#endif
|
||||
UINT8 *thismapstart;
|
||||
SINT8 offs;
|
||||
|
||||
barsize = vid.dup << 5;
|
||||
updistort = vid.dup << (rewind ? 5 : 3);
|
||||
downdistort = updistort >> 1;
|
||||
UINT8 barsize = vid.dup<<5;
|
||||
UINT8 updistort = vid.dup<<(rewind ? 5 : 3);
|
||||
UINT8 downdistort = updistort>>1;
|
||||
|
||||
if (rewind)
|
||||
V_DrawVhsEffect(false); // experimentation
|
||||
|
||||
upbary -= FixedMul(vid.dup * (rewind ? 3 : 1.8f), renderdeltatics);
|
||||
downbary += FixedMul(vid.dup * (rewind ? 2 : 1), renderdeltatics);
|
||||
upbary -= renderdeltatics * (vid.dup * (rewind ? 3 : 1.8f));
|
||||
downbary += renderdeltatics * (vid.dup * (rewind ? 2 : 1));
|
||||
|
||||
if (upbary < -barsize)
|
||||
upbary = vid.height;
|
||||
if (upbary < -barsize*FRACUNIT)
|
||||
upbary = vid.height<<FRACBITS;
|
||||
if (downbary > vid.height<<FRACBITS)
|
||||
downbary = -barsize*FRACUNIT;
|
||||
|
||||
if (downbary > vid.height)
|
||||
downbary = -barsize;
|
||||
fixed_t uby = upbary>>FRACBITS, dby = downbary>>FRACBITS;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
HWR_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize);
|
||||
HWR_RenderVhsEffect(uby, dby, updistort, downdistort, barsize);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
buf = vid.screens[0];
|
||||
tmp = vid.screens[4];
|
||||
|
||||
normalmapstart = ((UINT8 *)transtables + (8<<FF_TRANSSHIFT|(19<<8)));
|
||||
#ifdef HQ_VHS
|
||||
tmapstart = ((UINT8 *)transtables + (6<<FF_TRANSSHIFT));
|
||||
#endif
|
||||
|
||||
pos = 0;
|
||||
|
||||
for (y = 0; y < vid.height; y+=2)
|
||||
{
|
||||
thismapstart = normalmapstart;
|
||||
offs = 0;
|
||||
|
||||
if (y >= upbary && y < upbary+barsize)
|
||||
if (y >= uby && y < uby+barsize)
|
||||
{
|
||||
thismapstart -= (2<<FF_TRANSSHIFT) - (5<<8);
|
||||
offs += updistort * 2.0f * min(y-upbary, upbary+barsize-y) / barsize;
|
||||
offs += updistort * 2.0f * min(y-uby, uby+barsize-y) / barsize;
|
||||
}
|
||||
|
||||
if (y >= downbary && y < downbary+barsize)
|
||||
if (y >= dby && y < dby+barsize)
|
||||
{
|
||||
thismapstart -= (2<<FF_TRANSSHIFT) - (5<<8);
|
||||
offs -= downdistort * 2.0f * min(y-downbary, downbary+barsize-y) / barsize;
|
||||
offs -= downdistort * 2.0f * min(y-dby, dby+barsize-y) / barsize;
|
||||
}
|
||||
|
||||
offs += M_RandomKey(vid.dup<<1);
|
||||
@@ -1918,10 +1909,8 @@ UINT8 *V_GetStringColormap(INT32 colorflags)
|
||||
}
|
||||
#else // optimised
|
||||
colorflags = ((colorflags & V_CHARCOLORMASK) >> V_CHARCOLORSHIFT);
|
||||
|
||||
if (!colorflags || colorflags > 15) // INT32 is signed, but V_CHARCOLORMASK is a very restrictive mask.
|
||||
return NULL;
|
||||
|
||||
return (purplemap+((colorflags-1)<<8));
|
||||
#endif
|
||||
}
|
||||
@@ -2011,7 +2000,6 @@ char *V_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
|
||||
for (i = 0; i < slen; ++i)
|
||||
{
|
||||
c = newstring[i];
|
||||
|
||||
if ((UINT8)c >= 0x80 && (UINT8)c <= 0x8F) //color parsing! -Inuyasha 2.16.09
|
||||
continue;
|
||||
|
||||
@@ -3580,9 +3568,6 @@ boolean *heatshifter = NULL;
|
||||
INT32 lastheight = 0;
|
||||
INT32 heatindex[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
|
||||
|
||||
// unused motion blur effect, probably non functional
|
||||
//#define MOTIONBLUR
|
||||
|
||||
//
|
||||
// V_DoPostProcessor
|
||||
//
|
||||
@@ -3597,9 +3582,7 @@ void V_DoPostProcessor(INT32 view, INT32 param)
|
||||
(void)type;
|
||||
(void)param;
|
||||
#else
|
||||
#ifndef MOTIONBLUR
|
||||
(void)param; // unused motion blur stuff
|
||||
#endif
|
||||
INT32 yoffset, xoffset;
|
||||
|
||||
#ifdef HWRENDER
|
||||
@@ -3734,8 +3717,7 @@ void V_DoPostProcessor(INT32 view, INT32 param)
|
||||
srcscr = tmp;
|
||||
}
|
||||
|
||||
#ifdef MOTIONBLUR
|
||||
if (thiscam->postimg & POSTIMG_MOTION) // Motion Blur!
|
||||
/*if (thiscam->postimg & POSTIMG_MOTION) // Motion Blur!
|
||||
{
|
||||
INT32 x, y;
|
||||
|
||||
@@ -3747,8 +3729,7 @@ void V_DoPostProcessor(INT32 view, INT32 param)
|
||||
for (x = xoffset; x < xoffset+viewwidth; x++)
|
||||
tmpscr[y*vid.width + x] = colormaps[*(transme + (srcscr [(y*vid.width)+x ] <<8) + (tmpscr[(y*vid.width)+x]))];
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}*/
|
||||
|
||||
if ((thiscam->postimg & POSTIMG_FLIP) && !(thiscam->postimg & POSTIMG_MIRROR)) // Flip the screen upside-down
|
||||
{
|
||||
|
||||
+12
-19
@@ -259,12 +259,9 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
|
||||
size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
|
||||
char *name = malloc(length + 1);
|
||||
|
||||
if (!name)
|
||||
I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
|
||||
|
||||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
name[length] = '\0';
|
||||
CONS_Printf("Loading SOC from %s\n", name);
|
||||
CONS_Printf(M_GetText("Loading SOC from %s\n"), name);
|
||||
DEH_LoadDehackedLumpPwad(wadnum, posStart);
|
||||
free(name);
|
||||
}
|
||||
@@ -295,9 +292,6 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum)
|
||||
size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
|
||||
char *name = malloc(length + 1);
|
||||
|
||||
if (!name)
|
||||
I_Error("W_LoadDehackedLumps: Out of memory!\n");
|
||||
|
||||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
name[length] = '\0';
|
||||
|
||||
@@ -375,11 +369,11 @@ static restype_t ResourceFileDetect(const char* filename)
|
||||
{
|
||||
size_t len = strlen(filename) - 4;
|
||||
|
||||
if (fasticmp(&filename[len], ".pk3"))
|
||||
if (!stricmp(&filename[len], ".pk3"))
|
||||
return RET_PK3;
|
||||
if (fasticmp(&filename[len], ".soc"))
|
||||
if (!stricmp(&filename[len], ".soc"))
|
||||
return RET_SOC;
|
||||
if (fasticmp(&filename[len], ".lua"))
|
||||
if (!stricmp(&filename[len], ".lua"))
|
||||
return RET_LUA;
|
||||
|
||||
return RET_WAD;
|
||||
@@ -971,25 +965,24 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
|
||||
* \return 1 if all files were loaded, 0 if at least one was missing or
|
||||
* invalid.
|
||||
*/
|
||||
INT32 W_InitMultipleFiles(char **filenames, size_t count, boolean addons)
|
||||
INT32 W_InitMultipleFiles(char **filenames, boolean addons)
|
||||
{
|
||||
INT32 rc = 1;
|
||||
INT32 overallrc = 1;
|
||||
size_t i;
|
||||
|
||||
(void)addons;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
// will be realloced as lumps are added
|
||||
for (; *filenames; filenames++)
|
||||
{
|
||||
const char *filename = filenames[i];
|
||||
|
||||
// Previously, W_VerifyNMUSlumps was called to mark game modified
|
||||
// for addons... but W_InitFile already does exactly that!
|
||||
|
||||
//CONS_Debug(DBG_SETUP, "Loading %s\n", *filenames);
|
||||
rc = W_InitFile(filename, false, true);
|
||||
rc = W_InitFile(*filenames, false, true);
|
||||
|
||||
if (rc == INT16_MAX)
|
||||
CONS_Printf(M_GetText("Errors occurred while loading %s; not added.\n"), filename);
|
||||
CONS_Printf(M_GetText("Errors occurred while loading %s; not added.\n"), *filenames);
|
||||
|
||||
overallrc &= (rc != INT16_MAX) ? 1 : 0;
|
||||
}
|
||||
@@ -1130,7 +1123,7 @@ UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
if (lump_p->longnamelength == namelen
|
||||
&& lump_p->hash.longname == hash
|
||||
&& fasticmp(lump_p->longname, name))
|
||||
&& !stricmp(lump_p->longname, name))
|
||||
return i;
|
||||
}
|
||||
}
|
||||
@@ -1230,7 +1223,7 @@ static lumpnum_t CheckLumpInCache(const char *name, boolean longname)
|
||||
for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
|
||||
{
|
||||
if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
|
||||
&& fasticmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name))
|
||||
&& stricmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name) == 0)
|
||||
{
|
||||
lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
|
||||
return lumpnumcache[lumpnumcacheindex].lumpnum;
|
||||
|
||||
+1
-1
@@ -167,7 +167,7 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup);
|
||||
|
||||
// W_InitMultipleFiles returns 1 if all is okay, 0 otherwise,
|
||||
// so that it stops with a message if a file was not found, but not if all is okay.
|
||||
INT32 W_InitMultipleFiles(char **filenames, size_t count, boolean addons);
|
||||
INT32 W_InitMultipleFiles(char **filenames, boolean addons);
|
||||
|
||||
// Used for autoload. Uses P_AddWadFileLocal instead of W_InitFiles.
|
||||
INT32 W_AddAutoloadedLocalFiles(char **filenames);
|
||||
|
||||
+12
-2
@@ -552,8 +552,18 @@ void Y_Ticker(void)
|
||||
|
||||
intertic++;
|
||||
|
||||
if ((timer && !--timer)
|
||||
|| (intertic == endtic))
|
||||
// multiplayer uses timer (based on cv_inttime)
|
||||
if (timer)
|
||||
{
|
||||
if (!--timer)
|
||||
{
|
||||
Y_EndIntermission();
|
||||
Y_FollowIntermission();
|
||||
return;
|
||||
}
|
||||
}
|
||||
// single player is hardcoded to go away after awhile
|
||||
else if (intertic == endtic)
|
||||
{
|
||||
Y_EndIntermission();
|
||||
Y_FollowIntermission();
|
||||
|
||||
Reference in new issue
Block a user