Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
794fda5ac5 |
No files matched your search
@@ -247,9 +247,6 @@ set(SRB2_CONFIG_ASAN OFF CACHE BOOL
|
||||
set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
|
||||
"Compile with UndefinedBehaviorSanitizer (libubsan).")
|
||||
|
||||
set(SRB2_CONFIG_MUMBLE ON CACHE BOOL
|
||||
"Enable Mumble support")
|
||||
|
||||
set(SRB2_CONFIG_SATURNPAK ON CACHE BOOL
|
||||
"Enable Saturn specific special packet. Required for using the newer resynch system")
|
||||
set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
|
||||
@@ -257,9 +254,6 @@ set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
|
||||
set(SRB2_CONFIG_SCREENFBO ON CACHE BOOL
|
||||
"Enable hardware renderer (OpenGL) FBO downsampling support")
|
||||
|
||||
set(SRB2_CONFIG_PHOBOS OFF CACHE BOOL
|
||||
" Compile the Phobos client. Which contains things not compatible with vanilla, such as raised skinlimits, 32 player support, bugfixes, etc.")
|
||||
|
||||
if(${SRB2_CONFIG_DEDICATED})
|
||||
set(SRB2_CONFIG_HAVE_GME NO)
|
||||
set(SRB2_CONFIG_HAVE_OPENMPT NO)
|
||||
@@ -281,7 +275,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
|
||||
lua_hooklib.c
|
||||
lua_hudlib.c
|
||||
lua_hudlib_drawlist.c
|
||||
lua_profile.cpp
|
||||
lua_infolib.c
|
||||
lua_maplib.c
|
||||
lua_mathlib.c
|
||||
@@ -297,7 +290,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
|
||||
lua_hook.h
|
||||
lua_hud.h
|
||||
lua_hudlib_drawlist.h
|
||||
lua_profile.h
|
||||
lua_libs.h
|
||||
lua_script.h
|
||||
lua_udatalib.h
|
||||
@@ -586,10 +578,6 @@ if(${SRB2_CONFIG_SATURNJOIN})
|
||||
add_definitions(-DDOSATURNJOIN)
|
||||
endif()
|
||||
|
||||
if(${SRB2_CONFIG_PHOBOS})
|
||||
add_definitions(-DPHOBOS_BUILD)
|
||||
endif()
|
||||
|
||||
# Targets
|
||||
|
||||
# Compatibility flag with later versions of GCC
|
||||
|
||||
+4
-4
@@ -65,10 +65,6 @@
|
||||
# DEBUGMODE=1 - Enable various debugging capabilities.
|
||||
# Also disables optimizations.
|
||||
#
|
||||
# PHOBOS_BUILD=1 - Compile the Phobos client.
|
||||
# Contains things not compatible with vanilla.
|
||||
# such as raised skinlimits, 32 player support, bugfixes, etc.
|
||||
#
|
||||
# Development flags:
|
||||
#
|
||||
# VALGRIND=1 - Enable Valgrind memory debugging support.
|
||||
@@ -250,6 +246,10 @@ ifdef STATIC
|
||||
libs+=-static
|
||||
endif
|
||||
|
||||
ifneq (,$(filter $(CC) $(CXX),gcc g++))
|
||||
opts+=-mno-ms-bitfields
|
||||
endif
|
||||
|
||||
# build with profiling information
|
||||
ifdef PROFILEMODE
|
||||
opts+=-pg
|
||||
|
||||
@@ -9,7 +9,6 @@ passthru_opts+=\
|
||||
HAVE_DISCORDRPC DEVELOP\
|
||||
NOHOLEPUNCH\
|
||||
HAVE_IPV6\
|
||||
PHOBOS_BUILD\
|
||||
|
||||
# build with debugging information
|
||||
ifdef DEBUGMODE
|
||||
@@ -87,7 +86,7 @@ ifdef VALGRIND
|
||||
VALGRIND_PKGCONFIG?=valgrind
|
||||
VALGRIND_LDFLAGS=
|
||||
$(eval $(call Use_pkg_config,VALGRIND))
|
||||
#ZDEBUG=1 we enable this by default
|
||||
ZDEBUG=1
|
||||
opts+=-DHAVE_VALGRIND
|
||||
endif
|
||||
|
||||
|
||||
@@ -99,4 +99,3 @@ lua_skinlib.c
|
||||
lua_thinkerlib.c
|
||||
lua_udatalib.c
|
||||
lua_glib.c
|
||||
lua_profile.cpp
|
||||
+2
-2
@@ -55,8 +55,8 @@ struct lua_longjmp {
|
||||
|
||||
void luaD_seterrorobj (lua_State *L, int lerrcode, StkId oldtop) {
|
||||
switch (lerrcode) {
|
||||
case LUA_ERRMEM: { /* memory error? */
|
||||
setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
|
||||
case LUA_ERRMEM: {
|
||||
setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
|
||||
break;
|
||||
}
|
||||
case LUA_ERRERR: {
|
||||
|
||||
@@ -13,6 +13,8 @@
|
||||
#include "llimits.h"
|
||||
#include "lua.h"
|
||||
|
||||
#define MEMERRMSG "not enough memory"
|
||||
|
||||
|
||||
#define luaM_reallocv(L,b,on,n,e) \
|
||||
((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ? /* +1 to avoid warnings */ \
|
||||
|
||||
+1
-1
@@ -143,7 +143,7 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
|
||||
}
|
||||
case 'p': {
|
||||
char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
|
||||
snprintf(buff, sizeof(buff), "%p", va_arg(argp, void *));
|
||||
sprintf(buff, "%p", va_arg(argp, void *));
|
||||
pushstr(L, buff);
|
||||
break;
|
||||
}
|
||||
|
||||
+1
-6
@@ -64,9 +64,6 @@ static void freestack (lua_State *L, lua_State *L1) {
|
||||
}
|
||||
|
||||
|
||||
#define MEMERRMSG "not enough memory"
|
||||
|
||||
|
||||
/*
|
||||
** open parts that may cause memory-allocation errors
|
||||
*/
|
||||
@@ -79,9 +76,7 @@ static void f_luaopen (lua_State *L, void *ud) {
|
||||
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
|
||||
luaT_init(L);
|
||||
luaX_init(L);
|
||||
/* pre-create memory-error message */
|
||||
g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
|
||||
luaS_fix(g->memerrmsg); /* it should never be collected */
|
||||
luaS_fix(luaS_newliteral(L, MEMERRMSG));
|
||||
g->GCthreshold = 4*g->totalbytes;
|
||||
}
|
||||
|
||||
|
||||
@@ -88,7 +88,6 @@ typedef struct global_State {
|
||||
lua_CFunction panic; /* to be called in unprotected errors */
|
||||
TValue l_registry;
|
||||
struct lua_State *mainthread;
|
||||
TString *memerrmsg; /* memory-error message */
|
||||
UpVal uvhead; /* head of double-linked list of all open upvalues */
|
||||
struct Table *mt[NUM_TAGS]; /* metatables for basic types */
|
||||
TString *tmname[TM_N]; /* array with tag-method names */
|
||||
|
||||
+6
-6
@@ -776,23 +776,23 @@ static int str_format (lua_State *L) {
|
||||
strfrmt = scanformat(L, strfrmt, form);
|
||||
switch (*strfrmt++) {
|
||||
case 'c': {
|
||||
snprintf(buff, sizeof(buff), form, (int)luaL_checknumber(L, arg));
|
||||
sprintf(buff, form, (int)luaL_checknumber(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'd': case 'i': {
|
||||
addintlen(form);
|
||||
snprintf(buff, sizeof(buff), form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
|
||||
sprintf(buff, form, (LUA_INTFRM_T)luaL_checknumber(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'o': case 'u': case 'x': case 'X': {
|
||||
addintlen(form);
|
||||
snprintf(buff, sizeof(buff), form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
|
||||
sprintf(buff, form, (unsigned LUA_INTFRM_T)luaL_checknumber(L, arg));
|
||||
break;
|
||||
}
|
||||
case 'e': case 'E': case 'f':
|
||||
case 'g': case 'G': {
|
||||
lua_Number n = luaL_checknumber(L, arg);
|
||||
snprintf(buff, sizeof(buff), form, (double)n);
|
||||
lua_Number n = luaL_checknumber(L, arg);
|
||||
sprintf(buff, form, (double)n);
|
||||
break;
|
||||
}
|
||||
case 'q': {
|
||||
@@ -810,7 +810,7 @@ static int str_format (lua_State *L) {
|
||||
continue; /* skip the `addsize' at the end */
|
||||
}
|
||||
else {
|
||||
snprintf(buff, sizeof(buff), form, s);
|
||||
sprintf(buff, form, s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -536,7 +536,7 @@
|
||||
#define LUA_NUMBER_SCAN "%d"
|
||||
#define LUA_NUMBER_FMT "%d"
|
||||
#endif
|
||||
#define lua_number2str(s,n) snprintf((s), LUAI_MAXNUMBER2STR, LUA_NUMBER_FMT, (n))
|
||||
#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
|
||||
#define LUAI_MAXNUMBER2STR 12 /* 10 digits, sign, and \0 */
|
||||
#define lua_str2number(s,p) ({ \
|
||||
long nmr = strtol((s), (p), 10); \
|
||||
|
||||
@@ -206,15 +206,6 @@ FUNCINLINE static ATTRINLINE UINT32 readulong(void *ptr)
|
||||
p += n; \
|
||||
} while (0)
|
||||
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
#define WRITESKIN(p,b) WRITEUINT16(p,b)
|
||||
#define READSKIN(p) READUINT16(p)
|
||||
#else
|
||||
#define WRITESKIN(p,b) WRITEUINT8(p,b)
|
||||
#define READSKIN(p) READUINT8(p)
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
+15
-42
@@ -113,29 +113,18 @@ static vsbuf_t com_text; // variable sized buffer
|
||||
* \param ptext The text to add.
|
||||
* \sa COM_BufInsertText
|
||||
*/
|
||||
void COM_BufAddTextEx(const char *ptext, size_t plen)
|
||||
void COM_BufAddText(const char *ptext)
|
||||
{
|
||||
size_t l;
|
||||
char *text;
|
||||
|
||||
if (plen == 0)
|
||||
plen = strlen(ptext);
|
||||
|
||||
text = Z_Malloc(sizeof(char) * (plen+1), PU_STATIC, NULL);
|
||||
memcpy(text, ptext, plen);
|
||||
text[plen] = '\0';
|
||||
|
||||
l = strlen(text);
|
||||
l = strlen(ptext);
|
||||
|
||||
if (com_text.cursize + l >= com_text.maxsize)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Command buffer full!\n"));
|
||||
return;
|
||||
}
|
||||
|
||||
VS_Write(&com_text, text, l);
|
||||
|
||||
Z_Free(text);
|
||||
VS_Write(&com_text, ptext, l);
|
||||
}
|
||||
|
||||
/** Adds command text and executes it immediately.
|
||||
@@ -143,10 +132,8 @@ void COM_BufAddTextEx(const char *ptext, size_t plen)
|
||||
* \param ptext The text to execute. A newline is automatically added.
|
||||
* \sa COM_BufAddText
|
||||
*/
|
||||
void COM_BufInsertTextEx(const char *ptext, size_t plen)
|
||||
void COM_BufInsertText(const char *ptext)
|
||||
{
|
||||
const INT32 old_wait = com_wait;
|
||||
|
||||
char *temp = NULL;
|
||||
size_t templen;
|
||||
|
||||
@@ -158,14 +145,10 @@ void COM_BufInsertTextEx(const char *ptext, size_t plen)
|
||||
VS_Clear(&com_text);
|
||||
}
|
||||
|
||||
com_wait = 0;
|
||||
|
||||
// add the entire text of the file (or alias)
|
||||
COM_BufAddTextEx(ptext, plen);
|
||||
COM_BufAddText(ptext);
|
||||
COM_BufExecute(); // do it right away
|
||||
|
||||
com_wait += old_wait;
|
||||
|
||||
// add the copied off data
|
||||
if (templen)
|
||||
{
|
||||
@@ -176,7 +159,8 @@ void COM_BufInsertTextEx(const char *ptext, size_t plen)
|
||||
|
||||
/** Progress the wait timer and flush waiting console commands when ready.
|
||||
*/
|
||||
void COM_BufTicker(void)
|
||||
void
|
||||
COM_BufTicker(void)
|
||||
{
|
||||
if (com_wait)
|
||||
{
|
||||
@@ -1612,9 +1596,7 @@ void CV_SaveNetVars(UINT8 **p, boolean isdemorecording)
|
||||
// send only changed cvars ...
|
||||
// the client will reset all netvars to default before loading
|
||||
WRITEUINT16(*p, 0x0000);
|
||||
|
||||
for (cvar = consvar_vars; cvar; cvar = cvar->next)
|
||||
{
|
||||
if (((cvar->flags & CV_NETVAR) && !CV_IsSetToDefault(cvar)) || (isdemorecording && cvar->netid == cv_numlaps.netid))
|
||||
{
|
||||
WRITEUINT16(*p, cvar->netid);
|
||||
@@ -1632,7 +1614,7 @@ void CV_SaveNetVars(UINT8 **p, boolean isdemorecording)
|
||||
else
|
||||
{
|
||||
char buf[9];
|
||||
snprintf(buf, sizeof(buf), "%d", mapheaderinfo[gamemap - 1]->numlaps);
|
||||
sprintf(buf, "%d", mapheaderinfo[gamemap - 1]->numlaps);
|
||||
WRITESTRING(*p, buf);
|
||||
}
|
||||
}
|
||||
@@ -1644,8 +1626,6 @@ void CV_SaveNetVars(UINT8 **p, boolean isdemorecording)
|
||||
WRITEUINT8(*p, false);
|
||||
++count;
|
||||
}
|
||||
}
|
||||
|
||||
WRITEUINT16(count_p, count);
|
||||
}
|
||||
|
||||
@@ -1802,7 +1782,8 @@ void CV_StealthSet(consvar_t *var, const char *value)
|
||||
void CV_StealthSetValue(consvar_t *var, INT32 value)
|
||||
{
|
||||
char val[32];
|
||||
snprintf(val, sizeof(val), "%d", value);
|
||||
|
||||
sprintf(val, "%d", value);
|
||||
CV_SetCVar(var, val, true);
|
||||
}
|
||||
|
||||
@@ -1822,7 +1803,8 @@ void CV_Set(consvar_t *var, const char *value)
|
||||
void CV_SetValue(consvar_t *var, INT32 value)
|
||||
{
|
||||
char val[32];
|
||||
snprintf(val, sizeof(val), "%d", value);
|
||||
|
||||
sprintf(val, "%d", value);
|
||||
CV_SetCVar(var, val, false);
|
||||
}
|
||||
|
||||
@@ -2220,7 +2202,6 @@ void CV_SaveVariables(FILE *f)
|
||||
consvar_t *cvar;
|
||||
|
||||
for (cvar = consvar_vars; cvar; cvar = cvar->next)
|
||||
{
|
||||
if (cvar->flags & CV_SAVE)
|
||||
{
|
||||
char stringtowrite[MAXTEXTCMD+1];
|
||||
@@ -2229,23 +2210,15 @@ void CV_SaveVariables(FILE *f)
|
||||
if (fastcmp(cvar->string, "MAX") || fastcmp(cvar->string, "MIN"))
|
||||
{
|
||||
if (cvar->flags & CV_FLOAT)
|
||||
{
|
||||
snprintf(stringtowrite, sizeof(stringtowrite), "%f", FixedToFloat(cvar->value));
|
||||
}
|
||||
sprintf(stringtowrite, "%f", FixedToFloat(cvar->value));
|
||||
else
|
||||
{
|
||||
snprintf(stringtowrite, sizeof(stringtowrite), "%d", cvar->value);
|
||||
}
|
||||
sprintf(stringtowrite, "%d", cvar->value);
|
||||
}
|
||||
else
|
||||
{
|
||||
strncpy(stringtowrite, cvar->string, sizeof(stringtowrite)-1);
|
||||
stringtowrite[sizeof(stringtowrite)-1] = '\0';
|
||||
}
|
||||
strcpy(stringtowrite, cvar->string);
|
||||
|
||||
fprintf(f, "%s \"%s\"\n", cvar->name, stringtowrite);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
+2
-4
@@ -52,12 +52,10 @@ size_t COM_FirstOption(void);
|
||||
const char *COM_CompleteCommand(const char *partial, INT32 skips);
|
||||
|
||||
// insert at queu (at end of other command)
|
||||
#define COM_BufAddText(s) COM_BufAddTextEx(s, 0)
|
||||
void COM_BufAddTextEx(const char *ptext, size_t plen);
|
||||
void COM_BufAddText(const char *btext);
|
||||
|
||||
// insert in head (before other command)
|
||||
#define COM_BufInsertText(s) COM_BufInsertTextEx(s, 0)
|
||||
void COM_BufInsertTextEx(const char *ptext, size_t plen);
|
||||
void COM_BufInsertText(const char *btext);
|
||||
|
||||
// don't bother inserting, just do immediately
|
||||
void COM_ImmedExecute(const char *ptext);
|
||||
|
||||
+3
-27
@@ -1,7 +1,7 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
// BLANKART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2024 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
@@ -149,30 +149,6 @@ void PoolAllocator::release()
|
||||
allocated_blocks_ = 0;
|
||||
}
|
||||
|
||||
bool PoolAllocator::ptrcheck(const void* p) const
|
||||
{
|
||||
const uintptr_t paddr = reinterpret_cast<uintptr_t>(p);
|
||||
|
||||
ChunkFooter* next = nullptr;
|
||||
for (ChunkFooter* chunk = first_chunk_; chunk != nullptr; chunk = next)
|
||||
{
|
||||
const uintptr_t blockstart = reinterpret_cast<uintptr_t>(chunk->start);
|
||||
const uintptr_t blockend = blockstart + blocks_ * block_size_;
|
||||
|
||||
//CONS_Printf("mobj ptr %lu, block start %lu end %lu\n", paddr, blockstart, blockend);
|
||||
|
||||
if (paddr >= blockstart && paddr < blockend)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
next = chunk->next;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
static LinearMemory g_frame_memory {4 * 1024 * 1024};
|
||||
|
||||
void* Z_Frame_Alloc(size_t size)
|
||||
|
||||
+3
-4
@@ -1,7 +1,7 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
// SONIC ROBO BLAST 2 KART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2024 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
@@ -65,7 +65,6 @@ public:
|
||||
constexpr size_t allocated_bytes() const noexcept { return allocated_blocks_ * block_size_; };
|
||||
|
||||
void release();
|
||||
bool ptrcheck(const void* p) const;
|
||||
};
|
||||
|
||||
} // namespace srb2
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
// SONIC ROBO BLAST 2 KART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2024 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
// BLANKART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2024 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
// SONIC ROBO BLAST 2 KART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
|
||||
// Copyright (C) 2024 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
|
||||
+72
-114
@@ -1125,7 +1125,7 @@ static cl_mode_t cl_mode = CL_SEARCHING;
|
||||
static UINT16 cl_lastcheckedfilecount = 0; // used for full file list
|
||||
|
||||
// Player name send/load
|
||||
#ifndef PHOBOS_BUILD
|
||||
|
||||
static void CV_SavePlayerNames(UINT8 **p)
|
||||
{
|
||||
INT32 i = 0;
|
||||
@@ -1161,7 +1161,6 @@ static void CV_LoadPlayerNames(UINT8 **p)
|
||||
memcpy(player_names[i], tmp_name, MAXPLAYERNAME+1);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void CL_DrawAddonTypes(void)
|
||||
{
|
||||
@@ -1630,8 +1629,8 @@ static boolean CL_SendJoin(void)
|
||||
netbuffer->u.clientcfg.packetversion = PACKETVERSION;
|
||||
netbuffer->u.clientcfg.version = VERSION;
|
||||
netbuffer->u.clientcfg.subversion = SUBVERSION;
|
||||
strncpy(netbuffer->u.clientcfg.application, SRB2APPLICATION, sizeof(netbuffer->u.clientcfg.application)-1);
|
||||
netbuffer->u.clientcfg.application[sizeof(netbuffer->u.clientcfg.application)-1] = '\0';
|
||||
strncpy(netbuffer->u.clientcfg.application, SRB2APPLICATION,
|
||||
sizeof(netbuffer->u.clientcfg.application));
|
||||
#ifdef SATURNJOIN
|
||||
netbuffer->u.clientcfg.issaturn = ISSATURN;
|
||||
#endif
|
||||
@@ -1656,91 +1655,88 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
|
||||
|
||||
doomdata_t *netbuffer = DOOMCOM_DATA(doomcom);
|
||||
|
||||
serverinfo_pak *serverinfo = &netbuffer->u.serverinfo;
|
||||
|
||||
netbuffer->packettype = PT_SERVERINFO;
|
||||
serverinfo->_255 = 255;
|
||||
serverinfo->packetversion = PACKETVERSION;
|
||||
serverinfo->version = VERSION;
|
||||
serverinfo->subversion = SUBVERSION;
|
||||
strncpy(serverinfo->application, SRB2APPLICATION, sizeof(serverinfo->application)-1);
|
||||
serverinfo->application[sizeof(serverinfo->application)-1] = '\0';
|
||||
netbuffer->u.serverinfo._255 = 255;
|
||||
netbuffer->u.serverinfo.packetversion = PACKETVERSION;
|
||||
netbuffer->u.serverinfo.version = VERSION;
|
||||
netbuffer->u.serverinfo.subversion = SUBVERSION;
|
||||
strncpy(netbuffer->u.serverinfo.application, SRB2APPLICATION,
|
||||
sizeof netbuffer->u.serverinfo.application);
|
||||
// return back the time value so client can compute their ping
|
||||
serverinfo->time = (tic_t)LONG(servertime);
|
||||
serverinfo->leveltime = (tic_t)LONG(leveltime);
|
||||
netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
|
||||
netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
|
||||
|
||||
// force 1 player
|
||||
if (UseFakeSeed())
|
||||
serverinfo->numberofplayer = (UINT8)1;
|
||||
netbuffer->u.serverinfo.numberofplayer = (UINT8)1;
|
||||
else
|
||||
serverinfo->numberofplayer = (UINT8)D_NumPlayers();
|
||||
netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
|
||||
|
||||
serverinfo->maxplayer = (UINT8)(min((dedicated ? MAXPLAYERS-1 : MAXPLAYERS), cv_maxplayers.value));
|
||||
netbuffer->u.serverinfo.maxplayer = (UINT8)(min((dedicated ? MAXPLAYERS-1 : MAXPLAYERS), cv_maxplayers.value));
|
||||
|
||||
// SRB2Kart: Vanilla's gametype constants for MS support
|
||||
serverinfo->gametype = (UINT8)((gt == GT_MATCH) ? VANILLA_GT_MATCH : VANILLA_GT_RACE);
|
||||
netbuffer->u.serverinfo.gametype = (UINT8)((gt == GT_MATCH) ? VANILLA_GT_MATCH : VANILLA_GT_RACE);
|
||||
|
||||
serverinfo->modifiedgame = (UINT8)modifiedgame;
|
||||
serverinfo->cheatsenabled = CV_CheatsEnabled();
|
||||
netbuffer->u.serverinfo.modifiedgame = (UINT8)modifiedgame;
|
||||
netbuffer->u.serverinfo.cheatsenabled = CV_CheatsEnabled();
|
||||
|
||||
serverinfo->kartvars = (UINT8) (
|
||||
netbuffer->u.serverinfo.kartvars = (UINT8) (
|
||||
(cv_kartspeed.value & SV_SPEEDMASK) |
|
||||
(dedicated ? SV_DEDICATED : 0)
|
||||
);
|
||||
|
||||
CopyCaretColors(serverinfo->servername, cv_servername.string, MAXSERVERNAME);
|
||||
CopyCaretColors(netbuffer->u.serverinfo.servername, cv_servername.string,
|
||||
MAXSERVERNAME);
|
||||
strncpy(netbuffer->u.serverinfo.mapname, G_BuildMapName(gamemap), sizeof(netbuffer->u.serverinfo.mapname)-1);
|
||||
|
||||
strncpy(serverinfo->mapname, G_BuildMapName(gamemap), sizeof(serverinfo->mapname)-1);
|
||||
serverinfo->mapname[sizeof(serverinfo->mapname)-1] = '\0';
|
||||
memcpy(netbuffer->u.serverinfo.mapmd5, mapmd5, sizeof(netbuffer->u.serverinfo.mapmd5));
|
||||
|
||||
memcpy(serverinfo->mapmd5, mapmd5, sizeof(serverinfo->mapmd5));
|
||||
netbuffer->u.serverinfo.iszone = 0;
|
||||
|
||||
serverinfo->iszone = 0;
|
||||
|
||||
memset(serverinfo->maptitle, 0, sizeof(serverinfo->maptitle));
|
||||
memset(serverinfo->httpsource, 0, MAX_MIRROR_LENGTH);
|
||||
memset(netbuffer->u.serverinfo.maptitle, 0, sizeof(netbuffer->u.serverinfo.maptitle));
|
||||
memset(netbuffer->u.serverinfo.httpsource, 0, MAX_MIRROR_LENGTH);
|
||||
|
||||
if (!(mapheaderinfo[gamemap-1]->menuflags & LF2_HIDEINMENU) && mapheaderinfo[gamemap-1]->lvlttl[0])
|
||||
{
|
||||
strncpy(serverinfo->maptitle, mapheaderinfo[gamemap-1]->lvlttl, sizeof(serverinfo->maptitle)-1);
|
||||
strncpy(netbuffer->u.serverinfo.maptitle, mapheaderinfo[gamemap-1]->lvlttl, sizeof(netbuffer->u.serverinfo.maptitle)-1);
|
||||
|
||||
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE))
|
||||
{
|
||||
if (mapheaderinfo[gamemap-1]->zonttl[0])
|
||||
{
|
||||
strncat(serverinfo->maptitle, " ", sizeof(serverinfo->maptitle)-1);
|
||||
strncat(serverinfo->maptitle, mapheaderinfo[gamemap-1]->zonttl, sizeof(serverinfo->maptitle)-1);
|
||||
strncat(netbuffer->u.serverinfo.maptitle, " ", sizeof(netbuffer->u.serverinfo.maptitle)-1);
|
||||
strncat(netbuffer->u.serverinfo.maptitle, mapheaderinfo[gamemap-1]->zonttl,
|
||||
sizeof(netbuffer->u.serverinfo.maptitle)-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
serverinfo->iszone = 1; // ms and clients will append this themselves
|
||||
netbuffer->u.serverinfo.iszone = 1; // ms and clients will append this themselves
|
||||
}
|
||||
}
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->actnum[0])
|
||||
{
|
||||
strncat(serverinfo->maptitle, " ", sizeof(serverinfo->maptitle)-1);
|
||||
strncat(serverinfo->maptitle, mapheaderinfo[gamemap-1]->actnum, sizeof(serverinfo->maptitle)-1);
|
||||
strncat(netbuffer->u.serverinfo.maptitle, " ", sizeof(netbuffer->u.serverinfo.maptitle)-1);
|
||||
strncat(netbuffer->u.serverinfo.maptitle, mapheaderinfo[gamemap-1]->actnum,
|
||||
sizeof(netbuffer->u.serverinfo.maptitle)-1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
strncpy(serverinfo->maptitle, "Unknown", sizeof(serverinfo->maptitle)-1);
|
||||
}
|
||||
strncpy(netbuffer->u.serverinfo.maptitle, "Unknown", 33);
|
||||
|
||||
serverinfo->maptitle[sizeof(serverinfo->maptitle)-1] = '\0';
|
||||
netbuffer->u.serverinfo.maptitle[32] = '\0';
|
||||
|
||||
serverinfo->actnum = 0; //mapheaderinfo[gamemap-1]->actnum
|
||||
netbuffer->u.serverinfo.actnum = 0; //mapheaderinfo[gamemap-1]->actnum
|
||||
|
||||
mirror_length = strlen(httpurl);
|
||||
if (mirror_length > MAX_MIRROR_LENGTH)
|
||||
mirror_length = MAX_MIRROR_LENGTH;
|
||||
|
||||
if (snprintf(serverinfo->httpsource, mirror_length+1, "%s", httpurl) < 0)
|
||||
if (snprintf(netbuffer->u.serverinfo.httpsource, mirror_length+1, "%s", httpurl) < 0)
|
||||
// If there's an encoding error, send nothing, we accept that the above may be truncated
|
||||
strncpy(serverinfo->httpsource, "", mirror_length);
|
||||
strncpy(netbuffer->u.serverinfo.httpsource, "", mirror_length);
|
||||
|
||||
serverinfo->httpsource[MAX_MIRROR_LENGTH-1] = '\0';
|
||||
netbuffer->u.serverinfo.httpsource[MAX_MIRROR_LENGTH-1] = '\0';
|
||||
|
||||
p = PutFileNeeded(0);
|
||||
|
||||
@@ -1773,7 +1769,7 @@ static void SV_SendPlayerInfo(INT32 node)
|
||||
// doesent really matter what we put here lel
|
||||
netbuffer->u.playerinfo[0].score = LONG(42069);
|
||||
netbuffer->u.playerinfo[0].timeinserver = SHORT(42069);
|
||||
netbuffer->u.playerinfo[0].skin = (skinnum_t)1; // no clue wtf skin 1 is, tails maybe?
|
||||
netbuffer->u.playerinfo[0].skin = (UINT8)1; // no clue wtf skin 1 is, tails maybe?
|
||||
|
||||
netbuffer->u.playerinfo[0].data = 0;
|
||||
|
||||
@@ -1818,11 +1814,11 @@ static void SV_SendPlayerInfo(INT32 node)
|
||||
|
||||
netbuffer->u.playerinfo[i].score = LONG(players[i].score);
|
||||
netbuffer->u.playerinfo[i].timeinserver = SHORT((UINT16)(players[i].jointime / TICRATE));
|
||||
netbuffer->u.playerinfo[i].skin = (skinnum_t)players[i].skin;
|
||||
netbuffer->u.playerinfo[i].skin = (UINT8)players[i].skin;
|
||||
|
||||
// Extra data
|
||||
// Kart has extra skincolors, so we can't use this
|
||||
//netbuffer->u.playerinfo[i].data = 0;
|
||||
//netbuffer->u.playerinfo[i].data = 0; //netbuffer->u.playerinfo[i].data = players[i].skincolor;
|
||||
|
||||
// well why not, we only got like 100 of these?
|
||||
netbuffer->u.playerinfo[i].data = players[i].skincolor;
|
||||
@@ -1928,10 +1924,8 @@ static void SV_SendMapIcon(INT32 node)
|
||||
*/
|
||||
static boolean SV_SendServerConfig(INT32 node)
|
||||
{
|
||||
#ifndef PHOBOS_BUILD
|
||||
INT32 i;
|
||||
UINT8 *p, *op;
|
||||
#endif
|
||||
boolean waspacketsent;
|
||||
|
||||
doomdata_t *netbuffer = DOOMCOM_DATA(doomcom);
|
||||
@@ -1949,7 +1943,6 @@ static boolean SV_SendServerConfig(INT32 node)
|
||||
netbuffer->u.servercfg.gametype = (UINT8)gametype;
|
||||
netbuffer->u.servercfg.modifiedgame = (UINT8)modifiedgame;
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
// we fill these structs with FFs so that any players not in game get sent as 0xFFFF
|
||||
// which is nice and easy for us to detect
|
||||
memset(netbuffer->u.servercfg.playerskins, 0xFF, sizeof(netbuffer->u.servercfg.playerskins));
|
||||
@@ -1965,7 +1958,6 @@ static boolean SV_SendServerConfig(INT32 node)
|
||||
netbuffer->u.servercfg.playerskins[i] = (UINT8)players[i].skin;
|
||||
netbuffer->u.servercfg.playercolor[i] = (UINT8)players[i].skincolor;
|
||||
}
|
||||
#endif
|
||||
|
||||
netbuffer->u.servercfg.maxplayer = (UINT8)(min((dedicated ? MAXPLAYERS-1 : MAXPLAYERS), cv_maxplayers.value));
|
||||
netbuffer->u.servercfg.allownewplayer = cv_allownewplayer.value;
|
||||
@@ -1973,16 +1965,12 @@ static boolean SV_SendServerConfig(INT32 node)
|
||||
|
||||
memcpy(netbuffer->u.servercfg.server_context, server_context, 8);
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
const size_t len = sizeof(serverconfig_pak);
|
||||
#else
|
||||
op = p = netbuffer->u.servercfg.varlengthinputs;
|
||||
|
||||
CV_SavePlayerNames(&p);
|
||||
CV_SaveNetVars(&p, false);
|
||||
|
||||
const size_t len = sizeof (serverconfig_pak) + (size_t)(p - op);
|
||||
#endif
|
||||
|
||||
#ifdef DEBUGFILE
|
||||
if (debugfile)
|
||||
@@ -2106,7 +2094,7 @@ static void SV_SavedGame(void)
|
||||
if (!cv_dumpconsistency.value)
|
||||
return;
|
||||
|
||||
snprintf(tmpsave, sizeof(tmpsave), "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
|
||||
// first save it in a malloced buffer
|
||||
save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
|
||||
@@ -2144,7 +2132,7 @@ static void CL_LoadReceivedSavegame(boolean reloading)
|
||||
size_t length, decompressedlen;
|
||||
char tmpsave[264];
|
||||
|
||||
snprintf(tmpsave, sizeof(tmpsave), "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
|
||||
length = FIL_ReadFile(tmpsave, &save.buffer);
|
||||
|
||||
@@ -2223,7 +2211,7 @@ static void CL_ReloadReceivedSavegame(void)
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
LUA_InvalidatePlayer(&players[i]);
|
||||
snprintf(player_names[i], MAXPLAYERNAME+1, "Player %d", i + 1);
|
||||
sprintf(player_names[i], "Player %d", i + 1);
|
||||
}
|
||||
|
||||
CL_LoadReceivedSavegame(true);
|
||||
@@ -2959,7 +2947,7 @@ static void CL_ConnectToServer(void)
|
||||
tic_t asksent;
|
||||
char tmpsave[264];
|
||||
|
||||
snprintf(tmpsave, sizeof(tmpsave), "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
|
||||
filedownload.current = -1;
|
||||
cl_mode = CL_SEARCHING;
|
||||
@@ -3347,7 +3335,6 @@ static void Command_connect(void)
|
||||
return;
|
||||
}
|
||||
|
||||
// StarManiaKG: allow us to join servers from anywhere at any time //
|
||||
if (Playing() || demo.title || demo.playback)
|
||||
{
|
||||
if (demo.title || demo.playback)
|
||||
@@ -3366,9 +3353,7 @@ static void Command_connect(void)
|
||||
D_StartTitle();
|
||||
}
|
||||
else
|
||||
{
|
||||
M_ClearMenus(true); // close the menus
|
||||
}
|
||||
|
||||
// modified game check: no longer handled
|
||||
// we don't request a restart unless the filelist differs
|
||||
@@ -3384,52 +3369,37 @@ static void Command_connect(void)
|
||||
}
|
||||
else
|
||||
{
|
||||
// Get the server node.
|
||||
if (netgame)
|
||||
// used in menu to connect to a server in the list
|
||||
if (netgame && fasticmp(COM_Argv(1), "node"))
|
||||
{
|
||||
// used in menu to connect to a server in the list
|
||||
if (fasticmp(COM_Argv(1), "node"))
|
||||
{
|
||||
servernode = (SINT8)atoi(COM_Argv(2));
|
||||
}
|
||||
else
|
||||
{
|
||||
D_QuitNetGame();
|
||||
CL_Reset();
|
||||
D_StartTitle();
|
||||
}
|
||||
servernode = (SINT8)atoi(COM_Argv(2));
|
||||
}
|
||||
else
|
||||
else if (netgame)
|
||||
{
|
||||
// Standard behaviour
|
||||
if (I_NetOpenSocket)
|
||||
{
|
||||
I_NetOpenSocket();
|
||||
netgame = true;
|
||||
multiplayer = true;
|
||||
CONS_Printf(M_GetText("You cannot connect while in a game. End this game first.\n"));
|
||||
return;
|
||||
}
|
||||
else if (I_NetOpenSocket)
|
||||
{
|
||||
I_NetOpenSocket();
|
||||
netgame = true;
|
||||
multiplayer = true;
|
||||
|
||||
if (fasticmp(COM_Argv(1), "any"))
|
||||
servernode = BROADCASTADDR;
|
||||
else if (I_NetMakeNodewPort)
|
||||
{
|
||||
if (COM_Argc() >= 3) // address AND port
|
||||
servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
|
||||
else // address only, or address:port
|
||||
servernode = I_NetMakeNode(COM_Argv(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
|
||||
D_CloseConnection();
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (fasticmp(COM_Argv(1), "any"))
|
||||
servernode = BROADCASTADDR;
|
||||
else if (I_NetMakeNodewPort && COM_Argc() >= 3)
|
||||
servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
|
||||
else if (I_NetMakeNodewPort)
|
||||
servernode = I_NetMakeNode(COM_Argv(1));
|
||||
else
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
|
||||
CONS_Alert(CONS_ERROR, M_GetText("There is no server identification with this network driver\n"));
|
||||
D_CloseConnection();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
CONS_Alert(CONS_ERROR, M_GetText("There is no network driver\n"));
|
||||
|
||||
// invalid address
|
||||
if (servernode == -1)
|
||||
@@ -3476,7 +3446,6 @@ static void ResetNode(INT32 node);
|
||||
//
|
||||
void CL_ClearPlayer(INT32 playernum)
|
||||
{
|
||||
// Handle mobj_t pointers.
|
||||
if (players[playernum].mo)
|
||||
{
|
||||
// Don't leave a NiGHTS ghost!
|
||||
@@ -3485,7 +3454,6 @@ void CL_ClearPlayer(INT32 playernum)
|
||||
P_RemoveMobj(players[playernum].mo);
|
||||
}
|
||||
|
||||
// Wipe the struct.
|
||||
memset(&players[playernum], 0, sizeof(player_t));
|
||||
}
|
||||
|
||||
@@ -3542,7 +3510,7 @@ void CL_RemovePlayer(INT32 playernum, INT32 reason)
|
||||
player_muted[playernum] = false;
|
||||
|
||||
// Reset the name
|
||||
snprintf(player_names[playernum], MAXPLAYERNAME+1, "Player %d", playernum+1);
|
||||
sprintf(player_names[playernum], "Player %d", playernum+1);
|
||||
|
||||
player_name_changes[playernum] = 0;
|
||||
|
||||
@@ -4504,7 +4472,7 @@ void SV_ResetServer(void)
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
LUA_InvalidatePlayer(&players[i]);
|
||||
snprintf(player_names[i], MAXPLAYERNAME+1, "Player %d", i + 1);
|
||||
sprintf(player_names[i], "Player %d", i + 1);
|
||||
}
|
||||
|
||||
memset(player_name_changes, 0, sizeof(player_name_changes));
|
||||
@@ -5194,7 +5162,7 @@ static void PT_ServerInfo(SINT8 node)
|
||||
const tic_t ticthen = (tic_t)LONG(netbuffer->u.serverinfo.time);
|
||||
const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
|
||||
netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
|
||||
netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = '\0';
|
||||
netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
|
||||
netbuffer->u.serverinfo.application
|
||||
[sizeof netbuffer->u.serverinfo.application - 1] = '\0';
|
||||
memcpy(servername, netbuffer->u.serverinfo.servername, MAXSERVERNAME);
|
||||
@@ -5443,10 +5411,8 @@ static void PT_ServerRefuse(SINT8 node)
|
||||
// Positive response of client join request
|
||||
static void PT_ServerCFG(SINT8 node)
|
||||
{
|
||||
#ifndef PHOBOS_BUILD
|
||||
INT32 j;
|
||||
UINT8 *scp;
|
||||
#endif
|
||||
|
||||
if (server && serverrunning && node != servernode)
|
||||
{ // but wait I thought I'm the server?
|
||||
@@ -5469,10 +5435,8 @@ static void PT_ServerCFG(SINT8 node)
|
||||
if ((gametype = netbuffer->u.servercfg.gametype) >= NUMGAMETYPES)
|
||||
I_Error("Bad gametype %d in cliserv!", gametype);
|
||||
modifiedgame = netbuffer->u.servercfg.modifiedgame;
|
||||
#ifndef PHOBOS_BUILD
|
||||
for (j = 0; j < MAXPLAYERS; j++)
|
||||
adminplayers[j] = netbuffer->u.servercfg.adminplayers[j];
|
||||
#endif
|
||||
memcpy(server_context, netbuffer->u.servercfg.server_context, 8);
|
||||
}
|
||||
|
||||
@@ -5498,7 +5462,6 @@ static void PT_ServerCFG(SINT8 node)
|
||||
SendSaturnInfo(node);
|
||||
#endif
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
memset(playeringame, 0, sizeof(playeringame));
|
||||
|
||||
for (j = 0; j < MAXPLAYERS; j++)
|
||||
@@ -5515,7 +5478,6 @@ static void PT_ServerCFG(SINT8 node)
|
||||
scp = netbuffer->u.servercfg.varlengthinputs;
|
||||
CV_LoadPlayerNames(&scp);
|
||||
scp += CV_LoadNetVars(scp);
|
||||
#endif
|
||||
|
||||
/// \note Wait. What if a Lua script uses some global custom variables synched with the NetVars hook?
|
||||
/// Shouldn't them be downloaded even at intermission time?
|
||||
@@ -5569,7 +5531,7 @@ static void PT_WillResendGamestate(void)
|
||||
|
||||
CONS_Printf(M_GetText("Reloading game state...\n"));
|
||||
|
||||
snprintf(tmpsave, sizeof(tmpsave), "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
|
||||
// Don't get a corrupt savegame error because tmpsave already exists
|
||||
if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
|
||||
@@ -6911,10 +6873,7 @@ boolean TryRunTics(tic_t realtics)
|
||||
DEBFILE(va("============ Running tic %d (local %d)\n", gametic, leveltime));
|
||||
|
||||
if (update_stats)
|
||||
{
|
||||
ps_prevtictime = ps_tictime;
|
||||
PS_START_TIMING(ps_tictime);
|
||||
}
|
||||
|
||||
G_Ticker((gametic % NEWTICRATERATIO) == 0);
|
||||
ExtraDataTicker();
|
||||
@@ -7273,7 +7232,6 @@ static void DedicatedIdleUpdate(INT32 *realtics)
|
||||
{
|
||||
CONS_Printf("DEDICATED: Awakening from idle (Player detected...)\n");
|
||||
}
|
||||
|
||||
dedicatedidle = 0;
|
||||
}
|
||||
}
|
||||
|
||||
+2
-8
@@ -339,17 +339,13 @@ typedef struct
|
||||
UINT8 clientnode;
|
||||
UINT8 gamestate;
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
// 0xFF == not in game; else player skin num
|
||||
UINT8 playerskins[MAXPLAYERS];
|
||||
UINT8 playercolor[MAXPLAYERS];
|
||||
#endif
|
||||
|
||||
UINT8 gametype;
|
||||
UINT8 modifiedgame;
|
||||
#ifndef PHOBOS_BUILD
|
||||
SINT8 adminplayers[MAXPLAYERS]; // Needs to be signed
|
||||
#endif
|
||||
|
||||
char server_context[8]; // Unique context id, generated at server startup.
|
||||
|
||||
@@ -358,9 +354,7 @@ typedef struct
|
||||
boolean allownewplayer;
|
||||
boolean discordinvites;
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
UINT8 varlengthinputs[0]; // Playernames and netvars
|
||||
#endif
|
||||
} ATTRPACK serverconfig_pak;
|
||||
|
||||
typedef struct {
|
||||
@@ -450,7 +444,7 @@ typedef struct
|
||||
char name[MAXPLAYERNAME+1];
|
||||
UINT8 address[4]; // sending another string would run us up against MAXPACKETLENGTH
|
||||
UINT8 team;
|
||||
skinnum_t skin;
|
||||
UINT8 skin;
|
||||
UINT8 data; // Color is first four bits, hasflag, isit and issuper have one bit each, the last is unused.
|
||||
UINT32 score;
|
||||
UINT16 timeinserver; // In seconds.
|
||||
@@ -460,7 +454,7 @@ typedef struct
|
||||
typedef struct
|
||||
{
|
||||
char name[MAXPLAYERNAME+1];
|
||||
skinnum_t skin;
|
||||
UINT8 skin;
|
||||
UINT8 color;
|
||||
UINT32 pflags;
|
||||
UINT32 score;
|
||||
|
||||
+1
-7
@@ -79,7 +79,6 @@
|
||||
#include "core/memory.h"
|
||||
|
||||
#include "lua_script.h"
|
||||
#include "lua_profile.h"
|
||||
|
||||
/* Manually defined asset hashes for non-CMake builds
|
||||
* Last updated 2015 / 05 / 03 - SRB2 v2.1.15 - srb2.srb
|
||||
@@ -645,11 +644,6 @@ static boolean D_Display(void)
|
||||
|
||||
CON_Drawer(); // Ha, i LIED!
|
||||
|
||||
if (cv_lua_profile.value > 0)
|
||||
{
|
||||
LUA_RenderTimers();
|
||||
}
|
||||
|
||||
PS_START_TIMING(ps_swaptime);
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
PS_STOP_TIMING(ps_swaptime);
|
||||
@@ -1245,7 +1239,7 @@ static void IdentifyVersion(void)
|
||||
#endif
|
||||
|
||||
char tempsrb2path[256] = ".";
|
||||
if (I_GetCwd(tempsrb2path, 256) == NULL)
|
||||
if (getcwd(tempsrb2path, 256) == NULL)
|
||||
strcpy(tempsrb2path, ".");
|
||||
|
||||
// get the current directory (possible problem on NT with "." as current dir)
|
||||
|
||||
+1
-3
@@ -1315,9 +1315,7 @@ boolean D_CheckNetGame(void)
|
||||
while (!debugfile && k < MAXPLAYERS)
|
||||
{
|
||||
k++;
|
||||
|
||||
snprintf(filename, sizeof(filename), "debug%d.txt", k);
|
||||
|
||||
sprintf(filename, "debug%d.txt", k);
|
||||
debugfile = fopen(va("%s" PATHSEP "%s", srb2home, filename), "w");
|
||||
}
|
||||
|
||||
|
||||
+14
-93
@@ -47,7 +47,6 @@
|
||||
#include "z_zone.h"
|
||||
#include "lua_script.h"
|
||||
#include "lua_hook.h"
|
||||
#include "lua_profile.h"
|
||||
#include "m_cond.h"
|
||||
#include "m_anigif.h"
|
||||
#include "k_kart.h" // SRB2kart
|
||||
@@ -147,11 +146,6 @@ static void Command_Addfilelocal(void);
|
||||
static void Command_Addfile(void);
|
||||
static void Command_Addskins(void);
|
||||
static void Command_GLocalSkin(void);
|
||||
static void SetPrefcolor(int splitplayer);
|
||||
static void Command_UsePrefcolor(void);
|
||||
static void Command_UsePrefcolor2(void);
|
||||
static void Command_UsePrefcolor3(void);
|
||||
static void Command_UsePrefcolor4(void);
|
||||
static void Command_ListWADS_f(void);
|
||||
static void Command_LocateLump_f(void);
|
||||
static void Command_ListDoomednums_f(void);
|
||||
@@ -440,18 +434,10 @@ consvar_t cv_pointlimit = {"pointlimit", "0", CV_NETVAR|CV_CALL|CV_NOINIT, point
|
||||
static CV_PossibleValue_t timelimit_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_timelimit = {"timelimit", "0", CV_NETVAR|CV_CALL|CV_NOINIT, timelimit_cons_t,
|
||||
TimeLimit_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
#ifdef PHOBOS_BUILD
|
||||
static CV_PossibleValue_t numlaps_cons_t[] = {{1, "MIN"}, {255, "MAX"}, {0, NULL}};
|
||||
#else
|
||||
static CV_PossibleValue_t numlaps_cons_t[] = {{1, "MIN"}, {50, "MAX"}, {0, NULL}};
|
||||
#endif
|
||||
consvar_t cv_numlaps = {"numlaps", "3", CV_NETVAR|CV_CALL|CV_NOINIT, numlaps_cons_t,
|
||||
NumLaps_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
#ifdef PHOBOS_BUILD
|
||||
static CV_PossibleValue_t basenumlaps_cons_t[] = {{1, "MIN"}, {255, "MAX"}, {0, "Map default"}, {0, NULL}};
|
||||
#else
|
||||
static CV_PossibleValue_t basenumlaps_cons_t[] = {{1, "MIN"}, {50, "MAX"}, {0, "Map default"}, {0, NULL}};
|
||||
#endif
|
||||
consvar_t cv_basenumlaps = {"basenumlaps", "Map default", CV_NETVAR|CV_CALL|CV_CHEAT, basenumlaps_cons_t, BaseNumLaps_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_forceskin = {"forceskin", "Off", CV_NETVAR|CV_CALL|CV_CHEAT, Forceskin_cons_t, ForceSkin_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
@@ -520,9 +506,6 @@ static CV_PossibleValue_t ps_descriptor_cons_t[] = {
|
||||
{1, "Average"}, {2, "SD"}, {3, "Minimum"}, {4, "Maximum"}, {0, NULL}};
|
||||
consvar_t cv_ps_descriptor = {"ps_descriptor", "Average", 0, ps_descriptor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
//consvar_t cv_lua_profile = {"lua_profile", "0").values(CV_Unsigned).onchange(lua_profile_OnChange).description("Show hook timings over an average of N tics");
|
||||
consvar_t cv_lua_profile = {"lua_profile", "0", CV_CALL, CV_Unsigned, lua_profile_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// only there to better keep track of it globally
|
||||
consvar_t cv_director = {"director", "Off", CV_HIDEN, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
@@ -617,12 +600,6 @@ void D_RegisterServerCommands(void)
|
||||
Forceskin_cons_t[i].value = 0;
|
||||
Forceskin_cons_t[i].strvalue = NULL;
|
||||
}
|
||||
|
||||
// Set default player names
|
||||
// Monster Iestyn (12/08/19): not sure where else I could have actually put this, but oh well
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
snprintf(player_names[i], sizeof(player_names[i]), "Player %d", 1 + i);
|
||||
|
||||
RegisterNetXCmd(XD_NAMEANDCOLOR, Got_NameAndColor);
|
||||
RegisterNetXCmd(XD_WEAPONPREF, Got_WeaponPref);
|
||||
RegisterNetXCmd(XD_MAP, Got_Mapcmd);
|
||||
@@ -871,11 +848,6 @@ void D_RegisterClientCommands(void)
|
||||
|
||||
COM_AddCommand("localskin", Command_GLocalSkin);
|
||||
|
||||
COM_AddCommand("useprefcolor", Command_UsePrefcolor);
|
||||
COM_AddCommand("useprefcolor2", Command_UsePrefcolor2);
|
||||
COM_AddCommand("useprefcolor3", Command_UsePrefcolor3);
|
||||
COM_AddCommand("useprefcolor4", Command_UsePrefcolor4);
|
||||
|
||||
K_RegisterClientKartStuff(); // SRB2kart
|
||||
|
||||
CV_RegisterVar(&cv_screenshot_option);
|
||||
@@ -962,8 +934,6 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_palette);
|
||||
CV_RegisterVar(&cv_palettenum);
|
||||
|
||||
CV_RegisterVar(&cv_lua_profile);
|
||||
|
||||
// m_menu.c
|
||||
CV_RegisterVar(&cv_chatheight);
|
||||
CV_RegisterVar(&cv_chatwidth);
|
||||
@@ -1306,8 +1276,7 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
|
||||
else if (len == 1) // Agh!
|
||||
{
|
||||
// Last ditch effort...
|
||||
snprintf(name, MAXPLAYERNAME+1, "%d", M_RandomKey(10));
|
||||
|
||||
sprintf(name, "%d", M_RandomKey(10));
|
||||
if (!EnsurePlayerNameIsGood(name, playernum))
|
||||
return false;
|
||||
}
|
||||
@@ -1699,8 +1668,7 @@ static void SendNameAndColor(UINT8 splitplayer)
|
||||
// Finally write out the complete packet and send it off.
|
||||
WRITESTRINGN(p, playername->zstring, MAXPLAYERNAME);
|
||||
WRITEUINT8(p, (UINT8)playercolor->value);
|
||||
WRITESKIN(p, (skinnum_t)playerskin->value);
|
||||
|
||||
WRITEUINT8(p, (UINT8)playerskin->value);
|
||||
SendNetXCmdForPlayer(splitplayer, XD_NAMEANDCOLOR, buf, p - buf);
|
||||
}
|
||||
|
||||
@@ -1708,8 +1676,7 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
|
||||
{
|
||||
player_t *player;
|
||||
char name[MAXPLAYERNAME+1] = {};
|
||||
UINT8 color;
|
||||
skinnum_t skin;
|
||||
UINT8 color, skin;
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (playernum < 0 || playernum > MAXPLAYERS)
|
||||
@@ -1731,7 +1698,7 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
|
||||
|
||||
READSTRINGN(*cp, name, MAXPLAYERNAME);
|
||||
color = READUINT8(*cp);
|
||||
skin = READSKIN(*cp);
|
||||
skin = READUINT8(*cp);
|
||||
|
||||
// set name
|
||||
if (player_name_changes[playernum] < MAXNAMECHANGES)
|
||||
@@ -2363,12 +2330,11 @@ static char *ConcatCommandArgv(int start, int end)
|
||||
if (!p)
|
||||
I_Error("ConcatCommandArgv: Out of memory!\n");
|
||||
|
||||
--end; /* handle the final argument separately */
|
||||
--end;/* handle the final argument separately */
|
||||
|
||||
for (i = start; i < end; ++i)
|
||||
{
|
||||
if (size - (p - final) > 0)
|
||||
p += snprintf(p, size - (p - final), "%s ", COM_Argv(i));
|
||||
p += sprintf(p, "%s ", COM_Argv(i));
|
||||
}
|
||||
|
||||
/* at this point "end" is actually the last argument's position */
|
||||
@@ -2782,11 +2748,11 @@ static void Command_ReplayMarker(void)
|
||||
|
||||
if (title)
|
||||
{
|
||||
snprintf(demo.titlename, sizeof(demo.titlename)-1, "%s [%i:%02d/%.5s]", title, G_TicsToMinutes(adjustedleveltime, false), G_TicsToSeconds(adjustedleveltime), modeattacking ? "Record Attack" : connectedservername);
|
||||
snprintf(demo.titlename, 64, "%s [%i:%02d/%.5s]", title, G_TicsToMinutes(adjustedleveltime, false), G_TicsToSeconds(adjustedleveltime), modeattacking ? "Record Attack" : connectedservername);
|
||||
Z_Free(title);
|
||||
}
|
||||
else
|
||||
snprintf(demo.titlename, sizeof(demo.titlename)-1, "[%i:%02d/%.5s]", G_TicsToMinutes(adjustedleveltime, false), G_TicsToSeconds(adjustedleveltime), modeattacking ? "Record Attack" : connectedservername);
|
||||
snprintf(demo.titlename, 64, "[%i:%02d/%.5s]", G_TicsToMinutes(adjustedleveltime, false), G_TicsToSeconds(adjustedleveltime), modeattacking ? "Record Attack" : connectedservername);
|
||||
|
||||
CONS_Printf("Replay will be saved!\n");
|
||||
}
|
||||
@@ -4344,49 +4310,6 @@ static void Command_GLocalSkin(void)
|
||||
}
|
||||
}
|
||||
|
||||
static void SetPrefcolor(int splitplayer)
|
||||
{
|
||||
// splitscreen
|
||||
if (splitscreen < splitplayer)
|
||||
return;
|
||||
|
||||
const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
|
||||
|
||||
player_t *player = &players[pnum];
|
||||
consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
|
||||
consvar_t *playercolor = colorvars[splitplayer];
|
||||
|
||||
if (skins[player->skin].prefcolor)
|
||||
{
|
||||
CV_SetValue(playercolor, skins[player->skin].prefcolor);
|
||||
CONS_Printf("Set color to %s%s\n", HU_SkinColorToConsoleColor(skins[player->skin].prefcolor), KartColor_Names[skins[player->skin].prefcolor]);
|
||||
}
|
||||
else
|
||||
{
|
||||
CONS_Printf("\x86Your skin has no prefcolor set\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void Command_UsePrefcolor(void)
|
||||
{
|
||||
SetPrefcolor(0);
|
||||
}
|
||||
|
||||
static void Command_UsePrefcolor2(void)
|
||||
{
|
||||
SetPrefcolor(1);
|
||||
}
|
||||
|
||||
static void Command_UsePrefcolor3(void)
|
||||
{
|
||||
SetPrefcolor(2);
|
||||
}
|
||||
|
||||
static void Command_UsePrefcolor4(void)
|
||||
{
|
||||
SetPrefcolor(3);
|
||||
}
|
||||
|
||||
static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum)
|
||||
{
|
||||
char filename[241];
|
||||
@@ -4426,15 +4349,15 @@ static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum)
|
||||
char message[275];
|
||||
|
||||
if (toomany)
|
||||
snprintf(message, sizeof(message), M_GetText("Too many files loaded to add %s\n"), filename);
|
||||
sprintf(message, M_GetText("Too many files loaded to add %s\n"), filename);
|
||||
else if (ncs == FS_NOTFOUND)
|
||||
snprintf(message, sizeof(message), M_GetText("The server doesn't have %s\n"), filename);
|
||||
sprintf(message, M_GetText("The server doesn't have %s\n"), filename);
|
||||
else if (ncs == FS_MD5SUMBAD)
|
||||
snprintf(message, sizeof(message), M_GetText("Checksum mismatch on %s\n"), filename);
|
||||
sprintf(message, M_GetText("Checksum mismatch on %s\n"), filename);
|
||||
else
|
||||
snprintf(message, sizeof(message), M_GetText("Unknown error finding wad file (%s)\n"), filename);
|
||||
sprintf(message, M_GetText("Unknown error finding wad file (%s)\n"), filename);
|
||||
|
||||
CONS_Printf("%s", message);
|
||||
CONS_Printf("%s",message);
|
||||
|
||||
for (j = 0; j < MAXPLAYERS; j++)
|
||||
if (adminplayers[j])
|
||||
@@ -5266,10 +5189,8 @@ static void Command_Mapmd5_f(void)
|
||||
{
|
||||
INT32 i;
|
||||
char md5tmp[33];
|
||||
|
||||
for (i = 0; i < 16; ++i)
|
||||
snprintf(&md5tmp[i*2], 3, "%02x", mapmd5[i]);
|
||||
|
||||
sprintf(&md5tmp[i*2], "%02x", mapmd5[i]);
|
||||
CONS_Printf("%s: %s\n", G_BuildMapName(gamemap), md5tmp);
|
||||
}
|
||||
else
|
||||
|
||||
@@ -189,8 +189,6 @@ extern consvar_t cv_ps_thinkframe_page;
|
||||
extern consvar_t cv_ps_samplesize;
|
||||
extern consvar_t cv_ps_descriptor;
|
||||
|
||||
extern consvar_t cv_lua_profile;
|
||||
|
||||
extern consvar_t cv_director, cv_kartdebugdirector, cv_showdirectorhud;
|
||||
|
||||
extern consvar_t cv_showtrackaddon;
|
||||
|
||||
+4
-6
@@ -299,13 +299,10 @@ boolean CL_CheckDownloadable(void)
|
||||
{
|
||||
INT32 j;
|
||||
char md5tmp[33];
|
||||
|
||||
for (j = 0; j < 16; j++)
|
||||
snprintf(&md5tmp[j*2], 3, "%02x", fileneeded[i].md5sum[j]);
|
||||
|
||||
sprintf(&md5tmp[j*2], "%02x", fileneeded[i].md5sum[j]);
|
||||
CONS_Printf("%s", md5tmp);
|
||||
}
|
||||
|
||||
CONS_Printf("\n");
|
||||
}
|
||||
}
|
||||
@@ -1619,7 +1616,8 @@ static void CURLGetFile(void)
|
||||
#endif
|
||||
}
|
||||
|
||||
HTTP_login *CURLGetLogin(const char *url, HTTP_login ***return_prev_next)
|
||||
HTTP_login *
|
||||
CURLGetLogin (const char *url, HTTP_login ***return_prev_next)
|
||||
{
|
||||
HTTP_login * login;
|
||||
HTTP_login ** prev_next;
|
||||
@@ -1629,7 +1627,7 @@ HTTP_login *CURLGetLogin(const char *url, HTTP_login ***return_prev_next)
|
||||
( login = (*prev_next));
|
||||
prev_next = &login->next
|
||||
){
|
||||
if (fastcmp(login->url, url))
|
||||
if (fastcmp(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 (!fastcmp(buffer, "no"))
|
||||
{
|
||||
fclose(fp);
|
||||
return;
|
||||
}
|
||||
else if (!fastcmp(buffer, exe_path))
|
||||
else if (fastcmp(buffer, exe_path))
|
||||
{
|
||||
// overwrite
|
||||
fclose(fp);
|
||||
|
||||
+27
-49
@@ -542,7 +542,7 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
I_Error("I_OutputMsg: Out of memory!\n");
|
||||
|
||||
va_start(argptr, fmt);
|
||||
vsnprintf(txt, len+1, fmt, argptr);
|
||||
vsprintf(txt, fmt, argptr);
|
||||
va_end(argptr);
|
||||
|
||||
#ifdef HAVE_TTF
|
||||
@@ -550,7 +550,7 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
DEFAULTFONTBGR, DEFAULTFONTBGG, DEFAULTFONTBGB, DEFAULTFONTBGA, txt);
|
||||
#endif
|
||||
|
||||
len = strnlen(txt, len+1);
|
||||
len = strlen(txt);
|
||||
|
||||
#ifdef LOGMESSAGES
|
||||
if (logstream)
|
||||
@@ -968,18 +968,14 @@ void I_Sleep(UINT32 ms)
|
||||
|
||||
void I_SleepDuration(precise_t duration)
|
||||
{
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__) || defined(__OpenBSD__)
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__)
|
||||
UINT64 precision = I_GetPrecisePrecision();
|
||||
struct timespec ts = {
|
||||
.tv_sec = duration / precision,
|
||||
.tv_nsec = duration * 1000000000 / precision % 1000000000,
|
||||
};
|
||||
int status;
|
||||
#ifdef __OpenBSD__
|
||||
do status = nanosleep(&ts, &ts);
|
||||
#else
|
||||
do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
|
||||
#endif
|
||||
while (status == EINTR);
|
||||
#elif defined (MIN_SLEEP_DURATION_MS)
|
||||
UINT64 precision = I_GetPrecisePrecision();
|
||||
@@ -1057,7 +1053,7 @@ static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_ms
|
||||
sigmsg = ("SIGABRT - SRB2Kart-Saturn was terminated by an abort signal.");
|
||||
break;
|
||||
default:
|
||||
snprintf(signal_msg, 512, "Signal number %d", signal_num);
|
||||
sprintf(signal_msg, "Signal number %d", signal_num);
|
||||
sigmsg = (core_dumped ? "Unknown signal" : signal_msg);
|
||||
break;
|
||||
}
|
||||
@@ -1065,17 +1061,13 @@ static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_ms
|
||||
if (core_dumped)
|
||||
{
|
||||
if (sigmsg)
|
||||
{
|
||||
snprintf(signal_msg, 512, "%s (core dumped)", sigmsg);
|
||||
}
|
||||
sprintf(signal_msg, "%s (core dumped)", sigmsg);
|
||||
else
|
||||
{
|
||||
strcat(signal_msg, " (core dumped)");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf(signal_msg, 512, "%s", sigmsg);
|
||||
sprintf(signal_msg, "%s", sigmsg);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1352,7 +1344,7 @@ FUNCNORETURN static ATTRNORETURN void newsignalhandler_Warn(const char *pr)
|
||||
{
|
||||
char text[128];
|
||||
|
||||
snprintf(text, sizeof(text),
|
||||
snprintf(text, sizeof text,
|
||||
"Error while setting up signal reporting: %s: %s",
|
||||
pr,
|
||||
strerror(errno)
|
||||
@@ -1538,7 +1530,7 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
|
||||
if (errorcount > 20)
|
||||
{
|
||||
va_start(argptr, error);
|
||||
vsnprintf(buffer, sizeof(buffer), error, argptr);
|
||||
vsnprintf(buffer, 8192, error, argptr);
|
||||
va_end(argptr);
|
||||
|
||||
I_OutputMsg("SRB2Kart %s Recursive Error", buffer);
|
||||
@@ -1551,7 +1543,7 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
|
||||
|
||||
// Display error message in the console before we start shutting it down
|
||||
va_start(argptr, error);
|
||||
vsnprintf(buffer, sizeof(buffer), error, argptr);
|
||||
vsnprintf(buffer, 8192, error, argptr);
|
||||
va_end(argptr);
|
||||
I_OutputMsg("\nI_Error(): %s\n", buffer);
|
||||
|
||||
@@ -1772,8 +1764,7 @@ char *I_GetUserName(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(username, sizeof(username), "%s", p);
|
||||
strncpy(username, p, MAXPLAYERNAME);
|
||||
}
|
||||
|
||||
if (!fastcmp(username, ""))
|
||||
@@ -1797,24 +1788,6 @@ INT32 I_mkdir(const char *dirname, INT32 unixright)
|
||||
#endif
|
||||
}
|
||||
|
||||
INT32 I_ChDir(const char *path)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return (SetCurrentDirectoryA(path) ? 0 : -1);
|
||||
#else
|
||||
return chdir(path);
|
||||
#endif
|
||||
}
|
||||
|
||||
char *I_GetCwd(char *buf, size_t size)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return (GetCurrentDirectoryA((DWORD)size, buf) ? buf : NULL);
|
||||
#else
|
||||
return getcwd(buf, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
return getenv(name);
|
||||
@@ -1847,23 +1820,28 @@ const char *I_ClipboardPaste(void)
|
||||
*/
|
||||
static boolean isWadPathOk(const char *path)
|
||||
{
|
||||
char wad3path[256];
|
||||
char *wad3path = (char*)(malloc(256));
|
||||
|
||||
snprintf(wad3path, sizeof(wad3path), pandf, path, WADKEYWORD);
|
||||
if (!wad3path)
|
||||
return false;
|
||||
|
||||
sprintf(wad3path, pandf, path, WADKEYWORD);
|
||||
|
||||
if (FIL_ReadFileOK(wad3path))
|
||||
{
|
||||
free(wad3path);
|
||||
return true;
|
||||
}
|
||||
|
||||
free(wad3path);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void pathonly(char *s, size_t size)
|
||||
static void pathonly(char *s)
|
||||
{
|
||||
size_t j;
|
||||
|
||||
for (j = strnlen(s, size); j != (size_t)-1; j--)
|
||||
for (j = strlen(s); j != (size_t)-1; j--)
|
||||
{
|
||||
if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
|
||||
{
|
||||
@@ -1890,12 +1868,11 @@ static const char *searchWad(const char *searchDir)
|
||||
static char tempsw[256] = "";
|
||||
filestatus_t fstemp;
|
||||
|
||||
snprintf(tempsw, sizeof(tempsw), "%s", WADKEYWORD);
|
||||
strcpy(tempsw, WADKEYWORD);
|
||||
fstemp = filesearch(tempsw, searchDir, NULL, true, 20);
|
||||
|
||||
if (fstemp == FS_FOUND)
|
||||
{
|
||||
pathonly(tempsw, sizeof(tempsw));
|
||||
pathonly(tempsw);
|
||||
return tempsw;
|
||||
}
|
||||
|
||||
@@ -1933,7 +1910,7 @@ static const char *locateWad(void)
|
||||
|
||||
#ifndef NOCWD
|
||||
// examine current dir
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s", ".");
|
||||
strcpy(returnWadPath, ".");
|
||||
I_OutputMsg(",%s", returnWadPath);
|
||||
if (isWadPathOk(returnWadPath))
|
||||
return NULL;
|
||||
@@ -1945,7 +1922,7 @@ static const char *locateWad(void)
|
||||
// examine user jart directory
|
||||
if ((envstr = I_GetEnv("HOME")) != NULL)
|
||||
{
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s" PATHSEP DEFAULTDIR, envstr);
|
||||
sprintf(returnWadPath, "%s" PATHSEP DEFAULTDIR, envstr);
|
||||
CHECKWADPATH(returnWadPath);
|
||||
}
|
||||
#endif
|
||||
@@ -1959,7 +1936,7 @@ static const char *locateWad(void)
|
||||
// examine default dirs
|
||||
for (i = 0; wadDefaultPaths[i]; i++)
|
||||
{
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s", wadDefaultPaths[i]);
|
||||
strcpy(returnWadPath, wadDefaultPaths[i]);
|
||||
CHECKWADPATH(returnWadPath);
|
||||
}
|
||||
|
||||
@@ -1987,11 +1964,12 @@ const char *I_LocateWad(void)
|
||||
// change to the directory where we found srb2.srb
|
||||
#if defined (_WIN32)
|
||||
waddir = _fullpath(NULL, waddir, MAX_PATH);
|
||||
SetCurrentDirectoryA(waddir);
|
||||
#else
|
||||
waddir = realpath(waddir, NULL);
|
||||
#endif
|
||||
if (waddir == NULL || I_ChDir(waddir) == -1)
|
||||
if (waddir == NULL || chdir(waddir) == -1)
|
||||
I_OutputMsg("Couldn't change working directory\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
return waddir;
|
||||
|
||||
+1
-1
@@ -402,7 +402,7 @@ static void Discordrp_OnChange(void)
|
||||
static void DRPC_GotServerIP(UINT32 address)
|
||||
{
|
||||
const unsigned char * p = (const unsigned char *)&address;
|
||||
snprintf(self_ip, IP_SIZE+1, "%u.%u.%u.%u:%u", p[0], p[1], p[2], p[3], current_port);
|
||||
sprintf(self_ip, "%u.%u.%u.%u:%u", p[0], p[1], p[2], p[3], current_port);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
|
||||
+14
-29
@@ -128,24 +128,10 @@ extern char logfilename[1024];
|
||||
// most interface strings are ignored in development mode.
|
||||
// we use comprevision and compbranch instead.
|
||||
#else
|
||||
#ifdef PHOBOS_BUILD
|
||||
#define VERSION 1 // Game version
|
||||
#define SUBVERSION 69 // more precise version number
|
||||
#else
|
||||
#define VERSION 1 // Game version
|
||||
#define SUBVERSION 6 // more precise version number
|
||||
#endif
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
#define CLIENTNAME "Phobos"
|
||||
#define CLIENTNAMEW L"Phobos"
|
||||
#else
|
||||
#define CLIENTNAME "Saturn"
|
||||
#define CLIENTNAMEW L"Saturn"
|
||||
#endif
|
||||
|
||||
#define VERSIONSTRING CLIENTNAME " v10.1"
|
||||
#define VERSIONSTRINGW CLIENTNAMEW L" v10.1"
|
||||
#define VERSIONSTRING "Saturn v9.3"
|
||||
#define VERSIONSTRINGW L"Saturn v9.3"
|
||||
|
||||
#define SATURN_TESTING // comment out for saturn release builds!
|
||||
|
||||
@@ -616,19 +602,11 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
// None of these that are disabled in the normal build are guaranteed to work perfectly
|
||||
// Compile them at your own risk!
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
// we want 32 players yesss
|
||||
#undef MAXPLAYERS
|
||||
#define MAXPLAYERS 32
|
||||
|
||||
// raise skinlimit to 1024
|
||||
#undef MAXSKINS
|
||||
#define MAXSKINS 1024
|
||||
|
||||
// overwrite some of those
|
||||
// when not compiling in vanilla compat mode
|
||||
#define SATURNJOIN
|
||||
#define SATURNPAK
|
||||
// undefine to enable fixes and features that are not vanilla compatible
|
||||
#define COMPAT_VANILLA
|
||||
// if we build with 32 player (or more!) support we dont need to care vanilla compat
|
||||
#if MAXPLAYERS > 16
|
||||
#undef COMPAT_VANILLA
|
||||
#endif
|
||||
|
||||
//-- SATURN __
|
||||
@@ -695,6 +673,13 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
|
||||
#undef UPDATE_ALERT
|
||||
#endif
|
||||
|
||||
// overwrite some of those
|
||||
// when not compiling in vanilla compat mode
|
||||
#ifndef COMPAT_VANILLA
|
||||
#define SATURNJOIN
|
||||
#define SATURNPAK
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
@@ -42,12 +42,6 @@ extern "C" {
|
||||
#define INT64 int64_t
|
||||
#define UINT64 uint64_t
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
typedef uint16_t skinnum_t;
|
||||
#else
|
||||
typedef uint8_t skinnum_t;
|
||||
#endif
|
||||
|
||||
#ifdef __APPLE_CC__
|
||||
#define DEBUG_LOG
|
||||
#define NOIPX
|
||||
|
||||
+1
-2
@@ -111,8 +111,7 @@ static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum)
|
||||
goto freemask;
|
||||
|
||||
// SRB2Kart: This suddenly triggers ERRORMODE now
|
||||
//snprintf(&lumpname[4], 3, "%.2hu%.2hu", (UINT16)masknum, (UINT16)scrnnum);
|
||||
//lumpname[8] = 0;
|
||||
//sprintf(&lumpname[4], "%.2hu%.2hu", (UINT16)masknum, (UINT16)scrnnum);
|
||||
|
||||
lumpname[4] = '0'+(masknum/10);
|
||||
lumpname[5] = '0'+(masknum%10);
|
||||
|
||||
+31
-33
@@ -1723,11 +1723,11 @@ void G_BeginRecording(void)
|
||||
// Print to a separate temp buffer instead of demo.titlename, so we can use it in M_TextInputSetString
|
||||
if (title)
|
||||
{
|
||||
snprintf(demotitlename, sizeof(demotitlename)-1, "%s - %s", title, modeattacking ? "Time Attack" : connectedservername);
|
||||
snprintf(demotitlename, 64, "%s - %s", title, modeattacking ? "Time Attack" : connectedservername);
|
||||
Z_Free(title);
|
||||
}
|
||||
else
|
||||
snprintf(demotitlename, sizeof(demotitlename)-1, "%s", modeattacking ? "Time Attack" : connectedservername);
|
||||
snprintf(demotitlename, 64, "%s", modeattacking ? "Time Attack" : connectedservername);
|
||||
|
||||
// Init just in case it isn't initialized already
|
||||
M_TextInputInit(&demo.titlenameinput, demo.titlename, sizeof(demo.titlename));
|
||||
@@ -2212,7 +2212,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Failed to read file '%s'.\n"), pdemo->filepath);
|
||||
pdemo->type = MD_INVALID;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2222,7 +2222,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is not a SRB2Kart replay file.\n"), pdemo->filepath);
|
||||
pdemo->type = MD_INVALID;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2247,14 +2247,14 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
#ifdef DEMO_COMPAT_100
|
||||
case 0x0001:
|
||||
pdemo->type = MD_OUTDATED;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "Legacy Replay");
|
||||
sprintf(pdemo->title, "Legacy Replay");
|
||||
break;
|
||||
#endif
|
||||
// too old, cannot support.
|
||||
default:
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is an incompatible replay format and cannot be played.\n"), pdemo->filepath);
|
||||
pdemo->type = MD_INVALID;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2267,7 +2267,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is the wrong type of recording and cannot be played.\n"), pdemo->filepath);
|
||||
pdemo->type = MD_INVALID;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2288,7 +2288,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is a legacy multiplayer replay and cannot be played.\n"), pdemo->filepath);
|
||||
pdemo->type = MD_INVALID;
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
@@ -2335,7 +2335,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
while (READUINT8(extrainfo_p) == DW_STANDING) // Assume standings are always first in the extrainfo
|
||||
{
|
||||
INT32 i;
|
||||
char temp[17];
|
||||
char temp[16];
|
||||
|
||||
pdemo->standings[count].ranking = READUINT8(extrainfo_p);
|
||||
|
||||
@@ -2345,7 +2345,6 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
|
||||
// Skin
|
||||
memcpy(temp, extrainfo_p, 16);
|
||||
temp[16] = '\0';
|
||||
extrainfo_p += 16;
|
||||
pdemo->standings[count].skin = UINT8_MAX;
|
||||
|
||||
@@ -2360,7 +2359,6 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
|
||||
|
||||
// Color
|
||||
memcpy(temp, extrainfo_p, 16);
|
||||
temp[16] = '\0';
|
||||
extrainfo_p += 16;
|
||||
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
@@ -2524,7 +2522,7 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
|
||||
if (!handle)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Failed to read file '%s'.\n"), pdemo->filepath);
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2536,7 +2534,7 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
|
||||
if (count < 96 || memcmp(info_p, DEMOHEADER, 12))
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is not a SRB2Kart replay file.\n"), pdemo->filepath);
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2565,13 +2563,13 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
|
||||
break;
|
||||
#ifdef DEMO_COMPAT_100
|
||||
case 0x0001:
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "Legacy Replay");
|
||||
sprintf(pdemo->title, "Legacy Replay");
|
||||
break;
|
||||
#endif
|
||||
// too old, cannot support.
|
||||
default:
|
||||
CONS_Alert(CONS_ERROR, M_GetText("%s is an incompatible replay format and cannot be played.\n"), pdemo->filepath);
|
||||
snprintf(pdemo->title, sizeof(pdemo->title), "INVALID REPLAY");
|
||||
sprintf(pdemo->title, "INVALID REPLAY");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2635,7 +2633,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
//FIL_DefaultExtension(defdemoname, ".lmp");
|
||||
if (!FIL_ReadFile(defdemoname, &demobuf.buffer))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("Failed to read file '%s'.\n"), defdemoname);
|
||||
snprintf(msg, 1024, M_GetText("Failed to read file '%s'.\n"), defdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
gameaction = ga_nothing;
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
@@ -2647,7 +2645,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// load demo resource from WAD
|
||||
else if ((l = W_CheckNumForName(defdemoname)) == LUMPERROR)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("Failed to read lump '%s'.\n"), defdemoname);
|
||||
snprintf(msg, 1024, M_GetText("Failed to read lump '%s'.\n"), defdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
gameaction = ga_nothing;
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
@@ -2668,7 +2666,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
|
||||
if (memcmp(demobuf.p, DEMOHEADER, 12))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is not a SRB2Kart replay file.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is not a SRB2Kart replay file.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2694,7 +2692,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
#endif
|
||||
// too old, cannot support.
|
||||
default:
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is an incompatible replay format and cannot be played.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is an incompatible replay format and cannot be played.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2705,7 +2703,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
|
||||
if (memcmp(demobuf.p, "PLAY", 4))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is the wrong type of recording and cannot be played.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is the wrong type of recording and cannot be played.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2722,7 +2720,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
{
|
||||
if (demoflags & DF_MULTIPLAYER)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is an alpha multiplayer replay and cannot be played.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is an alpha multiplayer replay and cannot be played.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2749,31 +2747,31 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
switch (error)
|
||||
{
|
||||
case DFILE_ERROR_NOTLOADED:
|
||||
snprintf(msg, sizeof(msg),
|
||||
snprintf(msg, 1024,
|
||||
"Required files for this demo are not loaded.\n\nUse\n\"playdemo %s -addfiles\"\nto load them and play the demo.\n",
|
||||
pdemoname);
|
||||
break;
|
||||
|
||||
case DFILE_ERROR_OUTOFORDER:
|
||||
snprintf(msg, sizeof(msg),
|
||||
snprintf(msg, 1024,
|
||||
"Required files for this demo are loaded out of order.\n\nUse\n\"playdemo %s -force\"\nto play the demo anyway.\n",
|
||||
pdemoname);
|
||||
break;
|
||||
|
||||
case DFILE_ERROR_INCOMPLETEOUTOFORDER:
|
||||
snprintf(msg, sizeof(msg),
|
||||
snprintf(msg, 1024,
|
||||
"Required files for this demo are not loaded, and some are out of order.\n\nUse\n\"playdemo %s -addfiles\"\nto load needed files and play the demo.\n",
|
||||
pdemoname);
|
||||
break;
|
||||
|
||||
case DFILE_ERROR_CANNOTLOAD:
|
||||
snprintf(msg, sizeof(msg),
|
||||
snprintf(msg, 1024,
|
||||
"Required files for this demo cannot be loaded.\n\nUse\n\"playdemo %s -force\"\nto play the demo anyway.\n",
|
||||
pdemoname);
|
||||
break;
|
||||
|
||||
case DFILE_ERROR_EXTRAFILES:
|
||||
snprintf(msg, sizeof(msg),
|
||||
snprintf(msg, 1024,
|
||||
"You have additional files loaded beyond the demo's file list.\n\nUse\n\"playdemo %s -force\"\nto play the demo anyway.\n",
|
||||
pdemoname);
|
||||
break;
|
||||
@@ -2823,7 +2821,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// ...*map* not loaded?
|
||||
if (!gamemap || (gamemap > NUMMAPS) || (W_CheckNumForName(G_BuildMapName(gamemap)) == LUMPERROR))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2855,7 +2853,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// Skin not loaded?
|
||||
if (!SetPlayerSkin(0, skin))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s features a character that is not currently loaded.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s features a character that is not currently loaded.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2865,7 +2863,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// ...*map* not loaded?
|
||||
if (!gamemap || (gamemap > NUMMAPS) || !mapheaderinfo[gamemap-1] || !(mapheaderinfo[gamemap-1]->menuflags & LF2_EXISTSHACK))
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2888,7 +2886,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// Sigh ... it's an empty demo.
|
||||
if (*demobuf.p == DEMOMARKER)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s contains no data to be played.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s contains no data to be played.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2926,7 +2924,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
// Sigh ... it's an empty demo.
|
||||
if (*demobuf.p == DEMOMARKER)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s contains no data to be played.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s contains no data to be played.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2975,7 +2973,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
|
||||
if (modeattacking)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is a Record Attack replay with spectators, and is thus invalid.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is a Record Attack replay with spectators, and is thus invalid.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
@@ -2987,7 +2985,7 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
|
||||
if (modeattacking && numslots > 1)
|
||||
{
|
||||
snprintf(msg, sizeof(msg), M_GetText("%s is a Record Attack replay with multiple players, and is thus invalid.\n"), pdemoname);
|
||||
snprintf(msg, 1024, M_GetText("%s is a Record Attack replay with multiple players, and is thus invalid.\n"), pdemoname);
|
||||
CONS_Alert(CONS_ERROR, "%s", msg);
|
||||
M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
|
||||
G_ResetDemoPlayback();
|
||||
|
||||
+1
-2
@@ -82,8 +82,7 @@ typedef struct menudemo_s {
|
||||
struct {
|
||||
UINT8 ranking;
|
||||
char name[17];
|
||||
skinnum_t skin;
|
||||
UINT8 color;
|
||||
UINT8 skin, color;
|
||||
UINT32 timeorscore;
|
||||
} standings[MAXPLAYERS];
|
||||
} menudemo_t;
|
||||
|
||||
+35
-24
@@ -63,7 +63,7 @@ gameaction_t gameaction = 0;
|
||||
gamestate_t gamestate = GS_NULL;
|
||||
|
||||
boolean botingame = false;
|
||||
skinnum_t botskin = 0;
|
||||
UINT8 botskin = 0;
|
||||
UINT8 botcolor = 0;
|
||||
|
||||
// SRB2kart
|
||||
@@ -453,13 +453,34 @@ consvar_t cv_driftsparkpulse = {"driftsparkpulse", "1.4", CV_FLOAT | CV_SAVE, dr
|
||||
static CV_PossibleValue_t cechotoggle_t[] = {{0, "Off"}, {1, "On"}, {2, "Console"}, {0, NULL}};
|
||||
consvar_t cv_cechotoggle = {"show_cecho", "On", CV_SAVE, cechotoggle_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
#error "please update player_name table using the new value for MAXPLAYERS"
|
||||
#endif
|
||||
|
||||
#ifdef SEENAMES
|
||||
player_t *seenplayer = NULL; // player we're aiming at right now
|
||||
#endif
|
||||
|
||||
// now automatically allocated in D_RegisterServerCommands
|
||||
// so that it doesn't have to be updated depending on the value of MAXPLAYERS
|
||||
char player_names[MAXPLAYERS][MAXPLAYERNAME+1];
|
||||
char player_names[MAXPLAYERS][MAXPLAYERNAME+1] =
|
||||
{
|
||||
"Player 1",
|
||||
"Player 2",
|
||||
"Player 3",
|
||||
"Player 4",
|
||||
"Player 5",
|
||||
"Player 6",
|
||||
"Player 7",
|
||||
"Player 8",
|
||||
"Player 9",
|
||||
"Player 10",
|
||||
"Player 11",
|
||||
"Player 12",
|
||||
"Player 13",
|
||||
"Player 14",
|
||||
"Player 15",
|
||||
"Player 16"
|
||||
}; // SRB2kart - removed Players 17 through 32
|
||||
|
||||
INT32 player_name_changes[MAXPLAYERS] = {};
|
||||
|
||||
INT16 rw_maximums[NUM_WEAPONS] =
|
||||
@@ -604,18 +625,14 @@ const char *G_BuildMapName(INT32 map)
|
||||
}
|
||||
|
||||
if (map < 100 && map >= 0) // ...but why use signed integer in first place? idk but this prevents warning (and potential buffer overflow lol)
|
||||
{
|
||||
snprintf(&mapname[3], sizeof(mapname)-3, "%.2d", map);
|
||||
}
|
||||
sprintf(&mapname[3], "%.2d", map);
|
||||
else
|
||||
{
|
||||
mapname[3] = (char)('A' + (char)((map - 100) / 36));
|
||||
|
||||
if ((map - 100) % 36 < 10)
|
||||
mapname[4] = (char)('0' + (char)((map - 100) % 36));
|
||||
else
|
||||
mapname[4] = (char)('A' + (char)((map - 100) % 36) - 10);
|
||||
|
||||
mapname[5] = '\0';
|
||||
}
|
||||
|
||||
@@ -2630,18 +2647,12 @@ mapthing_t *G_FindRaceStart(INT32 playernum)
|
||||
// Just spawn there.
|
||||
//return playerstarts[0];
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
//this section courtesy of fickle - v1.1 battle royale
|
||||
// screw collision chex
|
||||
return playerstarts[pos % numcoopstarts];
|
||||
#else
|
||||
if (P_IsLocalPlayerNum(playernum))
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "Could not spawn at any Race starts!\n");
|
||||
}
|
||||
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (P_IsLocalPlayerNum(playernum))
|
||||
@@ -3776,7 +3787,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
|
||||
startonmapnum = mapoverride;
|
||||
#endif
|
||||
|
||||
snprintf(savename, sizeof(savename), savegamename, slot);
|
||||
sprintf(savename, savegamename, slot);
|
||||
|
||||
length = FIL_ReadFile(savename, &save.buffer);
|
||||
if (!length)
|
||||
@@ -3788,7 +3799,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
|
||||
save.p = save.buffer;
|
||||
|
||||
memset(vcheck, 0, sizeof (vcheck));
|
||||
snprintf(vcheck, sizeof(vcheck), "version %d", VERSION);
|
||||
sprintf(vcheck, "version %d", VERSION);
|
||||
|
||||
if (!fastcmp((const char *)save.p, (const char *)vcheck))
|
||||
{
|
||||
@@ -3854,8 +3865,8 @@ void G_SaveGame(UINT32 savegameslot)
|
||||
const char *backup;
|
||||
savebuffer_t save = {};
|
||||
|
||||
snprintf(savename, sizeof(savename), savegamename, savegameslot);
|
||||
backup = va("%s", savename);
|
||||
sprintf(savename, savegamename, savegameslot);
|
||||
backup = va("%s",savename);
|
||||
|
||||
// save during evaluation or credits? game's over, folks!
|
||||
if (gamestate == GS_CREDITS || gamestate == GS_EVALUATION)
|
||||
@@ -3873,8 +3884,8 @@ void G_SaveGame(UINT32 savegameslot)
|
||||
return;
|
||||
}
|
||||
|
||||
memset(name, 0, sizeof(name));
|
||||
snprintf(name, sizeof(name), "version %d", VERSION);
|
||||
memset(name, 0, sizeof (name));
|
||||
sprintf(name, "version %d", VERSION);
|
||||
WRITEMEM(save.p, name, VERSIONSIZE);
|
||||
|
||||
P_SaveGame(&save);
|
||||
@@ -4103,12 +4114,12 @@ char *G_BuildMapTitle(INT32 mapnum)
|
||||
if (!title)
|
||||
return NULL;
|
||||
|
||||
snprintf(title, len, "%s", mapheaderinfo[mapnum-1]->lvlttl);
|
||||
sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl);
|
||||
|
||||
if (zonetext)
|
||||
snprintf(title + strlen(title), len - strlen(title), " %s", zonetext);
|
||||
sprintf(title + strlen(title), " %s", zonetext);
|
||||
if (actnum)
|
||||
snprintf(title + strlen(title), len - strlen(title), " %s", actnum);
|
||||
sprintf(title + strlen(title), " %s", actnum);
|
||||
}
|
||||
|
||||
return title;
|
||||
|
||||
+1
-2
@@ -1250,8 +1250,7 @@ const char *G_KeynumToString(INT32 keynum)
|
||||
return keynames[j].name;
|
||||
|
||||
// create a name for unknown keys
|
||||
snprintf(keynamestr, sizeof(keynamestr), "KEY%d", keynum);
|
||||
|
||||
sprintf(keynamestr, "KEY%d", keynum);
|
||||
return keynamestr;
|
||||
}
|
||||
|
||||
|
||||
+1
-2
@@ -55,7 +55,6 @@ extern gamestate_t gamestate;
|
||||
extern gameaction_t gameaction;
|
||||
|
||||
extern boolean botingame;
|
||||
extern skinnum_t botskin;
|
||||
extern UINT8 botcolor;
|
||||
extern UINT8 botskin, botcolor;
|
||||
|
||||
#endif //__G_STATE__
|
||||
@@ -35,7 +35,7 @@ static int finalVertexArrayAllocSize = 65536;
|
||||
// not gonna use this for now, just sort by color and change state when it changes
|
||||
// later maybe when using vertex attributes if it's needed
|
||||
|
||||
static PolygonArrayEntry* polygonArray = NULL; // contains the polygon data from DrawPolygon, waiting to be processed
|
||||
static PolygonArrayEntry* polygonArray = NULL ;// contains the polygon data from DrawPolygon, waiting to be processed
|
||||
static PolygonArrayEntry **polygonArraySorted = NULL; // contains sorted pointers to polygonArray
|
||||
static int polygonArraySize = 0;
|
||||
static int polygonArrayAllocSize = 65536;
|
||||
@@ -171,8 +171,8 @@ static int comparePolygons(const void *p1, const void *p2)
|
||||
|
||||
// special case with signedness to prevent overflowing
|
||||
// FIXME: check for prediction slowdowns!
|
||||
const int shader1 = (poly1->hash & 0x80000000) ? -1 : poly1->shader;
|
||||
const int shader2 = (poly2->hash & 0x80000000) ? -1 : poly2->shader;
|
||||
const int shader1 = poly1->hash & 0x80000000 ? -1 : poly1->shader;
|
||||
const int shader2 = poly2->hash & 0x80000000 ? -1 : poly2->shader;
|
||||
|
||||
// skywalls and horizon lines must retain their order for horizon lines to work
|
||||
if (shader1 == -1 && shader2 == -1)
|
||||
@@ -214,8 +214,8 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
|
||||
const PolygonArrayEntry *poly1 = *(PolygonArrayEntry *const *)p1;
|
||||
const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
|
||||
|
||||
const GLMipmap_t *texture1 = (poly1->hash & 0x80000000) ? NULL : poly1->texture;
|
||||
const GLMipmap_t *texture2 = (poly2->hash & 0x80000000) ? NULL : poly2->texture;
|
||||
const GLMipmap_t *texture1 = poly1->hash & 0x80000000 ? NULL : poly1->texture;
|
||||
const GLMipmap_t *texture2 = poly2->hash & 0x80000000 ? NULL : poly2->texture;
|
||||
|
||||
// skywalls and horizon lines must retain their order for horizon lines to work
|
||||
if (!texture1 && !texture2)
|
||||
|
||||
@@ -346,15 +346,15 @@ static void SplitPoly (fdivline_t *dlnp, // splitting parametric line
|
||||
}
|
||||
|
||||
// checks if any line is a portal or horizonline, for optimization
|
||||
static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_t *line)
|
||||
static inline void CheckForPortalsAndHorizonLines(seg_t *lseg, const line_t *line)
|
||||
{
|
||||
// portal check
|
||||
if (!gl_maphasportals && firstside && line->special == PORTALSPECIAL)
|
||||
if (!gl_maphasportals && lseg->side == 0 && line->special == PORTALSPECIAL)
|
||||
{
|
||||
// Find the other side!
|
||||
INT32 line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->tag, -1);
|
||||
|
||||
if (line2 >= 0 && line == &lines[line2])
|
||||
if (line == &lines[line2])
|
||||
line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->tag, line2);
|
||||
|
||||
if (line2 >= 0) // found it!
|
||||
@@ -397,7 +397,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
|
||||
if (!line)
|
||||
continue;
|
||||
|
||||
CheckForPortalsAndHorizonLines(lseg->side == 0, line);
|
||||
CheckForPortalsAndHorizonLines(lseg, line);
|
||||
|
||||
if (line->sidenum[1] != NO_INDEX)
|
||||
{
|
||||
@@ -581,8 +581,7 @@ static void loading_status(void)
|
||||
|
||||
I_OsPolling();
|
||||
CON_Drawer();
|
||||
snprintf(s, sizeof(s), "%d%%", (++ls_percent)<<1);
|
||||
|
||||
sprintf(s, "%d%%", (++ls_percent)<<1);
|
||||
x = BASEVIDWIDTH/2;
|
||||
y = BASEVIDHEIGHT/2;
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol); // Black background to match fade in effect
|
||||
|
||||
+3
-22
@@ -555,8 +555,7 @@ static void HWR_FreePatchCache(boolean freeall)
|
||||
callback = FreeColormapsCallback;
|
||||
|
||||
//Z_IterateTags(PU_PATCH, PU_PATCH_ROTATED, callback);
|
||||
//Z_IterateTags(PU_PATCH, PU_PATCH_LOWPRIORITY, callback); // we dont really need to free low priority patches here as P_FreeLevelState takes care of them
|
||||
Z_IterateTag(PU_PATCH, callback);
|
||||
Z_IterateTags(PU_PATCH, PU_PATCH, callback);
|
||||
Z_IterateTags(PU_SPRITE, PU_HUDGFX, callback);
|
||||
}
|
||||
|
||||
@@ -624,26 +623,13 @@ static void HWR_PrecacheLevelFlats(void)
|
||||
{
|
||||
// lookup for flats that may´ve been already loaded
|
||||
flatcheck flatpresent;
|
||||
size_t i;
|
||||
#if 0
|
||||
size_t j;
|
||||
#endif
|
||||
size_t i, j;
|
||||
INT32 k;
|
||||
|
||||
// this kinda messes up encore remapping behavior at times
|
||||
// so just disable it for now ig
|
||||
#ifdef GLENCORE
|
||||
if (encoremap)
|
||||
{
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
flatcheck_init(&flatpresent);
|
||||
flatcheck_reserve(&flatpresent, numlevelflats);
|
||||
|
||||
// special case for encore
|
||||
#if 0
|
||||
#ifdef GLENCORE
|
||||
if (encoremap)
|
||||
{
|
||||
@@ -683,7 +669,6 @@ static void HWR_PrecacheLevelFlats(void)
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
// on non encore we have it simple
|
||||
@@ -1013,7 +998,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
|
||||
const char *flatname = W_CheckNameForNum(flatlumpnum);
|
||||
|
||||
// hack for gba rainbow roads cyan floors
|
||||
if (UNLIKELY(flatname && memcmp(flatname, "GBA_RRF5", 8) == 0 && flatname[8] == 0))
|
||||
if (UNLIKELY(memcmp(flatname, "GBA_RRF5", 8) == 0 && flatname[8] == 0))
|
||||
{
|
||||
glMipmap->flags &= ~TF_CHROMAKEYED;
|
||||
}
|
||||
@@ -1329,7 +1314,6 @@ void HWR_SetPalette(RGBA_t *palette)
|
||||
crushed_palette[i].s.blue = (UINT8)(fblue / 31.0f * 255.0f);
|
||||
crushed_palette[i].s.alpha = 255;
|
||||
}
|
||||
|
||||
GL_SetScreenPalette(crushed_palette);
|
||||
}
|
||||
else
|
||||
@@ -1407,7 +1391,6 @@ void HWR_SetMapPalette(void)
|
||||
I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
|
||||
|
||||
RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
|
||||
|
||||
// we got the RGB palette now, but we need it in RGBA format.
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
@@ -1416,7 +1399,6 @@ void HWR_SetMapPalette(void)
|
||||
RGBA_converted[i].s.blue = *(RGB_data++);
|
||||
RGBA_converted[i].s.alpha = 255;
|
||||
}
|
||||
|
||||
palette = RGBA_converted;
|
||||
}
|
||||
|
||||
@@ -1424,7 +1406,6 @@ void HWR_SetMapPalette(void)
|
||||
if (memcmp(mapPalette, palette, sizeof(mapPalette)))
|
||||
{
|
||||
memcpy(mapPalette, palette, sizeof(mapPalette));
|
||||
|
||||
// in palette rendering mode, this means that all rgba textures now have wrong colors
|
||||
// and the lookup table is outdated
|
||||
HWR_SetPaletteLookup(mapPalette);
|
||||
|
||||
+29
-39
@@ -514,7 +514,7 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
|
||||
const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);
|
||||
|
||||
finallight += offset;
|
||||
finallight = CLAMP(finallight, 0, 255);
|
||||
finallight = CLAMP(finallight, 0 , 255);
|
||||
}
|
||||
|
||||
return (FUINT)finallight;
|
||||
@@ -532,7 +532,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
|
||||
const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);
|
||||
|
||||
finallight += (fof ? -offset : offset);
|
||||
finallight = CLAMP(finallight, 0, 255);
|
||||
finallight = CLAMP(finallight, 0 , 255);
|
||||
}
|
||||
|
||||
return (FUINT)finallight;
|
||||
@@ -1101,8 +1101,8 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
|
||||
|
||||
// Found a break
|
||||
// The heights are clamped to ensure the polygon doesn't cross itself.
|
||||
bot = std::min(std::max(bheight, realbot), top);
|
||||
endbot = std::min(std::max(endbheight, endrealbot), endtop);
|
||||
bot = std::clamp(bheight, realbot, top);
|
||||
endbot = std::clamp(endbheight, endrealbot, endtop);
|
||||
|
||||
Surf->PolyColor.s.alpha = alpha;
|
||||
|
||||
@@ -1236,7 +1236,7 @@ static void HWR_DrawSkyWall(FOutVector *wallVerts, FSurfaceInfo *Surf)
|
||||
// Returns true if the midtexture is visible, and false if... it isn't...
|
||||
static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
|
||||
{
|
||||
FUINT blendmode = PF_Masked;
|
||||
FUINT blendmode = PF_Masked | PF_Translucent;
|
||||
|
||||
pSurf->PolyColor.s.alpha = 0xFF;
|
||||
|
||||
@@ -2306,7 +2306,7 @@ static inline void DoAddLine(seg_t* line, angle_t angle1, angle_t angle2)
|
||||
// Find the other side!
|
||||
INT32 line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->linedef->tag, -1);
|
||||
|
||||
if (line2 >= 0 && line->linedef == &lines[line2])
|
||||
if (line->linedef == &lines[line2])
|
||||
line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->linedef->tag, line2);
|
||||
|
||||
if (line2 >= 0) // found it!
|
||||
@@ -2662,13 +2662,11 @@ static void HWR_AddPolyObjectPlanes(void)
|
||||
|
||||
polyobjsector = po_ptrs[i]->lines[0]->backsector; // the in-level polyobject sector
|
||||
|
||||
if (polyobjsector->floorheight <= gl_frontsector->ceilingheight &&
|
||||
polyobjsector->floorheight >= gl_frontsector->floorheight &&
|
||||
(viewz < polyobjsector->floorheight))
|
||||
if (polyobjsector->floorheight <= gl_frontsector->ceilingheight
|
||||
&& polyobjsector->floorheight >= gl_frontsector->floorheight
|
||||
&& (viewz < polyobjsector->floorheight))
|
||||
{
|
||||
light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
|
||||
const INT16 llevel = (light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel);
|
||||
extracolormap_t *colmap = (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap);
|
||||
|
||||
if (po_ptrs[i]->translucency > 0)
|
||||
{
|
||||
@@ -2676,24 +2674,22 @@ static void HWR_AddPolyObjectPlanes(void)
|
||||
FBITFIELD blendmode;
|
||||
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
|
||||
HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
|
||||
llevel, Surf.PolyColor.s.alpha, polyobjsector, blendmode, colmap);
|
||||
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
|
||||
}
|
||||
else
|
||||
{
|
||||
HWR_GetFlat(levelflats[polyobjsector->floorpic].lumpnum, R_NoEncore(polyobjsector, false));
|
||||
HWR_RenderPolyObjectPlane(po_ptrs[i], false, polyobjsector->floorheight, PF_Occlude,
|
||||
llevel, levelflats[polyobjsector->floorpic].lumpnum,
|
||||
polyobjsector, 255, colmap);
|
||||
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), levelflats[polyobjsector->floorpic].lumpnum,
|
||||
polyobjsector, 255, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
|
||||
}
|
||||
}
|
||||
|
||||
if (polyobjsector->ceilingheight >= gl_frontsector->floorheight &&
|
||||
polyobjsector->ceilingheight <= gl_frontsector->ceilingheight &&
|
||||
(viewz > polyobjsector->ceilingheight))
|
||||
if (polyobjsector->ceilingheight >= gl_frontsector->floorheight
|
||||
&& polyobjsector->ceilingheight <= gl_frontsector->ceilingheight
|
||||
&& (viewz > polyobjsector->ceilingheight))
|
||||
{
|
||||
light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
|
||||
const INT16 llevel = (light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel);
|
||||
extracolormap_t *colmap = (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap);
|
||||
|
||||
if (po_ptrs[i]->translucency > 0)
|
||||
{
|
||||
@@ -2701,14 +2697,14 @@ static void HWR_AddPolyObjectPlanes(void)
|
||||
FBITFIELD blendmode;
|
||||
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
|
||||
HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
|
||||
llevel, Surf.PolyColor.s.alpha, polyobjsector, blendmode, colmap);
|
||||
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
|
||||
}
|
||||
else
|
||||
{
|
||||
HWR_GetFlat(levelflats[polyobjsector->ceilingpic].lumpnum, R_NoEncore(polyobjsector, true));
|
||||
HWR_RenderPolyObjectPlane(po_ptrs[i], true, polyobjsector->ceilingheight, PF_Occlude,
|
||||
llevel, levelflats[polyobjsector->ceilingpic].lumpnum,
|
||||
polyobjsector, 255, colmap);
|
||||
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), levelflats[polyobjsector->ceilingpic].lumpnum,
|
||||
polyobjsector, 255, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3239,18 +3235,6 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
|
||||
if (!spr->mobj)
|
||||
return;
|
||||
|
||||
// Ceiling scenery have no shadow.
|
||||
if ((spr->mobj->flags & (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY)) == (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY))
|
||||
return;
|
||||
|
||||
// Debris have no corona or shadow.
|
||||
if (spr->mobj->flags2 & MF2_DEBRIS)
|
||||
return;
|
||||
|
||||
// Without this, your shadow shows on the floor, even after you die and fall through the ground.
|
||||
if (spr->mobj->z < spr->mobj->floorz)
|
||||
return;
|
||||
|
||||
R_GetShadowZ(spr->mobj, &floorslope);
|
||||
|
||||
mobjfloor = HWR_OpaqueFloorAtPos(
|
||||
@@ -3511,7 +3495,10 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
|
||||
hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
|
||||
|
||||
// Draw shadow BEFORE sprite
|
||||
if (UNLIKELY(cv_shadow.value))
|
||||
if (UNLIKELY(cv_shadow.value // Shadows enabled
|
||||
&& (sprmo->flags & (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY)) != (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY) // Ceiling scenery have no shadow.
|
||||
&& !(sprmo->flags2 & MF2_DEBRIS) // Debris have no corona or shadow.
|
||||
&& (sprmo->z >= sprmo->floorz))) // Without this, your shadow shows on the floor, even after you die and fall through the ground.
|
||||
{
|
||||
////////////////////
|
||||
// SHADOW SPRITE! //
|
||||
@@ -3721,7 +3708,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
|
||||
|
||||
Surf.PolyColor.s.alpha = alpha;
|
||||
|
||||
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, shader, false);
|
||||
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, shader, false); // sprite shader
|
||||
|
||||
top = bot;
|
||||
endtop = endbot;
|
||||
@@ -3748,7 +3735,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
|
||||
|
||||
Surf.PolyColor.s.alpha = alpha;
|
||||
|
||||
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, shader, false);
|
||||
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, shader, false); // sprite shader
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
@@ -3837,7 +3824,10 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
|
||||
}
|
||||
|
||||
// Draw shadow BEFORE sprite
|
||||
if (UNLIKELY(cv_shadow.value))
|
||||
if (UNLIKELY(cv_shadow.value // Shadows enabled
|
||||
&& (sprmo->flags & (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY)) != (MF_SCENERY|MF_SPAWNCEILING|MF_NOGRAVITY) // Ceiling scenery have no shadow.
|
||||
&& !(sprmo->flags2 & MF2_DEBRIS) // Debris have no corona or shadow.
|
||||
&& (sprmo->z >= sprmo->floorz))) // Without this, your shadow shows on the floor, even after you die and fall through the ground.
|
||||
{
|
||||
////////////////////
|
||||
// SHADOW SPRITE! //
|
||||
@@ -6125,7 +6115,7 @@ static boolean HWR_WipeCheck(UINT8 wipenum, UINT8 scrnnum)
|
||||
}
|
||||
|
||||
// puts the numbers into the lumpname
|
||||
snprintf(&lumpname[4], sizeof(lumpname) - 4, "%.2hu%.2hu", (UINT16)wipenum, (UINT16)scrnnum);
|
||||
sprintf(&lumpname[4], "%.2hu%.2hu", (UINT16)wipenum, (UINT16)scrnnum);
|
||||
wipelumpnum = W_CheckNumForName(lumpname);
|
||||
|
||||
// again, shouldn't be here really
|
||||
|
||||
@@ -1247,7 +1247,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
if (!md2->model)
|
||||
{
|
||||
CONS_Debug(DBG_RENDER, "Loading model... (%s, %s)", sprnames[spr->mobj->sprite], md2->filename);
|
||||
snprintf(filename, sizeof(filename), "mdls/%s", md2->filename);
|
||||
sprintf(filename, "mdls/%s", md2->filename);
|
||||
md2->model = md2_readModel(filename);
|
||||
|
||||
if (md2->model)
|
||||
@@ -1483,7 +1483,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
|
||||
{
|
||||
char filename[64];
|
||||
CONS_Debug(DBG_RENDER, "Loading model... (%s)\n", md2->filename);
|
||||
snprintf(filename, sizeof(filename), "mdls/%s", md2->filename);
|
||||
sprintf(filename, "mdls/%s", md2->filename);
|
||||
md2->model = md2_readModel(filename);
|
||||
|
||||
if (md2->model)
|
||||
|
||||
@@ -275,6 +275,13 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
return NULL;
|
||||
|
||||
retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, NULL);
|
||||
|
||||
//size_t fileLen;
|
||||
|
||||
//int i, j;
|
||||
|
||||
//size_t namelen;
|
||||
//char *texturefilename;
|
||||
texPos = strchr(fileName, '/');
|
||||
|
||||
if (texPos)
|
||||
@@ -311,6 +318,8 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
retModel->numMeshes = 1; // MD2 only has one mesh
|
||||
retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, NULL);
|
||||
retModel->meshes[0].numFrames = header->numFrames;
|
||||
// const float WUNITS = 1.0f;
|
||||
// float dataScale = WUNITS;
|
||||
|
||||
// Tris and ST are simple structures that can be straight-copied
|
||||
tris = (md2triangle_t*)&buffer[header->offsetTris];
|
||||
@@ -346,6 +355,47 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
retModel->materials[t].specular[3] = 1.0f;
|
||||
retModel->materials[t].shininess = 0.0f;
|
||||
retModel->materials[t].spheremap = false;
|
||||
|
||||
/* retModel->materials[t].texture = Texture::ReadTexture((char*)texturefilename, ZT_TEXTURE);
|
||||
|
||||
if (!systemSucks)
|
||||
{
|
||||
// Check for a normal map...??
|
||||
char openfilename[1024];
|
||||
char normalMapName[1024];
|
||||
strcpy(normalMapName, texturefilename);
|
||||
size_t len = strlen(normalMapName);
|
||||
char *ptr = &normalMapName[len];
|
||||
ptr--; // z
|
||||
ptr--; // u
|
||||
ptr--; // b
|
||||
ptr--; // .
|
||||
*ptr++ = '_';
|
||||
*ptr++ = 'n';
|
||||
*ptr++ = '.';
|
||||
*ptr++ = 'b';
|
||||
*ptr++ = 'u';
|
||||
*ptr++ = 'z';
|
||||
*ptr++ = '\0';
|
||||
|
||||
sprintf(openfilename, "%s/%s", "textures", normalMapName);
|
||||
// Convert backslashes to forward slashes
|
||||
for (int k = 0; k < 1024; k++)
|
||||
{
|
||||
if (openfilename[k] == '\0')
|
||||
break;
|
||||
|
||||
if (openfilename[k] == '\\')
|
||||
openfilename[k] = '/';
|
||||
}
|
||||
|
||||
Resource::resource_t *res = Resource::Open(openfilename);
|
||||
if (res)
|
||||
{
|
||||
Resource::Close(res);
|
||||
retModel->materials[t].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
|
||||
}
|
||||
}*/
|
||||
}
|
||||
|
||||
retModel->meshes[0].numTriangles = header->numTris;
|
||||
@@ -375,11 +425,15 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
md2frame_t *framePtr = (md2frame_t*)ptr;
|
||||
retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, NULL);
|
||||
retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, NULL);
|
||||
|
||||
// if (retModel->materials[0].lightmap)
|
||||
// retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
|
||||
retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, NULL);
|
||||
|
||||
vertptr = retModel->meshes[0].tinyframes[i].vertices;
|
||||
normptr = retModel->meshes[0].tinyframes[i].normals;
|
||||
|
||||
// tanptr = retModel->meshes[0].tinyframes[i].tangents;
|
||||
retModel->meshes[0].tinyframes[i].material = &retModel->materials[0];
|
||||
|
||||
framePtr++; // Advance to vertex list
|
||||
@@ -455,7 +509,9 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
md2frame_t *framePtr = (md2frame_t*)ptr;
|
||||
retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL);
|
||||
retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL);
|
||||
|
||||
// if (retModel->materials[0].lightmap)
|
||||
// retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
|
||||
//float *vertptr, *normptr;
|
||||
normptr = (float*)retModel->meshes[0].frames[i].normals;
|
||||
vertptr = (float*)retModel->meshes[0].frames[i].vertices;
|
||||
trisPtr = tris;
|
||||
|
||||
@@ -243,6 +243,48 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
mdShader[j].name[len-1] = 'z';
|
||||
mdShader[j].name[len-2] = 'u';
|
||||
mdShader[j].name[len-3] = 'b';
|
||||
|
||||
// Load material
|
||||
/* retModel->materials[matCount].texture = Texture::ReadTexture(mdShader[j].name, ZT_TEXTURE);
|
||||
|
||||
if (!systemSucks)
|
||||
{
|
||||
// Check for a normal map...??
|
||||
char openfilename[1024];
|
||||
char normalMapName[1024];
|
||||
strcpy(normalMapName, mdShader[j].name);
|
||||
len = strlen(normalMapName);
|
||||
char *ptr = &normalMapName[len];
|
||||
ptr--; // z
|
||||
ptr--; // u
|
||||
ptr--; // b
|
||||
ptr--; // .
|
||||
*ptr++ = '_';
|
||||
*ptr++ = 'n';
|
||||
*ptr++ = '.';
|
||||
*ptr++ = 'b';
|
||||
*ptr++ = 'u';
|
||||
*ptr++ = 'z';
|
||||
*ptr++ = '\0';
|
||||
|
||||
sprintf(openfilename, "%s/%s", "textures", normalMapName);
|
||||
// Convert backslashes to forward slashes
|
||||
for (int k = 0; k < 1024; k++)
|
||||
{
|
||||
if (openfilename[k] == '\0')
|
||||
break;
|
||||
|
||||
if (openfilename[k] == '\\')
|
||||
openfilename[k] = '/';
|
||||
}
|
||||
|
||||
Resource::resource_t *res = Resource::Open(openfilename);
|
||||
if (res)
|
||||
{
|
||||
Resource::Close(res);
|
||||
retModel->materials[matCount].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
|
||||
}
|
||||
}*/
|
||||
}
|
||||
|
||||
retModel->meshes[i].numFrames = mdS->numFrames;
|
||||
@@ -263,15 +305,19 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
{
|
||||
short *vertptr;
|
||||
char *normptr;
|
||||
// char *tanptr;
|
||||
int k;
|
||||
md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
|
||||
retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, NULL);
|
||||
retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, NULL);
|
||||
|
||||
// if (retModel->materials[0].lightmap)
|
||||
// retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag);
|
||||
retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, NULL);
|
||||
vertptr = retModel->meshes[i].tinyframes[j].vertices;
|
||||
normptr = retModel->meshes[i].tinyframes[j].normals;
|
||||
|
||||
// tanptr = retModel->meshes[i].tinyframes[j].tangents;
|
||||
retModel->meshes[i].tinyframes[j].material = &retModel->materials[i];
|
||||
|
||||
for (k = 0; k < mdS->numVerts; k++)
|
||||
@@ -338,7 +384,8 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
|
||||
retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL);
|
||||
retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL);
|
||||
|
||||
// if (retModel->materials[i].lightmap)
|
||||
// retModel->meshes[i].frames[j].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag);
|
||||
vertptr = retModel->meshes[i].frames[j].vertices;
|
||||
normptr = retModel->meshes[i].frames[j].normals;
|
||||
retModel->meshes[i].frames[j].material = &retModel->materials[i];
|
||||
@@ -424,6 +471,37 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
// Tags?
|
||||
retModel->numTags = mdh->numTags;
|
||||
retModel->maxNumFrames = mdh->numFrames;
|
||||
retModel->tags = (tag_t*)Z_Calloc(sizeof(tag_t) * retModel->numTags * mdh->numFrames, ztag);
|
||||
md3Tag *mdTag = (md3Tag*)&buffer[mdh->offsetTags];
|
||||
tag_t *curTag = retModel->tags;
|
||||
for (i = 0; i < mdh->numFrames; i++)
|
||||
{
|
||||
int j;
|
||||
for (j = 0; j < retModel->numTags; j++, mdTag++)
|
||||
{
|
||||
strcpys(curTag->name, mdTag->name, sizeof(curTag->name) / sizeof(char));
|
||||
curTag->transform.m[0][0] = mdTag->axis[0];
|
||||
curTag->transform.m[0][1] = mdTag->axis[1];
|
||||
curTag->transform.m[0][2] = mdTag->axis[2];
|
||||
curTag->transform.m[1][0] = mdTag->axis[3];
|
||||
curTag->transform.m[1][1] = mdTag->axis[4];
|
||||
curTag->transform.m[1][2] = mdTag->axis[5];
|
||||
curTag->transform.m[2][0] = mdTag->axis[6];
|
||||
curTag->transform.m[2][1] = mdTag->axis[7];
|
||||
curTag->transform.m[2][2] = mdTag->axis[8];
|
||||
curTag->transform.m[3][0] = mdTag->origin[0] * WUNITS;
|
||||
curTag->transform.m[3][1] = mdTag->origin[1] * WUNITS;
|
||||
curTag->transform.m[3][2] = mdTag->origin[2] * WUNITS;
|
||||
curTag->transform.m[3][3] = 1.0f;
|
||||
|
||||
Matrix::Rotate(&curTag->transform, 90.0f, &Vector::Xaxis);
|
||||
curTag++;
|
||||
}
|
||||
}*/
|
||||
|
||||
free(buffer);
|
||||
|
||||
|
||||
@@ -1931,7 +1931,6 @@ static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD, UINT32
|
||||
{
|
||||
if (samplePoint[p].s.alpha == 0)
|
||||
continue;
|
||||
|
||||
sumR += samplePoint[p].s.red;
|
||||
sumG += samplePoint[p].s.green;
|
||||
sumB += samplePoint[p].s.blue;
|
||||
@@ -3283,7 +3282,7 @@ static void GL_Framebuffer_Generate(void)
|
||||
{
|
||||
pglGenTextures(1, &framebufferobject.tex);
|
||||
pglBindTexture(GL_TEXTURE_2D, framebufferobject.tex);
|
||||
pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
||||
pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screen_width, screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
|
||||
+8
-10
@@ -135,7 +135,8 @@ HMS_on_read (char *s, size_t _1, size_t n, void *userdata)
|
||||
return n;
|
||||
}
|
||||
|
||||
static struct HMS_buffer *HMS_connect(const char *format, ...)
|
||||
static struct HMS_buffer *
|
||||
HMS_connect (const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
CURL *curl;
|
||||
@@ -173,7 +174,7 @@ static struct HMS_buffer *HMS_connect(const char *format, ...)
|
||||
if (cv_masterserver_token.string && cv_masterserver_token.string[0])
|
||||
{
|
||||
quack_token = curl_easy_escape(curl, cv_masterserver_token.string, 0);
|
||||
token_length = ( sizeof "&token="-1 ) + strlen(quack_token);
|
||||
token_length = ( sizeof "&token="-1 )+ strlen(quack_token);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -185,30 +186,27 @@ static struct HMS_buffer *HMS_connect(const char *format, ...)
|
||||
I_lock_mutex(&hms_api_mutex);
|
||||
#endif
|
||||
|
||||
seek = strlen(hms_api) + 1; /* + '/' */
|
||||
seek = strlen(hms_api) + 1;/* + '/' */
|
||||
|
||||
va_start (ap, format);
|
||||
size_t url_size = (seek + vsnprintf(NULL, 0, format, ap) +
|
||||
sizeof HMS_QUERY_VERSION - 1 +
|
||||
token_length + 1);
|
||||
url = malloc(url_size);
|
||||
url = malloc(seek + vsnprintf(NULL, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
|
||||
va_end (ap);
|
||||
|
||||
snprintf(url, seek + 1, "%s/", hms_api);
|
||||
sprintf(url, "%s/", hms_api);
|
||||
|
||||
#ifdef HAVE_THREADS
|
||||
I_unlock_mutex(hms_api_mutex);
|
||||
#endif
|
||||
|
||||
va_start (ap, format);
|
||||
seek += vsnprintf(&url[seek], url_size - seek, format, ap);
|
||||
seek += vsprintf(&url[seek], format, ap);
|
||||
va_end (ap);
|
||||
|
||||
strcpy(&url[seek], HMS_QUERY_VERSION);
|
||||
seek += sizeof HMS_QUERY_VERSION - 1;
|
||||
|
||||
if (quack_token)
|
||||
snprintf(&url[seek], url_size - seek, "&token=%s", quack_token);
|
||||
sprintf(&url[seek], "&token=%s", quack_token);
|
||||
|
||||
Printf_url(url);
|
||||
|
||||
|
||||
+19
-17
@@ -154,14 +154,14 @@ void HU_LoadGraphics(void)
|
||||
for (i = 0; i < HU_FONTSIZE; i++, j++)
|
||||
{
|
||||
// cache the heads-up font for entire game execution
|
||||
snprintf(buffer, sizeof(buffer), "STCFN%.3d", j);
|
||||
sprintf(buffer, "STCFN%.3d", j);
|
||||
if (W_CheckNumForName(buffer) == LUMPERROR)
|
||||
hu_font[i] = NULL;
|
||||
else
|
||||
hu_font[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
|
||||
// tiny version of the heads-up font
|
||||
snprintf(buffer, sizeof(buffer), "TNYFN%.3d", j);
|
||||
sprintf(buffer, "TNYFN%.3d", j);
|
||||
if (W_CheckNumForName(buffer) == LUMPERROR)
|
||||
tny_font[i] = NULL;
|
||||
else
|
||||
@@ -188,7 +188,7 @@ void HU_LoadGraphics(void)
|
||||
for (i = 0; i < KART_FONTSIZE; i++, j++)
|
||||
{
|
||||
// cache the heads-up font for entire game execution
|
||||
snprintf(buffer, sizeof(buffer), "MKFNT%.3d", j);
|
||||
sprintf(buffer, "MKFNT%.3d", j);
|
||||
if (W_CheckNumForName(buffer) == LUMPERROR)
|
||||
kart_font[i] = NULL;
|
||||
else
|
||||
@@ -199,7 +199,7 @@ void HU_LoadGraphics(void)
|
||||
j = LT_FONTSTART;
|
||||
for (i = 0; i < LT_FONTSIZE; i++)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "LTFNT%.3d", j);
|
||||
sprintf(buffer, "LTFNT%.3d", j);
|
||||
j++;
|
||||
|
||||
if (W_CheckNumForName(buffer) == LUMPERROR)
|
||||
@@ -212,7 +212,7 @@ void HU_LoadGraphics(void)
|
||||
j = CRED_FONTSTART;
|
||||
for (i = 0; i < CRED_FONTSIZE; i++)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "CRFNT%.3d", j);
|
||||
sprintf(buffer, "CRFNT%.3d", j);
|
||||
j++;
|
||||
|
||||
if (W_CheckNumForName(buffer) == LUMPERROR)
|
||||
@@ -224,11 +224,11 @@ void HU_LoadGraphics(void)
|
||||
// cache numbers too!
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "STTNUM%d", i);
|
||||
sprintf(buffer, "STTNUM%d", i);
|
||||
tallnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
snprintf(buffer, sizeof(buffer), "PINGN%d", i);
|
||||
sprintf(buffer, "PINGN%d", i);
|
||||
pingnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
snprintf(buffer, sizeof(buffer), "OPPRNK0%d", i);
|
||||
sprintf(buffer, "OPPRNK0%d", i);
|
||||
ranknum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
@@ -240,7 +240,7 @@ void HU_LoadGraphics(void)
|
||||
// cache ping gfx:
|
||||
for (i = 0; i < 5; i++)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "PINGGFX%d", i+1);
|
||||
sprintf(buffer, "PINGGFX%d", i+1);
|
||||
pinggfx[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
@@ -472,7 +472,9 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
|
||||
strlcat(msg, COM_Argv(ix + usedargs), msgspace);
|
||||
}
|
||||
|
||||
if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
|
||||
const size_t msglength = strlen(msg);
|
||||
|
||||
if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
|
||||
{
|
||||
// what we're gonna do now is check if the node exists
|
||||
// with that logic, characters 4 and 5 are our numbers:
|
||||
@@ -526,7 +528,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
|
||||
strlcpy(msg, newmsg, HU_MAXMSGLEN + 1);
|
||||
}
|
||||
|
||||
SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
|
||||
SendNetXCmd(XD_SAY, buf, msglength + 1 + msg-buf);
|
||||
}
|
||||
|
||||
/** Send a message to everyone.
|
||||
@@ -777,11 +779,12 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
|
||||
return;
|
||||
}
|
||||
|
||||
const size_t msglength = strlen(msg);
|
||||
|
||||
//check for invalid characters (0x80 or above)
|
||||
{
|
||||
size_t i;
|
||||
const size_t j = strlen(msg);
|
||||
|
||||
const size_t j = msglength;
|
||||
for (i = 0; i < j; i++)
|
||||
{
|
||||
if (msg[i] & 0x80)
|
||||
@@ -828,7 +831,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
|
||||
}
|
||||
|
||||
// Handle "/me" actions, but only in messages to everyone.
|
||||
if (target == 0 && strlen(msg) > 4 && strnicmp(msg, "/me ", 4) == 0)
|
||||
if (target == 0 && msglength > 4 && strnicmp(msg, "/me ", 4) == 0)
|
||||
{
|
||||
msg += 4;
|
||||
action = true;
|
||||
@@ -2827,9 +2830,8 @@ static void HU_DrawRankings(void)
|
||||
scorelines++;
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
// 32 Player TODO: port over and cleanup scoreboard from sat-32p/blankart
|
||||
if (scorelines >= 16)
|
||||
break; // dont draw past bottom of screen, show the best only
|
||||
if (scorelines > 16)
|
||||
break; //dont draw past bottom of screen, show the best only
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@@ -237,21 +237,6 @@ char *I_GetUserName(void);
|
||||
*/
|
||||
INT32 I_mkdir(const char *dirname, INT32 unixright);
|
||||
|
||||
/** \brief Change current working directory
|
||||
|
||||
\param path directory path
|
||||
\return 0 on success, -1 on error
|
||||
*/
|
||||
INT32 I_ChDir(const char *path);
|
||||
|
||||
/** \brief Get current working directory
|
||||
|
||||
\param buf buffer to store path
|
||||
\param size size of buffer
|
||||
\return buf on success, NULL on error
|
||||
*/
|
||||
char *I_GetCwd(char *buf, size_t size);
|
||||
|
||||
/** \brief Find main WAD
|
||||
\return path to main WAD
|
||||
*/
|
||||
|
||||
+5
-4
@@ -213,7 +213,7 @@ static char *get_WSAErrorStr(int e)
|
||||
NULL);
|
||||
|
||||
if (!buf[0]) // provide a fallback error message if no message is available for some reason
|
||||
snprintf(buf, sizeof(buf), "Unknown error");
|
||||
sprintf(buf, "Unknown error");
|
||||
|
||||
return buf;
|
||||
}
|
||||
@@ -364,12 +364,12 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
|
||||
|
||||
if (addr == NULL)
|
||||
{
|
||||
snprintf(s, sizeof(s), "No address");
|
||||
sprintf(s, "No address");
|
||||
}
|
||||
else if (inet_ntop(sk->any.sa_family, addr, &s[v6], sizeof (s) - v6) == NULL)
|
||||
{
|
||||
e = errno;
|
||||
snprintf(s, sizeof(s), "Unknown family type, error #%u: %s", e, strerror(e));
|
||||
sprintf(s, "Unknown family type, error #%u: %s", e, strerror(e));
|
||||
}
|
||||
#ifdef HAVE_IPV6
|
||||
else if(sk->any.sa_family == AF_INET6)
|
||||
@@ -416,7 +416,7 @@ static const char *SOCK_GetBanMask(size_t ban)
|
||||
if (ban >= numbans)
|
||||
return NULL;
|
||||
|
||||
if (snprintf(s, sizeof(s), "%d",banned[ban].mask) > 0)
|
||||
if (sprintf(s,"%d",banned[ban].mask) > 0)
|
||||
return s;
|
||||
|
||||
return NULL;
|
||||
@@ -622,6 +622,7 @@ static boolean hole_punch(ssize_t c)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
#endif //ifdef HOLEPUNCH
|
||||
|
||||
|
||||
+3
-3
@@ -452,10 +452,10 @@ void A_SpawnFreshCopy(void *actor);
|
||||
extern boolean actionsoverridden[NUMACTIONS];
|
||||
|
||||
// ratio of states to sprites to mobj types is roughly 6 : 1 : 1
|
||||
#ifdef PHOBOS_BUILD
|
||||
#define NUMMOBJFREESLOTS 4096 // should be sufficient
|
||||
#else
|
||||
#ifdef COMPAT_VANILLA
|
||||
#define NUMMOBJFREESLOTS 1024
|
||||
#else
|
||||
#define NUMMOBJFREESLOTS 4096 // should be sufficient
|
||||
#endif
|
||||
#define NUMSPRITEFREESLOTS NUMMOBJFREESLOTS
|
||||
#define NUMSTATEFREESLOTS (NUMMOBJFREESLOTS*8)
|
||||
|
||||
+19
-40
@@ -388,7 +388,7 @@ static void K_LoadSaturnHUDGraphics(void)
|
||||
skp_speedpatchesdial[3] = (patch_t *)W_CachePatchName("SP_DFRAC", PU_HUDGFX);
|
||||
skp_speedpatchesdial[4] = (patch_t *)W_CachePatchName("SP_DPERC", PU_HUDGFX);
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_DSPNMx");
|
||||
sprintf(buffer, "K_DSPNMx");
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
buffer[7] = '0'+(i%10);
|
||||
@@ -507,7 +507,7 @@ static void K_LoadSaturnHUDGraphics(void)
|
||||
skp_speedpatchesdialclr[3] = (patch_t *)W_CachePatchName("SC_DFRAC", PU_HUDGFX);
|
||||
skp_speedpatchesdialclr[4] = (patch_t *)W_CachePatchName("SC_DPERC", PU_HUDGFX);
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_DSPNCx");
|
||||
sprintf(buffer, "K_DSPNCx");
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
buffer[7] = '0'+(i%10);
|
||||
@@ -677,7 +677,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
kp_racefinish[5] = (patch_t *)W_CachePatchName("K_2PFINB", PU_HUDGFX);
|
||||
|
||||
// Position numbers
|
||||
snprintf(buffer, sizeof(buffer), "K_POSNxx");
|
||||
sprintf(buffer, "K_POSNxx");
|
||||
for (i = 0; i < NUMPOSNUMS; i++)
|
||||
{
|
||||
buffer[6] = '0'+i;
|
||||
@@ -688,17 +688,14 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_POSNWx");
|
||||
sprintf(buffer, "K_POSNWx");
|
||||
for (i = 0; i < NUMWINFRAMES; i++)
|
||||
{
|
||||
buffer[7] = '0'+i;
|
||||
kp_winnernum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
// 32 player note: there are only 16 of those!
|
||||
// so slots after this will just be missing patches!
|
||||
// but keeping like this incase of missed adjustments which might cause crashes otherwise
|
||||
snprintf(buffer, sizeof(buffer), "OPPRNKxx");
|
||||
sprintf(buffer, "OPPRNKxx");
|
||||
for (i = 0; i <= MAXPLAYERS; i++)
|
||||
{
|
||||
buffer[6] = '0'+(i/10);
|
||||
@@ -706,7 +703,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
kp_facenum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_CHILIx");
|
||||
sprintf(buffer, "K_CHILIx");
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
buffer[7] = '0'+(i+1);
|
||||
@@ -775,21 +772,21 @@ void K_LoadKartHUDGraphics(void)
|
||||
kp_kitchensink[1] = (patch_t *)W_CachePatchName("K_ISSINK", PU_HUDGFX);
|
||||
kp_sadface[1] = (patch_t *)W_CachePatchName("K_ISSAD", PU_HUDGFX);
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_ITINVx");
|
||||
sprintf(buffer, "K_ITINVx");
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
buffer[7] = '1'+i;
|
||||
kp_invincibility[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_ITORBx");
|
||||
sprintf(buffer, "K_ITORBx");
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
buffer[7] = '1'+i;
|
||||
kp_orbinaut[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_ISINVx");
|
||||
sprintf(buffer, "K_ISINVx");
|
||||
for (i = 0; i < 6; i++)
|
||||
{
|
||||
buffer[7] = '1'+i;
|
||||
@@ -797,7 +794,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
|
||||
// CHECK indicators
|
||||
snprintf(buffer, sizeof(buffer), "K_CHECKx");
|
||||
sprintf(buffer, "K_CHECKx");
|
||||
for (i = 0; i < 6; i++)
|
||||
{
|
||||
buffer[7] = '1'+i;
|
||||
@@ -805,7 +802,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
|
||||
// Eggman warning numbers
|
||||
snprintf(buffer, sizeof(buffer), "K_EGGNx");
|
||||
sprintf(buffer, "K_EGGNx");
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
buffer[6] = '0'+i;
|
||||
@@ -818,7 +815,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
kp_fpview[2] = (patch_t *)W_CachePatchName("VIEWC0E0", PU_HUDGFX);
|
||||
|
||||
// Input UI Wheel
|
||||
snprintf(buffer, sizeof(buffer), "K_WHEELx");
|
||||
sprintf(buffer, "K_WHEELx");
|
||||
for (i = 0; i < 5; i++)
|
||||
{
|
||||
buffer[7] = '0'+i;
|
||||
@@ -826,7 +823,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
|
||||
// HERE COMES A NEW CHALLENGER
|
||||
snprintf(buffer, sizeof(buffer), "K_CHALxx");
|
||||
sprintf(buffer, "K_CHALxx");
|
||||
for (i = 0; i < 25; i++)
|
||||
{
|
||||
buffer[6] = '0'+((i+1)/10);
|
||||
@@ -835,14 +832,14 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
|
||||
// Lap start animation
|
||||
snprintf(buffer, sizeof(buffer), "K_LAP0x");
|
||||
sprintf(buffer, "K_LAP0x");
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
buffer[6] = '0'+(i+1);
|
||||
kp_lapanim_lap[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_LAPFxx");
|
||||
sprintf(buffer, "K_LAPFxx");
|
||||
for (i = 0; i < 11; i++)
|
||||
{
|
||||
buffer[6] = '0'+((i+1)/10);
|
||||
@@ -850,7 +847,7 @@ void K_LoadKartHUDGraphics(void)
|
||||
kp_lapanim_final[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_LAPNxx");
|
||||
sprintf(buffer, "K_LAPNxx");
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
buffer[6] = '0'+i;
|
||||
@@ -861,14 +858,14 @@ void K_LoadKartHUDGraphics(void)
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_LAPE0x");
|
||||
sprintf(buffer, "K_LAPE0x");
|
||||
for (i = 0; i < 2; i++)
|
||||
{
|
||||
buffer[7] = '0'+(i+1);
|
||||
kp_lapanim_emblem[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "K_LAPH0x");
|
||||
sprintf(buffer, "K_LAPH0x");
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
buffer[7] = '0'+(i+1);
|
||||
@@ -1977,7 +1974,7 @@ void K_drawKartTimestamp(tic_t drawtime, INT32 TX, INT32 TY, INT16 emblemmap, UI
|
||||
goto bademblem;
|
||||
}
|
||||
|
||||
snprintf(targettext, sizeof(targettext), "%i'%02i\"%02i",
|
||||
snprintf(targettext, 9, "%i'%02i\"%02i",
|
||||
G_TicsToMinutes(timetoreach, false),
|
||||
G_TicsToSeconds(timetoreach),
|
||||
G_TicsToCentiseconds(timetoreach));
|
||||
@@ -2297,11 +2294,6 @@ static boolean K_drawKartPositionFaces(void)
|
||||
if (pos < 0 || pos > MAXPLAYERS)
|
||||
pos = 0;
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
if (pos > 16)
|
||||
V_DrawPingNum(FACE_X+2, Y+10, V_HUDTRANS|V_SNAPTOLEFT, pos, NULL);
|
||||
else
|
||||
#endif
|
||||
// Draws the little number over the face
|
||||
V_DrawScaledPatch(FACE_X-5, Y+10, V_HUDTRANS|V_SNAPTOLEFT, kp_facenum[pos]);
|
||||
}
|
||||
@@ -2393,12 +2385,6 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
|
||||
INT32 pos = player->kartstuff[k_position];
|
||||
if (pos < 0 || pos > MAXPLAYERS)
|
||||
pos = 0;
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
if (pos > 16)
|
||||
V_DrawPingNum(x+2, y+10, 0, pos, NULL);
|
||||
else
|
||||
#endif
|
||||
// Draws the little number over the face
|
||||
V_DrawScaledPatch(x-5, y+6, 0, kp_facenum[pos]);
|
||||
}
|
||||
@@ -3595,10 +3581,6 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
|
||||
#endif
|
||||
|
||||
skin = K_GetMobjSkin(mo);
|
||||
|
||||
if (!skin)
|
||||
return;
|
||||
|
||||
minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)];
|
||||
|
||||
if (minimaphead == NULL)
|
||||
@@ -3802,9 +3784,6 @@ static void K_drawKartMinimap(void)
|
||||
|
||||
mobj_t *mobj = players[localplayers[i]].mo;
|
||||
|
||||
if (!mobj)
|
||||
continue;
|
||||
|
||||
// dont draw for no contestants
|
||||
boolean playertimedout = (mobj->health <= 0 && players[localplayers[i]].pflags & PF_TIMEOVER);
|
||||
|
||||
|
||||
+4
-38
@@ -1033,12 +1033,6 @@ INT32 K_KartGetItemOdds(UINT8 pos, SINT8 item, fixed_t mashed, boolean spbrush)
|
||||
}
|
||||
}
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
// courtesy of fickle from 1.1 battleroyale
|
||||
// battleroyale: limit how much items will scale to try to prevent shit-tier items in shit-huge netames
|
||||
pingame = min(pingame, 12);
|
||||
#endif
|
||||
|
||||
if (first != -1 && second != -1) // calculate 2nd's distance from 1st, for SPB
|
||||
{
|
||||
secondist = P_AproxDistance(P_AproxDistance(players[first].mo->x - players[second].mo->x,
|
||||
@@ -4337,6 +4331,7 @@ static void K_DoShrink(player_t *user)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
|
||||
{
|
||||
if (mo->player && mo->player->spectator)
|
||||
@@ -4399,7 +4394,8 @@ void K_KillBananaChain(mobj_t *banana, mobj_t *inflictor, mobj_t *source)
|
||||
mobj_t *cachenext;
|
||||
|
||||
killnext:
|
||||
if (P_MobjWasRemovedCompat(banana))
|
||||
|
||||
if (!banana)
|
||||
return;
|
||||
|
||||
cachenext = banana->hnext;
|
||||
@@ -4438,21 +4434,10 @@ void K_UpdateHnextList(player_t *player, boolean clean)
|
||||
nextwork = work->hnext;
|
||||
|
||||
if (!clean && (!work->movedir || work->movedir <= (UINT16)player->kartstuff[k_itemamount]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
P_RemoveMobj(work);
|
||||
}
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
if (P_MobjWasRemoved(player->mo->hnext))
|
||||
{
|
||||
// Like below, try to clean up the pointer if it's NULL.
|
||||
// Maybe this was a cause of the shrink/eggbox fails?
|
||||
P_SetTarget(&player->mo->hnext, NULL);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// For getting hit!
|
||||
@@ -4517,9 +4502,7 @@ void K_DropHnextList(player_t *player)
|
||||
}
|
||||
|
||||
dropwork = P_SpawnMobj(work->x, work->y, work->z, type);
|
||||
|
||||
P_SetTarget(&dropwork->target, player->mo);
|
||||
|
||||
dropwork->angle = work->angle;
|
||||
dropwork->flags2 = work->flags2;
|
||||
dropwork->flags |= MF_NOCLIPTHING;
|
||||
@@ -4587,13 +4570,10 @@ void K_DropHnextList(player_t *player)
|
||||
|
||||
// we need this here too because this is done in afterthink - pointers are cleaned up at the START of each tic...
|
||||
P_SetTarget(&player->mo->hnext, NULL);
|
||||
|
||||
player->kartstuff[k_bananadrag] = 0;
|
||||
|
||||
if (player->kartstuff[k_eggmanheld])
|
||||
{
|
||||
player->kartstuff[k_eggmanheld] = 0;
|
||||
}
|
||||
else if (player->kartstuff[k_itemheld]
|
||||
&& (dropall || (--player->kartstuff[k_itemamount] <= 0)))
|
||||
{
|
||||
@@ -4894,9 +4874,7 @@ static void K_MoveHeldObjects(player_t *player)
|
||||
player->kartstuff[k_bananadrag] = 0;
|
||||
|
||||
if (player->kartstuff[k_eggmanheld])
|
||||
{
|
||||
player->kartstuff[k_eggmanheld] = 0;
|
||||
}
|
||||
else if (player->kartstuff[k_itemheld])
|
||||
{
|
||||
player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
|
||||
@@ -4913,9 +4891,7 @@ static void K_MoveHeldObjects(player_t *player)
|
||||
player->kartstuff[k_bananadrag] = 0;
|
||||
|
||||
if (player->kartstuff[k_eggmanheld])
|
||||
{
|
||||
player->kartstuff[k_eggmanheld] = 0;
|
||||
}
|
||||
else if (player->kartstuff[k_itemheld])
|
||||
{
|
||||
player->kartstuff[k_itemamount] = player->kartstuff[k_itemheld] = 0;
|
||||
@@ -4931,12 +4907,7 @@ static void K_MoveHeldObjects(player_t *player)
|
||||
case MT_JAWZ_SHIELD:
|
||||
{
|
||||
mobj_t *cur = player->mo->hnext;
|
||||
fixed_t speed = 0;
|
||||
|
||||
if (cur == NULL)
|
||||
return;
|
||||
|
||||
speed = ((8 - min(4, player->kartstuff[k_itemamount])) * cur->info->speed) / 7;
|
||||
fixed_t speed = ((8 - min(4, player->kartstuff[k_itemamount])) * cur->info->speed) / 7;
|
||||
|
||||
player->kartstuff[k_bananadrag] = 0; // Just to make sure
|
||||
|
||||
@@ -4983,13 +4954,8 @@ static void K_MoveHeldObjects(player_t *player)
|
||||
cur->flags &= ~MF_NOCLIPTHING;
|
||||
|
||||
if (!P_TryMove(cur, player->mo->x + cur->momx, player->mo->y + cur->momy, true))
|
||||
{
|
||||
P_SlideMove(cur, true);
|
||||
|
||||
if (P_MobjWasRemovedCompat(cur))
|
||||
continue;
|
||||
}
|
||||
|
||||
if (P_IsObjectOnGround(player->mo))
|
||||
{
|
||||
if (P_MobjFlip(cur) > 0)
|
||||
|
||||
@@ -3087,8 +3087,6 @@ static int lib_gPlayerDeviceRumble(lua_State *L)
|
||||
if (!player)
|
||||
return LUA_ErrInvalid(L, "player_t");
|
||||
|
||||
if (demo.playback) return 0;
|
||||
|
||||
pnum = P_GetLocalPlayerNumForPlayer(player);
|
||||
|
||||
// Not a local player
|
||||
|
||||
+11
-56
@@ -25,7 +25,6 @@
|
||||
#include "lua_libs.h"
|
||||
#include "lua_hook.h"
|
||||
#include "lua_hud.h" // hud_running errors
|
||||
#include "lua_profile.h"
|
||||
|
||||
/* =========================================================================
|
||||
ABSTRACTION
|
||||
@@ -446,54 +445,11 @@ FUNCINLINE static ATTRINLINE void get_hook_from_table(Hook_State *hook, int n)
|
||||
lua_getref(gL, hookRefs[hook->id]);
|
||||
}
|
||||
|
||||
static int pcall(Hook_State *hook)
|
||||
{
|
||||
return lua_pcall(gL, hook->values, hook->results, EINDEX);
|
||||
}
|
||||
|
||||
static const char *hook_name(Hook_State *hook)
|
||||
{
|
||||
if (hud_running)
|
||||
{
|
||||
return hudHookNames[hook->hook_type];
|
||||
}
|
||||
else if (hook->string)
|
||||
{
|
||||
return stringHookNames[hook->hook_type];
|
||||
}
|
||||
//else if (hook->mobj_type > 0)
|
||||
else if (hook->mobj_type != NONMOHOOK)
|
||||
{
|
||||
return mobjHookNames[hook->hook_type];
|
||||
}
|
||||
else
|
||||
{
|
||||
return hookNames[hook->hook_type];
|
||||
}
|
||||
}
|
||||
|
||||
static int pcall_timed_or_untimed(Hook_State *hook)
|
||||
{
|
||||
if (!hud_running && cv_lua_profile.value > 0)
|
||||
{
|
||||
lua_timer_t *timer = LUA_BeginFunctionTimer(gL, -1 - hook->values, hook_name(hook));
|
||||
int k = pcall(hook);
|
||||
LUA_EndFunctionTimer(timer);
|
||||
|
||||
return k;
|
||||
}
|
||||
else
|
||||
{
|
||||
return pcall(hook);
|
||||
}
|
||||
}
|
||||
|
||||
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 (pcall_timed_or_untimed(hook) == 0)
|
||||
if (lua_pcall(gL, hook->values, hook->results, EINDEX) == 0)
|
||||
{
|
||||
if (hook->results > 0)
|
||||
{
|
||||
@@ -579,16 +535,16 @@ FUNCINLINE static ATTRINLINE int call_mobj_type_hooks(Hook_State *hook, mobjtype
|
||||
static UINT8 seen = 0; // so we dont have to check all this shit constantly
|
||||
int numCalls = call_mapped(hook, &mobjHookIds[mobj_type][hook->hook_type]);
|
||||
|
||||
if (!seen && numCalls > 0 && mobj_type == MT_NULL &&
|
||||
( hook->hook_type == MOBJ_HOOK(MobjThinker )
|
||||
if (!seen && numCalls > 0 && mobj_type == MT_NULL && (
|
||||
hook->hook_type == MOBJ_HOOK(MobjThinker )
|
||||
|| hook->hook_type == MOBJ_HOOK(MobjCollide )
|
||||
|| hook->hook_type == MOBJ_HOOK(MobjMoveCollide)
|
||||
|| hook->hook_type == MOBJ_HOOK(MobjFuse )
|
||||
|| hook->hook_type == MOBJ_HOOK(MobjThinker )
|
||||
|| hook->hook_type == MOBJ_HOOK(BossThinker )
|
||||
))
|
||||
{
|
||||
seen = 1;
|
||||
|
||||
CONS_Alert(
|
||||
CONS_WARNING, "%s\n", va(
|
||||
"%s hooks not attached to a specific mobj type may cause performance issues!",
|
||||
@@ -610,10 +566,12 @@ FUNCINLINE static ATTRINLINE int call_mobj_type_hooks(Hook_State *hook, mobjtype
|
||||
return numCalls;
|
||||
}
|
||||
|
||||
/*FUNCINLINE static ATTRINLINE int call_mobj_type_hooks(Hook_State *hook, mobjtype_t mobj_type)
|
||||
/*
|
||||
FUNCINLINE static ATTRINLINE int call_mobj_type_hooks(Hook_State *hook, mobjtype_t mobj_type)
|
||||
{
|
||||
return call_mapped(hook, &mobjHookIds[mobj_type][hook->hook_type]);
|
||||
}*/
|
||||
}
|
||||
*/
|
||||
|
||||
static int call_hooks
|
||||
(
|
||||
@@ -802,7 +760,7 @@ static void hook_think_frame(int type)
|
||||
const hook_t * map = &hookIds[type];
|
||||
int k;
|
||||
|
||||
const boolean perfstats = (cv_perfstats.value >= PS_THINKFRAME);
|
||||
const boolean perfstats = (cv_perfstats.value >= 3);
|
||||
|
||||
if (prepare_hook(&hook, 0, type))
|
||||
{
|
||||
@@ -898,7 +856,7 @@ int LUA_HookShouldDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT3
|
||||
int LUA_HookMobjDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
|
||||
{
|
||||
return damage_hook(target, inflictor, source, damage,
|
||||
MOBJ_HOOK(MobjDamage), res_true);
|
||||
MOBJ_HOOK(MobjDamage), res_true);
|
||||
}
|
||||
|
||||
int LUA_HookMobjDeath(mobj_t *target, mobj_t *inflictor, mobj_t *source)
|
||||
@@ -987,7 +945,7 @@ void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
|
||||
{
|
||||
Hook_State hook = {};
|
||||
if (prepare_string_hook
|
||||
(&hook, 0, STRING_HOOK(LinedefExecute), line->text))
|
||||
(&hook, 0, STRING_HOOK(LinedefExecute), line->text))
|
||||
{
|
||||
LUA_PushUserdata(gL, line, META_LINE);
|
||||
LUA_PushUserdata(gL, mo, META_MOBJ);
|
||||
@@ -1060,9 +1018,6 @@ void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save)
|
||||
lua_pushcclosure(gL, archFunc, 2);
|
||||
// stack: tables, savebuffer_t, archFunc
|
||||
|
||||
// Manually set the hook's variables here since we don't call prepare_hook
|
||||
hook.hook_type = HOOK(NetVars);
|
||||
hook.mobj_type = NONMOHOOK; // Force mobj_type to be NONMOHOOK so the mobj_type check get skipped
|
||||
init_hook_call(&hook, 0, res_none);
|
||||
call_mapped(&hook, map);
|
||||
|
||||
|
||||
+1
-5
@@ -22,8 +22,7 @@
|
||||
#include "lua_script.h"
|
||||
#include "lua_libs.h"
|
||||
#include "lua_hud.h" // hud_running errors
|
||||
#include "lua_hook.h" // hook_cmd_running errors
|
||||
#include "lua_profile.h"
|
||||
#include "lua_hook.h" // cmd errors
|
||||
|
||||
boolean LUA_CallAction(enum actionnum actionnum, mobj_t *actor);
|
||||
state_t *astate = NULL;
|
||||
@@ -111,10 +110,7 @@ static void A_Lua(mobj_t *actor)
|
||||
LUA_PushUserdata(gL, actor, META_MOBJ);
|
||||
lua_pushinteger(gL, var1);
|
||||
lua_pushinteger(gL, var2);
|
||||
|
||||
lua_timer_t *timer = LUA_BeginFunctionTimer(gL, -4, "A_Lua");
|
||||
LUA_Call(gL, 3, 0, 1);
|
||||
LUA_EndFunctionTimer(timer);
|
||||
|
||||
lua_pop(gL, 1); // pop error handler
|
||||
|
||||
|
||||
@@ -1,264 +0,0 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by James Robert Roman
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "screen.h"
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <unordered_map>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <vector>
|
||||
|
||||
extern "C" {
|
||||
#include "blua/lua.h"
|
||||
};
|
||||
|
||||
#include "v_video.h"
|
||||
|
||||
#include "command.h"
|
||||
#include "doomtype.h"
|
||||
#include "i_system.h"
|
||||
#include "lua_profile.h"
|
||||
#include "m_perfstats.h"
|
||||
|
||||
extern "C" consvar_t cv_lua_profile;
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
precise_t g_time_reference;
|
||||
int g_tics_counted;
|
||||
|
||||
double g_running_tic_time;
|
||||
double g_avg_tic_time;
|
||||
|
||||
bool g_invalid;
|
||||
|
||||
}; // namespace
|
||||
|
||||
struct lua_timer_t
|
||||
{
|
||||
struct Stat
|
||||
{
|
||||
double calls = 0;
|
||||
double time = 0.0;
|
||||
};
|
||||
|
||||
Stat running, avg;
|
||||
};
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
std::unordered_map<std::string, lua_timer_t> g_tic_timers;
|
||||
|
||||
}; // namespace
|
||||
|
||||
lua_timer_t* LUA_BeginFunctionTimer(lua_State* L, int fn_idx, const char* name)
|
||||
{
|
||||
lua_Debug ar;
|
||||
|
||||
lua_pushvalue(L, fn_idx);
|
||||
lua_getinfo(L, ">S", &ar);
|
||||
|
||||
auto label = [&]
|
||||
{
|
||||
using sv = std::string_view;
|
||||
sv view{ar.source};
|
||||
|
||||
switch (view.front())
|
||||
{
|
||||
case '@': // file
|
||||
if (std::size_t p = view.rfind('/'); p != sv::npos) // lump or base
|
||||
{
|
||||
return view.substr(p + 1);
|
||||
}
|
||||
break;
|
||||
|
||||
case '=': // ??
|
||||
view.remove_prefix(1);
|
||||
break;
|
||||
}
|
||||
|
||||
return view;
|
||||
};
|
||||
|
||||
// i sure hope this std::string mess is fine...
|
||||
auto [it, ins] = g_tic_timers.try_emplace(std::string(va("%s:%d (%s)", std::string(label()).c_str(), ar.linedefined, name)));
|
||||
auto& [key, timer] = *it;
|
||||
|
||||
g_time_reference = I_GetPreciseTime();
|
||||
|
||||
return &timer;
|
||||
}
|
||||
|
||||
void LUA_EndFunctionTimer(lua_timer_t* timer)
|
||||
{
|
||||
precise_t t = I_GetPreciseTime() - g_time_reference;
|
||||
double precision = I_GetPrecisePrecision();
|
||||
|
||||
timer->running.time += t / precision;
|
||||
timer->running.calls += 1.0;
|
||||
}
|
||||
|
||||
void LUA_ResetTicTimers(void)
|
||||
{
|
||||
if (cv_lua_profile.value <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (g_tics_counted < cv_lua_profile.value)
|
||||
{
|
||||
g_tics_counted++;
|
||||
|
||||
double precision = I_GetPrecisePrecision();
|
||||
g_running_tic_time += ps_prevtictime.value.p / precision;
|
||||
}
|
||||
else
|
||||
{
|
||||
double counted = g_tics_counted;
|
||||
|
||||
for (auto& [key, timer] : g_tic_timers)
|
||||
{
|
||||
timer.avg = {timer.running.calls / counted, timer.running.time / counted};
|
||||
timer.running = {};
|
||||
}
|
||||
|
||||
g_avg_tic_time = g_running_tic_time / counted;
|
||||
g_running_tic_time = 0.0;
|
||||
|
||||
g_tics_counted = 1;
|
||||
|
||||
g_invalid = false;
|
||||
}
|
||||
}
|
||||
|
||||
void LUA_RenderTimers(void)
|
||||
{
|
||||
constexpr int kRowHeight = 4;
|
||||
float row_y = kRowHeight;
|
||||
|
||||
// pretty much what the whole srb2::Draw does lol
|
||||
auto draw_row = [](float x, float y, INT32 flags, const char *str)
|
||||
{
|
||||
V_DrawSmallStringAtFixed(
|
||||
FloatToFixed(x),
|
||||
FloatToFixed(y),
|
||||
V_MONOSPACE|V_ALLOWLOWERCASE|flags,
|
||||
str
|
||||
);
|
||||
};
|
||||
|
||||
draw_row(0.f, 0.f, 0, va("-- AVERAGES PER TIC (over %d tics) --", cv_lua_profile.value));
|
||||
|
||||
if (g_invalid)
|
||||
{
|
||||
draw_row(0.f, row_y, V_GRAYMAP, " <Data pending>");
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<decltype(g_tic_timers)::iterator> view;
|
||||
view.reserve(g_tic_timers.size());
|
||||
|
||||
auto color_flag = [](double t)
|
||||
{
|
||||
if (t < 10.0)
|
||||
{
|
||||
return V_GRAYMAP;
|
||||
}
|
||||
else if (t >= 100.0)
|
||||
{
|
||||
return V_YELLOWMAP;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
{
|
||||
double cum = 0.0;
|
||||
|
||||
for (auto it = g_tic_timers.begin(); it != g_tic_timers.end(); ++it)
|
||||
{
|
||||
auto& [key, timer] = *it;
|
||||
|
||||
cum += timer.avg.time;
|
||||
|
||||
if (timer.avg.time > 0.0)
|
||||
{
|
||||
view.push_back(it);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
const INT32 tally_flags = color_flag(cum * 1'000'000.0);
|
||||
|
||||
draw_row(0.f, row_y, tally_flags, va("%8.2f us - TOTAL", cum * 1'000'000.0));
|
||||
draw_row(0.f, row_y + kRowHeight, tally_flags, va("%8.2f ms", cum * 1000.0));
|
||||
|
||||
// dont need to show this if we didnt capture over time
|
||||
// this would just show nan or inf anyways
|
||||
if (std::fpclassify(g_avg_tic_time) != FP_ZERO)
|
||||
{
|
||||
draw_row(0.f, row_y + kRowHeight * 2, tally_flags, va(
|
||||
"%8.2f%% overhead (%.2f / %.2f) <-- not counting rendering time",
|
||||
(cum / g_avg_tic_time) * 100.0,
|
||||
(cum * (double)TICRATE),
|
||||
(g_avg_tic_time * (double)TICRATE)
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
row_y += kRowHeight * 4;
|
||||
}
|
||||
|
||||
std::sort(
|
||||
view.rbegin(),
|
||||
view.rend(),
|
||||
[](auto a, auto b)
|
||||
{
|
||||
auto& [k1, t1] = *a;
|
||||
auto& [k2, t2] = *b;
|
||||
return t1.avg.time < t2.avg.time;
|
||||
}
|
||||
);
|
||||
|
||||
for (auto it : view)
|
||||
{
|
||||
auto& [key, timer] = *it;
|
||||
|
||||
double t = timer.avg.time * 1'000'000.0;
|
||||
|
||||
draw_row(0.f, row_y, color_flag(t), va(
|
||||
"%8.2f us %8.2f calls - %s",
|
||||
t,
|
||||
timer.avg.calls,
|
||||
key.c_str()
|
||||
));
|
||||
|
||||
row_y += kRowHeight;
|
||||
|
||||
// FIXME this is all ugly and sucks
|
||||
if (row_y >= BASEVIDHEIGHT)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void lua_profile_OnChange(void)
|
||||
{
|
||||
g_invalid = true;
|
||||
|
||||
if (cv_lua_profile.value == 0)
|
||||
{
|
||||
g_tic_timers = {};
|
||||
}
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
// DR. ROBOTNIK'S RING RACERS
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2025 by James Robert Roman
|
||||
// Copyright (C) 2025 by Kart Krew
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef lua_profile_h
|
||||
#define lua_profile_h
|
||||
|
||||
#include "blua/lua.h"
|
||||
#include "doomtype.h"
|
||||
//#include "typedef.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct lua_timer_t;
|
||||
typedef struct lua_timer_t lua_timer_t;
|
||||
|
||||
void LUA_ResetTicTimers(void);
|
||||
|
||||
lua_timer_t *LUA_BeginFunctionTimer(lua_State *L, int fn_idx, const char *name);
|
||||
void LUA_EndFunctionTimer(lua_timer_t *timer);
|
||||
|
||||
void LUA_RenderTimers(void);
|
||||
|
||||
void lua_profile_OnChange(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif/*lua_profile_h*/
|
||||
+15
-25
@@ -62,6 +62,14 @@ static lua_CFunction liblist[] = {
|
||||
NULL
|
||||
};
|
||||
|
||||
// Lua asks for memory using this.
|
||||
static void *LUA_Alloc(void *ud, void *ptr, size_t osize, size_t nsize)
|
||||
{
|
||||
(void)ud;
|
||||
(void)osize;
|
||||
return Z_Realloc(ptr, nsize, PU_LUA, NULL);
|
||||
}
|
||||
|
||||
// Panic function Lua calls when there's an unprotected error.
|
||||
// This function cannot return. Lua would kill the application anyway if it did.
|
||||
FUNCNORETURN static int LUA_Panic(lua_State *L)
|
||||
@@ -189,7 +197,7 @@ void LUA_ClearState(void)
|
||||
CONS_Printf(M_GetText("Pardon me while I initialize the Lua scripting interface...\n"));
|
||||
|
||||
// allocate state
|
||||
L = luaL_newstate();
|
||||
L = lua_newstate(LUA_Alloc, NULL);
|
||||
lua_atpanic(L, LUA_Panic);
|
||||
|
||||
// open base libraries
|
||||
@@ -269,19 +277,20 @@ void LUA_LoadLump(UINT16 wad, UINT16 lump)
|
||||
|
||||
if (wadfiles[wad]->type == RET_LUA)
|
||||
{
|
||||
name = malloc(len + 1);
|
||||
snprintf(name, len + 1, "%s", wadfiles[wad]->filename);
|
||||
name = malloc(len+1);
|
||||
strcpy(name, wadfiles[wad]->filename);
|
||||
}
|
||||
else // If it's not a .lua file, copy the lump name in too.
|
||||
{
|
||||
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);
|
||||
name = malloc(len+1);
|
||||
|
||||
if (!name)
|
||||
I_Error("LUA_LoadLump: Out of memory!\n");
|
||||
|
||||
snprintf(name, len + 1, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
|
||||
sprintf(name, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
|
||||
name[len] = '\0';
|
||||
}
|
||||
|
||||
LUA_LoadFile(&f, name); // actually load file!
|
||||
@@ -365,7 +374,7 @@ void LUA_DumpFile(const char *filename)
|
||||
|
||||
static void createMathLibState(void)
|
||||
{
|
||||
mL = luaL_newstate();
|
||||
mL = lua_newstate(LUA_Alloc, NULL);
|
||||
lua_atpanic(mL, LUA_Panic);
|
||||
|
||||
// open only enum lib
|
||||
@@ -583,7 +592,6 @@ void LUA_InvalidateLevel(void)
|
||||
|
||||
for (i = 0; i < numsubsectors; i++)
|
||||
LUA_InvalidateUserdata(&subsectors[i]);
|
||||
|
||||
for (i = 0; i < numsectors; i++)
|
||||
{
|
||||
LUA_InvalidateUserdata(§ors[i]);
|
||||
@@ -604,7 +612,6 @@ void LUA_InvalidateLevel(void)
|
||||
|
||||
for (i = 0; i < numsides; i++)
|
||||
LUA_InvalidateUserdata(&sides[i]);
|
||||
|
||||
for (i = 0; i < numvertexes; i++)
|
||||
LUA_InvalidateUserdata(&vertexes[i]);
|
||||
|
||||
@@ -615,10 +622,6 @@ void LUA_InvalidateLevel(void)
|
||||
LUA_InvalidateUserdata(&slope->o);
|
||||
LUA_InvalidateUserdata(&slope->d);
|
||||
}
|
||||
|
||||
// We invalidated a lot of userdata objects, a lot of them probably ended up unreachable so they can be
|
||||
// GC'd right away
|
||||
lua_gc(gL, LUA_GCCOLLECT, 0);
|
||||
}
|
||||
|
||||
void LUA_InvalidateMapthings(void)
|
||||
@@ -1457,16 +1460,3 @@ int Lua_CreateFieldTable(lua_State *L, const char *const lst[])
|
||||
|
||||
return luaL_ref(L, LUA_REGISTRYINDEX);
|
||||
}
|
||||
|
||||
size_t LUA_MemoryUsage(void)
|
||||
{
|
||||
size_t usage = 0;
|
||||
|
||||
if (gL)
|
||||
usage += lua_gc(gL, LUA_GCCOUNT, 0);
|
||||
|
||||
if (mL)
|
||||
usage += lua_gc(mL, LUA_GCCOUNT, 0);
|
||||
|
||||
return usage;
|
||||
}
|
||||
@@ -82,9 +82,6 @@ int Lua_optoption(lua_State *L, int narg, int def, int list_ref);
|
||||
int Lua_CreateFieldTable(lua_State *L, const char *const lst[]);
|
||||
void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save);
|
||||
|
||||
// Returns lua memory usage in kbytes
|
||||
size_t LUA_MemoryUsage(void);
|
||||
|
||||
// Console wrapper
|
||||
void COM_Lua_f(void);
|
||||
|
||||
|
||||
+1
-1
@@ -11,7 +11,7 @@
|
||||
|
||||
#include "m_curl.h"
|
||||
#include "doomtype.h"
|
||||
#include "doomdef.h" // I_OutputMsg
|
||||
#include "i_system.h" // I_OutputMsg
|
||||
#include "m_argv.h" // M_CheckParm, M_GetNextParm
|
||||
|
||||
static boolean curl_args_init = false;
|
||||
|
||||
+118
-141
@@ -616,7 +616,7 @@ void Nextmap_OnChange(void)
|
||||
if (!gpath)
|
||||
return;
|
||||
|
||||
snprintf(gpath, glen, "%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value));
|
||||
sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value));
|
||||
|
||||
CV_StealthSetValue(&cv_dummystaff, 0);
|
||||
|
||||
@@ -735,7 +735,7 @@ static void Dummystaff_OnChange(void)
|
||||
while (*temp)
|
||||
temp++;
|
||||
|
||||
snprintf(temp, sizeof(dummystaffname) - (size_t)(temp - dummystaffname), " - %d", cv_dummystaff.value);
|
||||
sprintf(temp, " - %d", cv_dummystaff.value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -825,8 +825,7 @@ static void M_ChangeCvar(INT32 choice)
|
||||
float increment;
|
||||
|
||||
increment = FIXED_TO_FLOAT(cv->value)+(choice)*((currentMenu->menuitems[itemOn].status & IT_CV_BIGFLOAT) ? 0.5f : (1.0f/16.0f));
|
||||
snprintf(s, sizeof(s), "%ld%s", (long)increment, M_Ftrim(increment));
|
||||
|
||||
sprintf(s,"%ld%s",(long)increment,M_Ftrim(increment));
|
||||
CV_Set(cv, s);
|
||||
}
|
||||
else
|
||||
@@ -4186,12 +4185,12 @@ static void PrepReplayList(boolean reset)
|
||||
if (dirmenu[i][DIR_TYPE] == EXT_UP)
|
||||
{
|
||||
demolist_all[i].type = MD_SUBDIR;
|
||||
snprintf(demolist_all[i].title, sizeof(demolist_all[i].title), "UP");
|
||||
sprintf(demolist_all[i].title, "UP");
|
||||
}
|
||||
else if (dirmenu[i][DIR_TYPE] == EXT_FOLDER)
|
||||
{
|
||||
demolist_all[i].type = MD_SUBDIR;
|
||||
snprintf(demolist_all[i].title, sizeof(demolist_all[i].title), "%s", dirmenu[i] + DIR_STRING);
|
||||
strncpy(demolist_all[i].title, dirmenu[i] + DIR_STRING, 64);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -4199,7 +4198,7 @@ static void PrepReplayList(boolean reset)
|
||||
snprintf(demolist_all[i].filepath, sizeof(demolist_all[i].filepath),
|
||||
// 255 = UINT8 limit. dirmenu entries are restricted to this length (see DIR_LEN).
|
||||
"%s%.255s", menupath, dirmenu[i] + DIR_STRING);
|
||||
snprintf(demolist_all[i].title, sizeof(demolist_all[i].title), ".....");
|
||||
sprintf(demolist_all[i].title, ".....");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5767,8 +5766,7 @@ static void M_DrawMusicTest(void)
|
||||
x = 24;
|
||||
y = 64;
|
||||
|
||||
if (renderisnewtic)
|
||||
st_musictime++;
|
||||
if (renderisnewtic) st_musictime++;
|
||||
|
||||
while (t <= b)
|
||||
{
|
||||
@@ -5777,11 +5775,11 @@ static void M_DrawMusicTest(void)
|
||||
|
||||
{
|
||||
const musicdef_t *def = S_GetMusicCredit(t);
|
||||
const size_t MAXLENGTH = 34;
|
||||
const char *songname = def->title[0] ? def->title : def->source;
|
||||
|
||||
size_t namelength = strlen(songname);
|
||||
|
||||
#define MAXLENGTH 34
|
||||
char buf[MAXLENGTH+1];
|
||||
|
||||
if (t == st_sel && namelength > MAXLENGTH)
|
||||
@@ -5790,14 +5788,11 @@ static void M_DrawMusicTest(void)
|
||||
strlcpy(buf, songname, MAXLENGTH);
|
||||
|
||||
V_DrawString(x, y, (t == st_sel ? V_YELLOWMAP : 0)|V_ALLOWLOWERCASE|V_MONOSPACE, buf);
|
||||
|
||||
if (curplaying == def)
|
||||
{
|
||||
V_DrawFill(20+280-9, y-4, 8, 16, 230);
|
||||
}
|
||||
#undef MAXLENGTH
|
||||
}
|
||||
|
||||
t++;
|
||||
y += 16;
|
||||
}
|
||||
@@ -5984,8 +5979,7 @@ static void M_DrawStatsMaps(void)
|
||||
|
||||
V_DrawString(20, 42, highlightflags|MENUCAPS, "Combined time records:");
|
||||
|
||||
snprintf(beststr, sizeof(beststr), "%i:%02i:%02i.%02i", G_TicsToHours(besttime), G_TicsToMinutes(besttime, false), G_TicsToSeconds(besttime), G_TicsToCentiseconds(besttime));
|
||||
|
||||
sprintf(beststr, "%i:%02i:%02i.%02i", G_TicsToHours(besttime), G_TicsToMinutes(besttime, false), G_TicsToSeconds(besttime), G_TicsToCentiseconds(besttime));
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH-16, 42, (mapsunfinished ? warningflags : 0), beststr);
|
||||
|
||||
if (mapsunfinished)
|
||||
@@ -6451,7 +6445,7 @@ static void M_ChooseTimeAttack(INT32 choice)
|
||||
else
|
||||
G_RecordDemo(nameofdemo);
|
||||
|
||||
G_DeferedInitNew(false, mapname, (skinnum_t)(cv_chooseskin.value-1), 0, false);
|
||||
G_DeferedInitNew(false, mapname, (UINT8)(cv_chooseskin.value-1), 0, false);
|
||||
}
|
||||
|
||||
static void M_HandleStaffReplay(INT32 choice)
|
||||
@@ -7152,7 +7146,7 @@ static void M_CheckMODVersion(int id)
|
||||
|
||||
if (updatecheck)
|
||||
{
|
||||
snprintf(updatestring, sizeof(updatestring), UPDATE_ALERT_STRING, VERSIONSTRING, updatecheck);
|
||||
sprintf(updatestring, UPDATE_ALERT_STRING, VERSIONSTRING, updatecheck);
|
||||
#ifdef HAVE_THREADS
|
||||
I_lock_mutex(&m_menu_mutex);
|
||||
#endif
|
||||
@@ -7650,8 +7644,11 @@ static void M_DrawMPMainMenu(void)
|
||||
// use generic drawer for cursor, items and title
|
||||
M_DrawGenericMenu();
|
||||
|
||||
#if MAXPLAYERS != 16
|
||||
Update the maxplayers label...
|
||||
#endif
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH-x, y+MP_MainMenu[4].alphaKey,
|
||||
((itemOn == 4) ? highlightflags : 0)|MENUCAPS, va("(2-%d Players)", MAXPLAYERS));
|
||||
((itemOn == 4) ? highlightflags : 0)|MENUCAPS, "(2-16 Players)");
|
||||
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH-x, y+MP_MainMenu[5].alphaKey,
|
||||
((itemOn == 5) ? highlightflags : 0)|MENUCAPS,
|
||||
@@ -7667,7 +7664,7 @@ static void M_DrawMPMainMenu(void)
|
||||
{
|
||||
char buf[28];
|
||||
strlcpy(buf, setupm_ip, sizeof(buf));
|
||||
V_DrawString(x+8, y+12, V_ALLOWLOWERCASE, buf);
|
||||
V_DrawString(x+8,y+12, V_ALLOWLOWERCASE, buf);
|
||||
}
|
||||
else
|
||||
M_DrawTextInputScroll(x+8, y+12, &setupm_input_ip, 0, SETUPM_IP_MAXSIZE);
|
||||
@@ -7677,7 +7674,7 @@ static void M_DrawMPMainMenu(void)
|
||||
#define iconwidth 32
|
||||
#define spacingwidth 32
|
||||
#define incrwidth (iconwidth + spacingwidth)
|
||||
UINT16 i = 0, pskin, pcol;
|
||||
UINT8 i = 0, pskin, pcol;
|
||||
// player arrangement width, but there's also a chance i'm a furry, shhhhhh
|
||||
const INT32 paw = iconwidth + 3*incrwidth;
|
||||
INT32 trans = 0;
|
||||
@@ -7930,16 +7927,16 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
spritedef_t *sprdef;
|
||||
spriteframe_t *sprframe;
|
||||
patch_t *patch;
|
||||
UINT16 frame;
|
||||
UINT16 speed;
|
||||
UINT16 weight;
|
||||
UINT16 i;
|
||||
UINT16 s, w;
|
||||
UINT8 frame;
|
||||
UINT8 speed;
|
||||
UINT8 weight;
|
||||
UINT8 i;
|
||||
UINT8 s, w;
|
||||
INT32 skinnum = 0;
|
||||
INT32 statx, staty;
|
||||
UINT32 speenframe;
|
||||
INT32 sltw, actw, hetw;
|
||||
skinnum_t skintodisplay;
|
||||
UINT8 skintodisplay;
|
||||
INT32 nameboxaddy = 0;
|
||||
|
||||
const UINT8 *flashcol = V_GetStringColormap(highlightflags);
|
||||
@@ -7996,7 +7993,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
break;
|
||||
case SKINMENUTYPE_2D:
|
||||
|
||||
skintodisplay = (skinnum_t)setupm_fakeskin;
|
||||
skintodisplay = setupm_fakeskin;
|
||||
if (setupm_skinlockedselect) //show the skin we are trying to select
|
||||
skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][setupm_skinselect];
|
||||
else if (skinstatscount[setupm_skinxpos][setupm_skinypos] && itemOn == 1)
|
||||
@@ -8205,12 +8202,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
case SKINMENUTYPE_EXTENDED:
|
||||
for (s = 0; s < SKINGRIDNEWWIDTH*SKINGRIDNEWHEIGHT; s++)
|
||||
{
|
||||
INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + 10); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH);
|
||||
INT32 skinn;
|
||||
patch_t *face;
|
||||
UINT8 *cmap;
|
||||
const INT32 x = ((s % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
const INT32 y = ((s / SKINGRIDNEWWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2)) + 10); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
const INT32 calcs = s + (setupm_skinypos * SKINGRIDNEWWIDTH);
|
||||
|
||||
if (calcs < numskins)
|
||||
skinn = skinsorted[calcs];
|
||||
@@ -8231,10 +8228,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
if (itemOn == 1) //has to be on skin select part
|
||||
{
|
||||
patch_t *cursor;
|
||||
const INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
|
||||
const INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ 10);
|
||||
INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
|
||||
INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ 10);
|
||||
|
||||
const UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
|
||||
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
|
||||
}
|
||||
@@ -8243,9 +8240,9 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
case SKINMENUTYPE_GRID:
|
||||
for (s = 0; s < SKINGRIDWIDTH*SKINGRIDHEIGHT; s++)
|
||||
{
|
||||
const INT32 x = ((s % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
const INT32 y = ((s / SKINGRIDWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2))); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
const INT32 calcs = s + (setupm_skinypos * SKINGRIDWIDTH);
|
||||
INT32 x = ((s % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH) - 8) + 100 + SKINXSHIFT; //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 y = ((s / SKINGRIDWIDTH) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2))); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 calcs = s + (setupm_skinypos * SKINGRIDWIDTH);
|
||||
INT16 skinn;
|
||||
patch_t *face;
|
||||
UINT8 *cmap;
|
||||
@@ -8269,44 +8266,36 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
if (itemOn == 1) //has to be on skin select part
|
||||
{
|
||||
patch_t *cursor;
|
||||
const INT32 curx = (((setupm_skinselect % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH/2)) + SKINXSHIFT) + 20;
|
||||
const INT32 cury = (((setupm_skinselect / SKINGRIDWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2)));
|
||||
INT32 curx = (((setupm_skinselect % SKINGRIDWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDWIDTH/2)) + SKINXSHIFT) + 20;
|
||||
INT32 cury = (((setupm_skinselect / SKINGRIDWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDWIDTH/2)));
|
||||
|
||||
if (setupm_skinselect < numskins)
|
||||
{
|
||||
const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
|
||||
UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
|
||||
cursor = facewantprefix[skinsorted[setupm_skinselect]];
|
||||
V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
const UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
|
||||
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
{ // stat dot
|
||||
const INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
|
||||
|
||||
INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
|
||||
speed = skins[selectedskin].kartspeed;
|
||||
weight = skins[selectedskin].kartweight;
|
||||
|
||||
const INT32 x = (((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1);
|
||||
const INT32 y = (((staty+71) + (weight*4))<<FRACBITS);
|
||||
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
|
||||
|
||||
if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
|
||||
V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, flashcol);
|
||||
V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, flashcol);
|
||||
else
|
||||
V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, NULL);
|
||||
V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
|
||||
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
|
||||
if (setupm_fakecolor)
|
||||
{
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
|
||||
V_DrawFixedPatch(x, y, FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
|
||||
}
|
||||
V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
|
||||
}
|
||||
break;
|
||||
case SKINMENUTYPE_2D:
|
||||
@@ -8315,13 +8304,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
{
|
||||
for (w = 0; w < MAXSTAT; w++)
|
||||
{
|
||||
INT32 x = ((s * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 y = ((w * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
INT32 skinn;
|
||||
patch_t *face;
|
||||
UINT8 *cmap;
|
||||
|
||||
const INT32 x = ((s * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
const INT32 y = ((w * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8); //BASEVIDWIDTH / 2 - ((icons + 1) * 24) - 4;
|
||||
|
||||
if (!skinstatscount[s][w])
|
||||
{
|
||||
V_DrawFill(x, y, 16, 16, 239);
|
||||
@@ -8339,20 +8327,20 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
if (itemOn == 1) //has to be on skin select part
|
||||
{
|
||||
patch_t *cursor;
|
||||
const INT32 curx = ((setupm_skinxpos * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT);
|
||||
const INT32 cury = ((setupm_skinypos * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8);
|
||||
INT32 curx = ((setupm_skinxpos * 18) + ((BASEVIDWIDTH / 2) - (18 * 4)) - 8 + SKINXSHIFT);
|
||||
INT32 cury = ((setupm_skinypos * 18) + ((BASEVIDHEIGHT / 2) - (18 * 4)) - 8);
|
||||
|
||||
if (skinstatscount[setupm_skinxpos][setupm_skinypos])
|
||||
{
|
||||
const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
|
||||
const INT32 skinn = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime() / TICRATE) % skinstatscount[setupm_skinxpos][setupm_skinypos]];
|
||||
UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
|
||||
INT32 skinn = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime() / TICRATE) % skinstatscount[setupm_skinxpos][setupm_skinypos]];
|
||||
|
||||
cursor = facewantprefix[skinn];
|
||||
V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
const UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
UINT8 cursorframe = (I_GetTime() / 4) % 7;
|
||||
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
|
||||
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
|
||||
}
|
||||
@@ -8360,26 +8348,18 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
break;
|
||||
#undef SKINXSHIFT
|
||||
default:
|
||||
{
|
||||
speed = skins[setupm_fakeskin].kartspeed;
|
||||
weight = skins[setupm_fakeskin].kartweight;
|
||||
speed = skins[setupm_fakeskin].kartspeed;
|
||||
weight = skins[setupm_fakeskin].kartweight;
|
||||
|
||||
const INT32 x = ((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS;
|
||||
const INT32 y = ((my+76) + ((weight-1)*8))<<FRACBITS;
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
|
||||
if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
|
||||
V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, flashcol);
|
||||
else
|
||||
V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, NULL);
|
||||
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT1", PU_PATCH);
|
||||
|
||||
if (skullAnimCounter < 4) // SRB2Kart: we draw this dot later so that it's not covered if there's multiple skins with the same stats
|
||||
V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, flashcol);
|
||||
else
|
||||
V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, NULL);
|
||||
|
||||
if (setupm_fakecolor)
|
||||
{
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
|
||||
V_DrawFixedPatch(x, y, FRACUNIT, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
|
||||
}
|
||||
}
|
||||
statdot = (patch_t *)W_CachePatchName("K_SDOT2", PU_PATCH); // coloured center
|
||||
if (setupm_fakecolor)
|
||||
V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, R_GetTranslationColormap(0, setupm_fakecolor, GTC_MENUCACHE));
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -8393,7 +8373,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
colwidth = colwidth - 10;
|
||||
|
||||
INT32 j = -colwidth;
|
||||
INT32 col = setupm_fakecolor - colwidth;
|
||||
INT16 col = setupm_fakecolor - colwidth;
|
||||
INT32 x = mx;
|
||||
INT32 cw = indexwidth;
|
||||
UINT8 ch;
|
||||
@@ -8406,13 +8386,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
cw = charw;
|
||||
else
|
||||
cw = indexwidth;
|
||||
|
||||
for (ch = 0; ch < 16; ch++)
|
||||
V_DrawFill(x, my+(cv_skinselectmenu.value?176:162)+ch, cw, 1, colortranslations[col][ch]);
|
||||
|
||||
if (++col >= MAXSKINCOLORS)
|
||||
col -= MAXSKINCOLORS-1;
|
||||
|
||||
x += cw;
|
||||
}
|
||||
}
|
||||
@@ -8424,7 +8401,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
{
|
||||
const INT32 icons = 4;
|
||||
INT32 k = -icons;
|
||||
INT32 col = setupm_fakeskin - icons;
|
||||
INT16 col = setupm_fakeskin - icons;
|
||||
INT32 x = BASEVIDWIDTH/2 - ((icons+1)*24) - 4;
|
||||
fixed_t scale = FRACUNIT/2;
|
||||
INT32 offx = 8, offy = 8;
|
||||
@@ -8440,7 +8417,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
|
||||
if (col < 0)
|
||||
col += numskins;
|
||||
|
||||
while (k <= icons)
|
||||
{
|
||||
if (!(k++))
|
||||
@@ -8457,16 +8433,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
offx = 8;
|
||||
offy = 8;
|
||||
}
|
||||
|
||||
colmap = R_GetTranslationColormap(col, setupm_fakecolor, GTC_MENUCACHE);
|
||||
V_DrawFixedPatch((x+offx)<<FRACBITS, (my+28+offy)<<FRACBITS, FRACUNIT, 0, face, colmap);
|
||||
|
||||
if (scale == FRACUNIT) // bit of a hack
|
||||
V_DrawFixedPatch((x+offx)<<FRACBITS, (my+28+offy)<<FRACBITS, FRACUNIT, 0, cursor, colmap);
|
||||
|
||||
if (++col >= numskins)
|
||||
col -= numskins;
|
||||
|
||||
x += FixedMul(iconwidth<<FRACBITS, 3*scale/2)/FRACUNIT;
|
||||
}
|
||||
}
|
||||
@@ -8492,7 +8464,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
switch (cv_skinselectmenu.value)
|
||||
{
|
||||
case SKINMENUTYPE_2D:
|
||||
skintodisplay = (skinnum_t)setupm_fakeskin;
|
||||
skintodisplay = (UINT8)setupm_fakeskin;
|
||||
if (setupm_skinlockedselect) // show the skin we are trying to select
|
||||
skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][setupm_skinselect];
|
||||
else if (skinstatscount[setupm_skinxpos][setupm_skinypos] && itemOn == 1)
|
||||
@@ -8500,10 +8472,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
break;
|
||||
case SKINMENUTYPE_EXTENDED:
|
||||
case SKINMENUTYPE_GRID:
|
||||
skintodisplay = ((itemOn == 1 && (setupm_skinselect < numskins)) ? skinsorted[setupm_skinselect] : (skinnum_t)setupm_fakeskin);
|
||||
skintodisplay = ((itemOn == 1 && (setupm_skinselect < numskins)) ? skinsorted[setupm_skinselect] : (UINT8)setupm_fakeskin);
|
||||
break;
|
||||
default:
|
||||
skintodisplay = (skinnum_t)setupm_fakeskin;
|
||||
skintodisplay = (UINT8)setupm_fakeskin;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -8607,7 +8579,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
}
|
||||
else
|
||||
M_NextOpt();
|
||||
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
}
|
||||
@@ -8634,7 +8605,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
{
|
||||
M_NextOpt();
|
||||
}
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
}
|
||||
else if (itemOn == 0)
|
||||
@@ -8645,11 +8615,9 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
}
|
||||
else
|
||||
M_NextOpt();
|
||||
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
}
|
||||
|
||||
M_NextOpt();
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
@@ -8667,7 +8635,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
}
|
||||
else
|
||||
M_PrevOpt();
|
||||
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
}
|
||||
@@ -8686,7 +8653,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
{
|
||||
M_PrevOpt();
|
||||
}
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
}
|
||||
else if (itemOn == 2)
|
||||
@@ -8706,11 +8672,9 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
}
|
||||
else
|
||||
M_PrevOpt();
|
||||
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
}
|
||||
|
||||
M_PrevOpt();
|
||||
S_StartSound(NULL, sfx_menu1); // Tails
|
||||
break;
|
||||
@@ -8729,7 +8693,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
setupm_skinselect--;
|
||||
else
|
||||
setupm_skinselect = SELECTEDSTATSCOUNT - 1;
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
}
|
||||
else //player skin
|
||||
@@ -8762,7 +8725,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
else if (cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED)
|
||||
setupm_skinypos = (((roundedskins/8) - SKINGRIDHEIGHT-2) > 0 ? (roundedskins/8) - SKINGRIDHEIGHT-2 : 0);
|
||||
}
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
break;
|
||||
}
|
||||
@@ -8793,7 +8755,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
setupm_skinselect++;
|
||||
else
|
||||
setupm_skinselect = 0;
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
}
|
||||
else //player skin
|
||||
@@ -8828,7 +8789,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
setupm_skinselect = 0;
|
||||
setupm_skinypos = 0;
|
||||
}
|
||||
|
||||
S_StartSound(NULL, sfx_menu1);
|
||||
break;
|
||||
}
|
||||
@@ -8851,14 +8811,12 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
setupm_skinlockedselect = false;
|
||||
break;
|
||||
}
|
||||
|
||||
exitmenu = true;
|
||||
break;
|
||||
|
||||
case KEY_BACKSPACE:
|
||||
if (cv_skinselectmenu.value)
|
||||
BREAKWHENLOCKED
|
||||
|
||||
if (itemOn == 0)
|
||||
{
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
@@ -8888,7 +8846,6 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
case KEY_DEL:
|
||||
if (cv_skinselectmenu.value)
|
||||
BREAKWHENLOCKED
|
||||
|
||||
if (itemOn == 0)
|
||||
{
|
||||
M_TextInputHandle(&setupm_input, choice);
|
||||
@@ -9205,7 +9162,7 @@ static void M_DrawJoystick(void)
|
||||
compareval4 = cv_usejoystick[3].value;
|
||||
compareval3 = cv_usejoystick[2].value;
|
||||
compareval2 = cv_usejoystick[1].value;
|
||||
compareval = cv_usejoystick[0].value;
|
||||
compareval = cv_usejoystick[0].value;
|
||||
#endif
|
||||
|
||||
if ((setupcontrolplayer == 4 && (i == compareval4))
|
||||
@@ -9244,13 +9201,14 @@ void M_SetupJoystickMenu(INT32 choice)
|
||||
//
|
||||
// Update cv_usejoystick.string here so that the user can
|
||||
// properly change this value.
|
||||
for (INT32 f = 0; f < MAXSPLITSCREENPLAYERS; f++)
|
||||
{
|
||||
if (i == cv_usejoystick[f].value)
|
||||
{
|
||||
CV_SetValue(&cv_usejoystick[f], i);
|
||||
}
|
||||
}
|
||||
if (i == cv_usejoystick[0].value)
|
||||
CV_SetValue(&cv_usejoystick[0], i);
|
||||
if (i == cv_usejoystick[1].value)
|
||||
CV_SetValue(&cv_usejoystick[1], i);
|
||||
if (i == cv_usejoystick[2].value)
|
||||
CV_SetValue(&cv_usejoystick[2], i);
|
||||
if (i == cv_usejoystick[3].value)
|
||||
CV_SetValue(&cv_usejoystick[3], i);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -9289,11 +9247,9 @@ static void M_Setup4PJoystickMenu(INT32 choice)
|
||||
static void M_DoAssignJoystick(UINT8 pnum, INT32 choice)
|
||||
{
|
||||
INT32 oldchoice, oldstringchoice;
|
||||
const int joynum = atoi(cv_usejoystick[pnum].string);
|
||||
|
||||
#define joystrnum (atoi(cv_usejoystick[pnum].string))
|
||||
#define joyoldchoice ((joystrnum > numcontrollers) ? joystrnum : cv_usejoystick[pnum].value)
|
||||
|
||||
oldchoice = oldstringchoice = joyoldchoice;
|
||||
oldchoice = oldstringchoice = joynum > numcontrollers ? joynum : cv_usejoystick[pnum].value;
|
||||
CV_SetValue(&cv_usejoystick[pnum], choice);
|
||||
|
||||
// Just in case last-minute changes were made to cv_usejoystick.value,
|
||||
@@ -9303,37 +9259,59 @@ static void M_DoAssignJoystick(UINT8 pnum, INT32 choice)
|
||||
{
|
||||
CV_SetValue(&cv_usejoystick[pnum], cv_usejoystick[pnum].value);
|
||||
|
||||
// reset this so the comparison is valid
|
||||
if (oldchoice > numcontrollers)
|
||||
if (oldchoice > numcontrollers) /* reset this so the comparison is valid*/
|
||||
oldchoice = cv_usejoystick[pnum].value;
|
||||
|
||||
if (oldchoice != choice)
|
||||
{
|
||||
if (choice && oldstringchoice > numcontrollers) // if we did not select "None", we likely selected a used device
|
||||
{
|
||||
CV_SetValue(&cv_usejoystick[pnum], ((oldstringchoice > numcontrollers) ? oldstringchoice : oldchoice));
|
||||
}
|
||||
CV_SetValue(&cv_usejoystick[pnum], (oldstringchoice > numcontrollers ? oldstringchoice : oldchoice));
|
||||
|
||||
if (oldstringchoice == joyoldchoice)
|
||||
{
|
||||
if (oldstringchoice ==
|
||||
(joynum > numcontrollers ? joynum : cv_usejoystick[pnum].value))
|
||||
M_StartMessage("This joystick is used by another\n"
|
||||
"player. Reset the joystick\n"
|
||||
"for that player first.\n\n"
|
||||
"(Press a key)\n", NULL, MM_NOTHING);
|
||||
}
|
||||
}
|
||||
}
|
||||
#undef joystrnum
|
||||
#undef joyoldchoice
|
||||
}
|
||||
#endif
|
||||
|
||||
static void M_AssignJoystick(INT32 choice)
|
||||
{
|
||||
#ifdef JOYSTICK_HOTPLUG
|
||||
M_DoAssignJoystick((setupcontrolplayer-1), choice);
|
||||
switch (setupcontrolplayer)
|
||||
{
|
||||
case 4:
|
||||
M_DoAssignJoystick(3, choice);
|
||||
break;
|
||||
case 3:
|
||||
M_DoAssignJoystick(2, choice);
|
||||
break;
|
||||
case 2:
|
||||
M_DoAssignJoystick(1, choice);
|
||||
break;
|
||||
case 1:
|
||||
M_DoAssignJoystick(0, choice);
|
||||
break;
|
||||
}
|
||||
#else
|
||||
CV_SetValue(&cv_usejoystick[(setupcontrolplayer-1)], choice);
|
||||
switch (setupcontrolplayer)
|
||||
{
|
||||
case 4:
|
||||
CV_SetValue(&cv_usejoystick[3], choice);
|
||||
break;
|
||||
case 3:
|
||||
CV_SetValue(&cv_usejoystick[2], choice);
|
||||
break;
|
||||
case 2:
|
||||
CV_SetValue(&cv_usejoystick[1], choice);
|
||||
break;
|
||||
case 1:
|
||||
CV_SetValue(&cv_usejoystick[0], choice);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -9371,7 +9349,7 @@ static void M_SetupControlsMenu(UINT8 pnum)
|
||||
{
|
||||
// Hide P1-only controls
|
||||
OP_AllControlsMenu[19].status = IT_GRAYEDOUT2; // Chat
|
||||
OP_AllControlsMenu[20].status = IT_GRAYEDOUT2; // Rankings
|
||||
OP_AllControlsMenu[10].status = IT_GRAYEDOUT2; // Rankings
|
||||
OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Pause
|
||||
OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // Screenshot
|
||||
OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // GIF
|
||||
@@ -9383,7 +9361,7 @@ static void M_SetupControlsMenu(UINT8 pnum)
|
||||
{
|
||||
// Unhide P1-only controls
|
||||
OP_AllControlsMenu[19].status = IT_CONTROL; // Chat
|
||||
OP_AllControlsMenu[20].status = IT_CONTROL; // Rankings
|
||||
OP_AllControlsMenu[10].status = IT_CONTROL; // Rankings
|
||||
OP_AllControlsMenu[21].status = IT_CONTROL; // Pause
|
||||
OP_AllControlsMenu[22].status = IT_CONTROL; // Screenshot
|
||||
OP_AllControlsMenu[23].status = IT_CONTROL; // GIF
|
||||
@@ -9620,13 +9598,11 @@ static void M_ChangecontrolResponse(event_t *ev)
|
||||
menu_t *prev = currentMenu->prevMenu;
|
||||
|
||||
if (controltochange == gc_pause)
|
||||
{
|
||||
snprintf(tmp, sizeof(tmp), M_GetText("The \x82Pause Key \x80is enabled, but \nyou may select another key. \n\nHit another key for\n%s\nESC for Cancel"), controltochangetext);
|
||||
}
|
||||
sprintf(tmp, M_GetText("The \x82Pause Key \x80is enabled, but \nyou may select another key. \n\nHit another key for\n%s\nESC for Cancel"),
|
||||
controltochangetext);
|
||||
else
|
||||
{
|
||||
snprintf(tmp, sizeof(tmp), M_GetText("The \x82Pause Key \x80is enabled, but \nit is not configurable. \n\nHit another key for\n%s\nESC for Cancel"), controltochangetext);
|
||||
}
|
||||
sprintf(tmp, M_GetText("The \x82Pause Key \x80is enabled, but \nit is not configurable. \n\nHit another key for\n%s\nESC for Cancel"),
|
||||
controltochangetext);
|
||||
|
||||
M_StartMessage(tmp, M_ChangecontrolResponse, MM_EVENTHANDLER);
|
||||
currentMenu->prevMenu = prev;
|
||||
@@ -9647,7 +9623,8 @@ static void M_ChangeControl(INT32 choice)
|
||||
static char tmp[68];
|
||||
|
||||
controltochange = currentMenu->menuitems[choice].alphaKey;
|
||||
snprintf(tmp, sizeof(tmp), M_GetText("Hit the new key for\n%s\nESC for Cancel"), currentMenu->menuitems[choice].text);
|
||||
sprintf(tmp, M_GetText("Hit the new key for\n%s\nESC for Cancel"),
|
||||
currentMenu->menuitems[choice].text);
|
||||
strlcpy(controltochangetext, currentMenu->menuitems[choice].text, 33);
|
||||
|
||||
M_StartMessage(tmp, M_ChangecontrolResponse, MM_EVENTHANDLER);
|
||||
@@ -10079,7 +10056,7 @@ static void M_DrawColorMenu(void)
|
||||
|
||||
for (max = currentMenu->numitems; max > 0; max--)
|
||||
{
|
||||
if (currentMenu->menuitems[max-1].status != IT_DISABLED && currentMenu->menuitems[max-1].alphaKey*2 + tempcentery <= (currentMenu->y + 2*scrollareaheight))
|
||||
if (currentMenu->menuitems[max].status != IT_DISABLED && currentMenu->menuitems[max-1].alphaKey*2 + tempcentery <= (currentMenu->y + 2*scrollareaheight))
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -230,8 +230,8 @@ typedef struct
|
||||
char levelname[32];
|
||||
UINT8 actnum;
|
||||
UINT8 skincolor;
|
||||
skinnum_t skinnum;
|
||||
skinnum_t botskin;
|
||||
UINT8 skinnum;
|
||||
UINT8 botskin;
|
||||
UINT8 botcolor;
|
||||
UINT8 numemeralds;
|
||||
INT32 lives;
|
||||
|
||||
+18
-19
@@ -515,8 +515,8 @@ static boolean M_BackupConfig(const char *filename)
|
||||
{
|
||||
char backupfile[MAX_WADPATH+4];
|
||||
|
||||
snprintf(backupfile, sizeof(backupfile), "%s.bak", filename);
|
||||
backupfile[sizeof(backupfile) - 1] = '\0';
|
||||
snprintf(backupfile, sizeof backupfile, "%s.bak", filename);
|
||||
backupfile[sizeof backupfile - 1] = '\0';
|
||||
|
||||
FILE *config = fopen(filename, "r");
|
||||
|
||||
@@ -766,27 +766,27 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
|
||||
}
|
||||
|
||||
if (gamestate == GS_LEVEL)
|
||||
snprintf(maptext, sizeof(maptext), "%s", G_BuildMapName(gamemap));
|
||||
snprintf(maptext, 8, "%s", G_BuildMapName(gamemap));
|
||||
else
|
||||
snprintf(maptext, sizeof(maptext), "Unknown");
|
||||
snprintf(maptext, 8, "Unknown");
|
||||
|
||||
if (gamestate == GS_LEVEL && mapheaderinfo[gamemap-1]->lvlttl[0] != '\0')
|
||||
snprintf(lvlttltext, sizeof(lvlttltext), "%s%s%s",
|
||||
snprintf(lvlttltext, 48, "%s%s%s",
|
||||
mapheaderinfo[gamemap-1]->lvlttl,
|
||||
(strlen(mapheaderinfo[gamemap-1]->zonttl) > 0) ? va(" %s",mapheaderinfo[gamemap-1]->zonttl) : // SRB2kart
|
||||
((mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE) ? "" : " ZONE"),
|
||||
(strlen(mapheaderinfo[gamemap-1]->actnum) > 0) ? va(" %s",mapheaderinfo[gamemap-1]->actnum) : "");
|
||||
else
|
||||
snprintf(lvlttltext, sizeof(lvlttltext), "Unknown");
|
||||
snprintf(lvlttltext, 48, "Unknown");
|
||||
|
||||
if (gamestate == GS_LEVEL && players[displayplayers[0]].mo)
|
||||
snprintf(locationtxt, sizeof(locationtxt), "X:%d Y:%d Z:%d A:%d",
|
||||
snprintf(locationtxt, 40, "X:%d Y:%d Z:%d A:%d",
|
||||
players[displayplayers[0]].mo->x>>FRACBITS,
|
||||
players[displayplayers[0]].mo->y>>FRACBITS,
|
||||
players[displayplayers[0]].mo->z>>FRACBITS,
|
||||
FixedInt(AngleFixed(players[displayplayers[0]].mo->angle)));
|
||||
else
|
||||
snprintf(locationtxt, sizeof(locationtxt), "Unknown");
|
||||
snprintf(locationtxt, 40, "Unknown");
|
||||
|
||||
memset(png_infotext, 0x00, sizeof(png_infotext));
|
||||
|
||||
@@ -1253,6 +1253,7 @@ boolean M_ScreenshotResponder(event_t *ev)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void M_ScrollString(const char name[], size_t len, char result[], size_t maxlen, tic_t timer)
|
||||
{
|
||||
// How much should we scroll. Not sure why +1 is needed, but without it this function skips 2
|
||||
@@ -1260,7 +1261,7 @@ void M_ScrollString(const char name[], size_t len, char result[], size_t maxlen,
|
||||
const size_t amount = len - maxlen + 1;
|
||||
|
||||
// Note: anything above 17 will cause zero division
|
||||
static const size_t MAXSPEED = 6;
|
||||
const size_t MAXSPEED = 6;
|
||||
const tic_t t = timer / (35/min(amount, MAXSPEED));
|
||||
|
||||
const size_t state = (t / amount) % 4;
|
||||
@@ -1295,7 +1296,7 @@ void M_ScrollString(const char name[], size_t len, char result[], size_t maxlen,
|
||||
}
|
||||
|
||||
// Technically not necessary, since it gets set again after function call, but just in case
|
||||
result[maxlen-1] = '\0';
|
||||
result[maxlen] = 0;
|
||||
}
|
||||
|
||||
void M_MinimapGenerate(void)
|
||||
@@ -1393,7 +1394,7 @@ char *va(const char *format, ...)
|
||||
static char string[1024];
|
||||
|
||||
va_start(argptr, format);
|
||||
vsnprintf(string, sizeof(string), format, argptr);
|
||||
vsnprintf(string, 1024, format, argptr);
|
||||
va_end(argptr);
|
||||
|
||||
return string;
|
||||
@@ -1707,7 +1708,7 @@ const char * M_Ftrim(double f)
|
||||
int i;
|
||||
|
||||
/* I know I said it's the default, but just in case... */
|
||||
snprintf(dig, sizeof(dig), "%.6f", fabs(modf(f, &f)));
|
||||
sprintf(dig, "%.6f", fabs(modf(f, &f)));
|
||||
|
||||
/* trim trailing zeroes */
|
||||
for (i = strlen(dig)-1; dig[i] == '0'; --i)
|
||||
@@ -1735,7 +1736,6 @@ UINT8 M_CountBits(UINT32 num, UINT8 size)
|
||||
const char *GetRevisionString(void)
|
||||
{
|
||||
static char rev[9] = {0};
|
||||
|
||||
if (rev[0])
|
||||
return rev;
|
||||
|
||||
@@ -1743,7 +1743,6 @@ const char *GetRevisionString(void)
|
||||
strncpy(rev, comprevision, 7);
|
||||
else
|
||||
snprintf(rev, 7, "r%s", comprevision);
|
||||
|
||||
rev[7] = '\0';
|
||||
|
||||
return rev;
|
||||
@@ -1815,35 +1814,35 @@ TMatrix *RotateZMatrix(angle_t rad)
|
||||
char *sizeu1(size_t num)
|
||||
{
|
||||
static char sizeu1_buf[28];
|
||||
snprintf(sizeu1_buf, sizeof(sizeu1_buf), "%" PRIdS, num);
|
||||
sprintf(sizeu1_buf, "%"PRIdS, num);
|
||||
return sizeu1_buf;
|
||||
}
|
||||
|
||||
char *sizeu2(size_t num)
|
||||
{
|
||||
static char sizeu2_buf[28];
|
||||
snprintf(sizeu2_buf, sizeof(sizeu2_buf), "%" PRIdS, num);
|
||||
sprintf(sizeu2_buf, "%"PRIdS, num);
|
||||
return sizeu2_buf;
|
||||
}
|
||||
|
||||
char *sizeu3(size_t num)
|
||||
{
|
||||
static char sizeu3_buf[28];
|
||||
snprintf(sizeu3_buf, sizeof(sizeu3_buf), "%" PRIdS, num);
|
||||
sprintf(sizeu3_buf, "%"PRIdS, num);
|
||||
return sizeu3_buf;
|
||||
}
|
||||
|
||||
char *sizeu4(size_t num)
|
||||
{
|
||||
static char sizeu4_buf[28];
|
||||
snprintf(sizeu4_buf, sizeof(sizeu4_buf), "%" PRIdS, num);
|
||||
sprintf(sizeu4_buf, "%"PRIdS, num);
|
||||
return sizeu4_buf;
|
||||
}
|
||||
|
||||
char *sizeu5(size_t num)
|
||||
{
|
||||
static char sizeu5_buf[28];
|
||||
snprintf(sizeu5_buf, sizeof(sizeu5_buf), "%" PRIdS, num);
|
||||
sprintf(sizeu5_buf, "%"PRIdS, num);
|
||||
return sizeu5_buf;
|
||||
}
|
||||
|
||||
|
||||
+56
-42
@@ -47,7 +47,6 @@ struct perfstatrow {
|
||||
static ps_metric_t ps_frametime = {0};
|
||||
|
||||
ps_metric_t ps_tictime = {0};
|
||||
ps_metric_t ps_prevtictime = {0};
|
||||
|
||||
ps_metric_t ps_playerthink_time = {0};
|
||||
ps_metric_t ps_thinkertime = {0};
|
||||
@@ -169,14 +168,14 @@ perfstatrow_t gamelogic_rows[] = {
|
||||
};
|
||||
|
||||
perfstatrow_t thinkercount_rows[] = {
|
||||
{"thnkers" , "Thinkers: ", &ps_thinkercount, PS_LEVEL},
|
||||
{" mobjs " , " Mobjs: ", &ps_mobjcount, PS_LEVEL},
|
||||
{"thnkers", "Thinkers: ", &ps_thinkercount, PS_LEVEL},
|
||||
{" mobjs ", " Mobjs: ", &ps_mobjcount, PS_LEVEL},
|
||||
{" regular", " Regular: ", &ps_regularcount, PS_LEVEL},
|
||||
{" scenery", " Scenery: ", &ps_scenerycount, PS_LEVEL},
|
||||
{" nothink", " Nothink: ", &ps_nothinkcount, PS_HIDE_ZERO|PS_LEVEL},
|
||||
{" precip " , " Precipitation: ", &ps_precipcount, PS_LEVEL},
|
||||
{" other " , " Other: ", &ps_otherthcount, PS_LEVEL},
|
||||
{" remove " , " Pending removal:", &ps_removecount, PS_LEVEL},
|
||||
{" precip ", " Precipitation: ", &ps_precipcount, PS_LEVEL},
|
||||
{" other ", " Other: ", &ps_otherthcount, PS_LEVEL},
|
||||
{" remove ", " Pending removal:", &ps_removecount, PS_LEVEL},
|
||||
{}
|
||||
};
|
||||
|
||||
@@ -606,9 +605,7 @@ static void PS_CountThinkers(void)
|
||||
else if (thinker->function == (actionf_p1)P_MobjThinker)
|
||||
{
|
||||
mobj_t *mobj = (mobj_t*)thinker;
|
||||
|
||||
ps_mobjcount.value.i++;
|
||||
|
||||
if (mobj->flags & MF_NOTHINK)
|
||||
ps_nothinkcount.value.i++;
|
||||
else if (mobj->flags & MF_SCENERY)
|
||||
@@ -627,17 +624,49 @@ static void PS_CountThinkers(void)
|
||||
|
||||
ps_precipcount.value.i++;
|
||||
}
|
||||
|
||||
/*for (i = 0; i < NUM_THINKERLISTS; i++)
|
||||
{
|
||||
for (thinker = thlist[i].next; thinker != &thlist[i]; thinker = thinker->next)
|
||||
{
|
||||
ps_thinkercount.value.i++;
|
||||
if (thinker->function == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
ps_removecount.value.i++;
|
||||
else if (i == THINK_POLYOBJ)
|
||||
ps_polythcount.value.i++;
|
||||
else if (i == THINK_MAIN)
|
||||
ps_mainthcount.value.i++;
|
||||
else if (i == THINK_MOBJ)
|
||||
{
|
||||
if (thinker->function == (actionf_p1)P_MobjThinker)
|
||||
{
|
||||
mobj_t *mobj = (mobj_t*)thinker;
|
||||
ps_mobjcount.value.i++;
|
||||
if (mobj->flags & MF_NOTHINK)
|
||||
ps_nothinkcount.value.i++;
|
||||
else if (mobj->flags & MF_SCENERY)
|
||||
ps_scenerycount.value.i++;
|
||||
else
|
||||
ps_regularcount.value.i++;
|
||||
}
|
||||
}
|
||||
else if (i == THINK_DYNSLOPE)
|
||||
ps_dynslopethcount.value.i++;
|
||||
else if (i == THINK_PRECIP)
|
||||
ps_precipcount.value.i++;
|
||||
}
|
||||
}*/
|
||||
}
|
||||
|
||||
// Update all metrics that are calculated on every tick.
|
||||
void PS_UpdateTickStats(void)
|
||||
{
|
||||
if (cv_perfstats.value == PS_RENDER && cv_ps_samplesize.value > 1)
|
||||
if (cv_perfstats.value == 1 && cv_ps_samplesize.value > 1)
|
||||
{
|
||||
PS_UpdateRowHistories(gamelogicbrief_row, false);
|
||||
}
|
||||
|
||||
if (cv_perfstats.value == PS_LOGIC)
|
||||
if (cv_perfstats.value == 2)
|
||||
{
|
||||
if (PS_IsLevelActive())
|
||||
{
|
||||
@@ -662,25 +691,25 @@ void PS_UpdateTickStats(void)
|
||||
|
||||
if (cv_ps_samplesize.value > 1)
|
||||
{
|
||||
if (cv_perfstats.value >= PS_THINKFRAME && PS_IsLevelActive())
|
||||
if (cv_perfstats.value >= 3 && PS_IsLevelActive())
|
||||
{
|
||||
int i;
|
||||
|
||||
switch (cv_perfstats.value)
|
||||
{
|
||||
case PS_THINKFRAME:
|
||||
case 3:
|
||||
for (i = 0; i < thinkframe_hooks_length; i++)
|
||||
{
|
||||
PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false);
|
||||
}
|
||||
break;
|
||||
case PS_PRETHINKFRAME:
|
||||
case 4:
|
||||
for (i = 0; i < prethinkframe_hooks_length; i++)
|
||||
{
|
||||
PS_UpdateMetricHistory(&prethinkframe_hooks[i].time_taken, true, false);
|
||||
}
|
||||
break;
|
||||
case PS_POSTTHINKFRAME:
|
||||
case 5:
|
||||
for (i = 0; i < postthinkframe_hooks_length; i++)
|
||||
{
|
||||
PS_UpdateMetricHistory(&postthinkframe_hooks[i].time_taken, true, false);
|
||||
@@ -690,7 +719,6 @@ void PS_UpdateTickStats(void)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (cv_perfstats.value)
|
||||
{
|
||||
ps_tick_index++;
|
||||
@@ -721,7 +749,7 @@ static void PS_DrawDescriptorHeader(void)
|
||||
int samples_left = max(ps_frame_samples_left, ps_tick_samples_left);
|
||||
int x, y;
|
||||
|
||||
if (cv_perfstats.value >= PS_THINKFRAME)
|
||||
if (cv_perfstats.value >= 3)
|
||||
{
|
||||
x = 2;
|
||||
y = 0;
|
||||
@@ -837,19 +865,20 @@ static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
|
||||
last_mod_name[0] = '\0';
|
||||
INT32 total = 0;
|
||||
|
||||
// Decide page length based and drawn text on choosen thinker type
|
||||
//Decide page length based and drawn text on choosen thinker type
|
||||
switch (cv_perfstats.value)
|
||||
{
|
||||
case PS_THINKFRAME:
|
||||
case 3:
|
||||
{
|
||||
maxpage = thinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
|
||||
pagestart = min((page - 1)*PAGE_ENTRIES, thinkframe_hooks_length);
|
||||
pageend = min(pagestart + PAGE_ENTRIES, thinkframe_hooks_length);
|
||||
|
||||
V_DrawSmallString(MAX_X-50, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, "ThinkFrame");
|
||||
}
|
||||
break;
|
||||
case PS_PRETHINKFRAME:
|
||||
case 4:
|
||||
{
|
||||
maxpage = prethinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
|
||||
@@ -858,7 +887,7 @@ static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
|
||||
V_DrawSmallString(MAX_X-60, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, "PreThinkFrame");
|
||||
}
|
||||
break;
|
||||
case PS_POSTTHINKFRAME:
|
||||
case 5:
|
||||
{
|
||||
maxpage = postthinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
|
||||
@@ -946,22 +975,7 @@ static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
|
||||
|
||||
void PS_ThinkFrame_Page_OnChange(void)
|
||||
{
|
||||
int maxpage = 0;
|
||||
|
||||
switch (cv_perfstats.value)
|
||||
{
|
||||
case PS_THINKFRAME:
|
||||
maxpage = thinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
break;
|
||||
case PS_PRETHINKFRAME:
|
||||
maxpage = prethinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
break;
|
||||
case PS_POSTTHINKFRAME:
|
||||
maxpage = postthinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
int maxpage = thinkframe_hooks_length/PAGE_ENTRIES + 1;
|
||||
|
||||
if (cv_ps_thinkframe_page.value > maxpage)
|
||||
CV_StealthSetValue(&cv_ps_thinkframe_page, maxpage);
|
||||
@@ -994,18 +1008,18 @@ static void PS_DrawPostThinkFrameStats(void)
|
||||
|
||||
void M_DrawPerfStats(void)
|
||||
{
|
||||
if (cv_perfstats.value == PS_RENDER) // rendering
|
||||
if (cv_perfstats.value == 1) // rendering
|
||||
{
|
||||
PS_UpdateFrameStats();
|
||||
PS_DrawRenderStats();
|
||||
}
|
||||
else if (cv_perfstats.value == PS_LOGIC) // logic
|
||||
else if (cv_perfstats.value == 2) // logic
|
||||
{
|
||||
// PS_UpdateTickStats is called in TryRunTics, since otherwise it would miss
|
||||
// tics when frame skips happen
|
||||
PS_DrawGameLogicStats();
|
||||
}
|
||||
else if (cv_perfstats.value >= PS_THINKFRAME) // lua thinkframe
|
||||
else if (cv_perfstats.value >= 3) // lua thinkframe
|
||||
{
|
||||
if (!PS_IsLevelActive())
|
||||
return;
|
||||
@@ -1022,13 +1036,13 @@ void M_DrawPerfStats(void)
|
||||
|
||||
switch (cv_perfstats.value)
|
||||
{
|
||||
case PS_THINKFRAME:
|
||||
case 3:
|
||||
PS_DrawThinkFrameStats();
|
||||
break;
|
||||
case PS_PRETHINKFRAME:
|
||||
case 4:
|
||||
PS_DrawPreThinkFrameStats();
|
||||
break;
|
||||
case PS_POSTTHINKFRAME:
|
||||
case 5:
|
||||
PS_DrawPostThinkFrameStats();
|
||||
break;
|
||||
default:
|
||||
|
||||
@@ -26,16 +26,6 @@ typedef struct
|
||||
void *history;
|
||||
} ps_metric_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PS_OFF = 0,
|
||||
PS_RENDER,
|
||||
PS_LOGIC,
|
||||
PS_THINKFRAME,
|
||||
PS_PRETHINKFRAME,
|
||||
PS_POSTTHINKFRAME
|
||||
} ps_types_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
ps_metric_t time_taken;
|
||||
@@ -46,7 +36,6 @@ typedef struct
|
||||
#define PS_STOP_TIMING(metric) metric.value.p = I_GetPreciseTime() - metric.value.p
|
||||
|
||||
extern ps_metric_t ps_tictime;
|
||||
extern ps_metric_t ps_prevtictime;
|
||||
|
||||
extern ps_metric_t ps_playerthink_time;
|
||||
extern ps_metric_t ps_thinkertime;
|
||||
|
||||
+2
-2
@@ -238,8 +238,8 @@ void M_TextInputClear(textinput_t *input)
|
||||
|
||||
void M_TextInputSetString(textinput_t *input, const char *c)
|
||||
{
|
||||
strncpy(input->buffer, c, input->buffer_size-1);
|
||||
input->buffer[input->buffer_size-1] = '\0';
|
||||
memset(input->buffer, 0, input->buffer_size);
|
||||
strncpy(input->buffer, c, input->buffer_size);
|
||||
input->cursor = input->select = input->length = strlen(input->buffer);
|
||||
}
|
||||
|
||||
|
||||
+331
-708
File diff suppressed because it is too large.
Load diff
+1
-5
@@ -107,9 +107,6 @@ void P_DoNightsScore(player_t *player)
|
||||
|
||||
dummymo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z+player->mo->height/2, MT_NIGHTSCORE);
|
||||
|
||||
if (P_MobjWasRemovedCompat(dummymo))
|
||||
return;
|
||||
|
||||
if (player->bot)
|
||||
player = &players[consoleplayer];
|
||||
|
||||
@@ -2016,7 +2013,7 @@ static inline void P_NiGHTSDamage(mobj_t *target, mobj_t *source)
|
||||
}
|
||||
}
|
||||
|
||||
static boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
|
||||
static inline boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
|
||||
{
|
||||
player_t *player = target->player;
|
||||
(void)damage; //unused parm
|
||||
@@ -2635,7 +2632,6 @@ void P_PlayerRingBurst(player_t *player, INT32 num_rings)
|
||||
if (i & 1)
|
||||
P_SetObjectMomZ(mo, ns, true);
|
||||
}
|
||||
|
||||
if (player->mo->eflags & MFE_VERTICALFLIP)
|
||||
mo->momz *= -1;
|
||||
}
|
||||
|
||||
+3
-4
@@ -295,10 +295,10 @@ FUNCINLINE static ATTRINLINE boolean P_MobjWasRemoved(const mobj_t *mobj)
|
||||
// so can only check if its not NULL in vanilla compat mode
|
||||
FUNCINLINE static ATTRINLINE boolean P_MobjWasRemovedCompat(const mobj_t *mobj)
|
||||
{
|
||||
#ifdef PHOBOS_BUILD
|
||||
return P_MobjWasRemoved(mobj);
|
||||
#ifdef COMPAT_VANILLA
|
||||
return (!mobj);
|
||||
#else
|
||||
return !mobj;
|
||||
return P_MobjWasRemoved(mobj);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -418,7 +418,6 @@ boolean P_CheckSector(sector_t *sector, boolean crunch);
|
||||
void P_DelSeclist(msecnode_t *node);
|
||||
|
||||
void P_CreateSecNodeList(mobj_t *thing, fixed_t x, fixed_t y);
|
||||
void P_Initsecnode(void);
|
||||
|
||||
void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist);
|
||||
|
||||
|
||||
+7
-39
@@ -245,12 +245,12 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|
||||
|
||||
static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object)
|
||||
{
|
||||
player_t *player = object->player; // will be NULL if not a player
|
||||
player_t *p = object->player; // will be NULL if not a player
|
||||
fixed_t zdist; // distance between bottoms
|
||||
fixed_t speed = spring->info->mass; // conveniently, both fans and gas jets use this for the vertical thrust
|
||||
SINT8 flipval = P_MobjFlip(spring); // virtually everything here centers around the thruster's gravity, not the object's!
|
||||
|
||||
if (player && object->state == &states[object->info->painstate]) // can't use fans and gas jets when player is in pain!
|
||||
if (p && object->state == &states[object->info->painstate]) // can't use fans and gas jets when player is in pain!
|
||||
return;
|
||||
|
||||
// is object's top below thruster's position? if not, calculate distance between their bottoms
|
||||
@@ -276,7 +276,7 @@ static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object)
|
||||
break;
|
||||
if (flipval*object->momz >= FixedMul(speed, spring->scale)) // if object's already moving faster than your best, don't bother
|
||||
break;
|
||||
if (player && (player->climbing || player->pflags & PF_GLIDING)) // doesn't affect Knux when he's using his abilities!
|
||||
if (p && (p->climbing || p->pflags & PF_GLIDING)) // doesn't affect Knux when he's using his abilities!
|
||||
break;
|
||||
|
||||
object->momz += flipval*FixedMul(speed/4, spring->scale);
|
||||
@@ -2026,7 +2026,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
|
||||
mapcampointer = thiscam;
|
||||
|
||||
if (newsec->flags & SF_NOCLIPCAMERA)
|
||||
if (UNLIKELY(GETSECSPECIAL(newsec->special, 4) == 12))
|
||||
{ // Camera noclip on entire sector.
|
||||
tmfloorz = tmdropoffz = thiscam->z;
|
||||
tmceilingz = tmdrpoffceilz = thiscam->z + thiscam->height;
|
||||
@@ -2068,7 +2068,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
fixed_t topheight, bottomheight, midheight;
|
||||
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL)
|
||||
|| rover->master->frontsector->flags & SF_NOCLIPCAMERA)
|
||||
|| UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(thiscam, newsec, rover, x, y, NULL);
|
||||
@@ -2144,7 +2144,7 @@ static boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
// We're inside it! Yess...
|
||||
polysec = po->lines[0]->backsector;
|
||||
|
||||
if (polysec->flags & SF_NOCLIPCAMERA)
|
||||
if (UNLIKELY(GETSECSPECIAL(polysec->special, 4) == 12))
|
||||
{ // Camera noclip polyobj.
|
||||
plink = (polymaplink_t *)(plink->link.next);
|
||||
continue;
|
||||
@@ -3983,51 +3983,19 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
|
||||
Lots of new Boom functions that work faster and add functionality.
|
||||
*/
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
static msecnode_t *headsecnode = NULL;
|
||||
#endif
|
||||
|
||||
void P_Initsecnode(void)
|
||||
{
|
||||
#ifndef PHOBOS_BUILD
|
||||
headsecnode = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
// P_GetSecnode() retrieves a node from the freelist. The calling routine
|
||||
// should make sure it sets all fields properly.
|
||||
|
||||
static msecnode_t *P_GetSecnode(void)
|
||||
{
|
||||
#ifdef PHOBOS_BUILD
|
||||
return Z_LevelPoolCalloc(sizeof(msecnode_t));
|
||||
#else
|
||||
msecnode_t *node;
|
||||
|
||||
if (headsecnode)
|
||||
{
|
||||
// vanilla does not clear this
|
||||
// so for compat reasons we also dont
|
||||
// means we just reuse stale data which causes weird interactions with orbiting items in some cases
|
||||
node = headsecnode;
|
||||
headsecnode = headsecnode->m_thinglist_next;
|
||||
}
|
||||
else
|
||||
node = Z_LevelPoolCalloc(sizeof(msecnode_t));
|
||||
|
||||
return node;
|
||||
#endif
|
||||
}
|
||||
|
||||
// P_PutSecnode() returns a node to the freelist.
|
||||
|
||||
static inline void P_PutSecnode(msecnode_t *node)
|
||||
{
|
||||
#ifdef PHOBOS_BUILD
|
||||
Z_LevelPoolFree(node, sizeof(msecnode_t));
|
||||
#else
|
||||
node->m_thinglist_next = headsecnode;
|
||||
headsecnode = node;
|
||||
#endif
|
||||
}
|
||||
|
||||
// P_AddSecnode() searches the current list to see if this sector is
|
||||
|
||||
+3
-3
@@ -328,7 +328,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
{
|
||||
fixed_t topheight, bottomheight, midheight;
|
||||
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef);
|
||||
@@ -358,7 +358,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
{
|
||||
fixed_t topheight, bottomheight, midheight;
|
||||
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef);
|
||||
@@ -466,7 +466,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
// Check for collision with front side's midtexture if Effect 4 is set
|
||||
if (linedef->flags & ML_EFFECT4
|
||||
&& !linedef->polyobj) // don't do anything for polyobjects! ...for now
|
||||
{
|
||||
{
|
||||
side_t *side = &sides[linedef->sidenum[0]];
|
||||
fixed_t textop, texbottom, texheight;
|
||||
fixed_t texmid, delta1, delta2;
|
||||
|
||||
+896
-1099
File diff suppressed because it is too large.
Load diff
+1
-1
@@ -113,7 +113,7 @@ typedef enum
|
||||
// Don't use the blocklinks (inert but displayable)
|
||||
MF_NOBLOCKMAP = 1<<4,
|
||||
// Thin, paper-like collision bound (for visual equivalent, see FF_PAPERSPRITE)
|
||||
MF_PAPERCOLLISION = 1<<5,
|
||||
MF_PAPERCOLLISION = 1<<5,
|
||||
// You can push this object. It can activate switches and things by pushing it on top.
|
||||
MF_PUSHABLE = 1<<6,
|
||||
// Object is a boss.
|
||||
|
||||
+6
-36
@@ -69,7 +69,7 @@ FUNCINLINE static ATTRINLINE void P_ArchivePlayer(savebuffer_t *save)
|
||||
pllives = 3; // has less than that.
|
||||
|
||||
WRITEUINT8(save->p, player->skincolor);
|
||||
WRITESKIN(save->p, player->skin);
|
||||
WRITEUINT8(save->p, player->skin);
|
||||
|
||||
WRITEUINT32(save->p, player->score);
|
||||
WRITEINT32(save->p, pllives);
|
||||
@@ -77,7 +77,7 @@ FUNCINLINE static ATTRINLINE void P_ArchivePlayer(savebuffer_t *save)
|
||||
|
||||
if (botskin)
|
||||
{
|
||||
WRITESKIN(save->p, botskin);
|
||||
WRITEUINT8(save->p, botskin);
|
||||
WRITEUINT8(save->p, botcolor);
|
||||
}
|
||||
}
|
||||
@@ -88,7 +88,7 @@ FUNCINLINE static ATTRINLINE void P_ArchivePlayer(savebuffer_t *save)
|
||||
FUNCINLINE static ATTRINLINE void P_UnArchivePlayer(savebuffer_t *save)
|
||||
{
|
||||
savedata.skincolor = READUINT8(save->p);
|
||||
savedata.skin = READSKIN(save->p);
|
||||
savedata.skin = READUINT8(save->p);
|
||||
|
||||
savedata.score = READINT32(save->p);
|
||||
savedata.lives = READINT32(save->p);
|
||||
@@ -96,11 +96,9 @@ FUNCINLINE static ATTRINLINE void P_UnArchivePlayer(savebuffer_t *save)
|
||||
|
||||
if (savedata.botcolor)
|
||||
{
|
||||
savedata.botskin = READSKIN(save->p);
|
||||
|
||||
savedata.botskin = READUINT8(save->p);
|
||||
if (savedata.botskin-1 >= numskins)
|
||||
savedata.botskin = 0;
|
||||
|
||||
savedata.botcolor = READUINT8(save->p);
|
||||
}
|
||||
else
|
||||
@@ -119,9 +117,7 @@ static void P_NetArchivePlayers(savebuffer_t *save, boolean resending)
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
#ifndef PHOBOS_BUILD
|
||||
if (resending)
|
||||
#endif
|
||||
WRITESINT8(save->p, (SINT8)adminplayers[i]);
|
||||
|
||||
if (!playeringame[i])
|
||||
@@ -131,9 +127,7 @@ static void P_NetArchivePlayers(savebuffer_t *save, boolean resending)
|
||||
|
||||
// no longer send ticcmds
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
if (resending)
|
||||
#endif
|
||||
WRITESTRINGN(save->p, player_names[i], MAXPLAYERNAME);
|
||||
|
||||
const player_t *player = &players[i];
|
||||
@@ -162,16 +156,11 @@ static void P_NetArchivePlayers(savebuffer_t *save, boolean resending)
|
||||
WRITEUINT16(save->p, player->flashpal);
|
||||
WRITEUINT16(save->p, player->flashcount);
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
WRITEUINT8(save->p, player->skincolor);
|
||||
WRITEINT32(save->p, player->skin);
|
||||
#else
|
||||
if (resending)
|
||||
{
|
||||
WRITEUINT8(save->p, player->skincolor);
|
||||
WRITEINT32(save->p, player->skin);
|
||||
}
|
||||
#endif
|
||||
|
||||
WRITEUINT32(save->p, player->score);
|
||||
WRITEFIXED(save->p, player->dashspeed);
|
||||
@@ -320,9 +309,7 @@ static void P_NetUnArchivePlayers(savebuffer_t *save, boolean reloading)
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
#ifndef PHOBOS_BUILD
|
||||
if (reloading)
|
||||
#endif
|
||||
adminplayers[i] = (INT32)READSINT8(save->p);
|
||||
|
||||
// Do NOT memset player struct to 0
|
||||
@@ -333,9 +320,7 @@ static void P_NetUnArchivePlayers(savebuffer_t *save, boolean reloading)
|
||||
|
||||
// NOTE: sending tics should (hopefully) no longer be necessary
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
if (reloading)
|
||||
#endif
|
||||
READSTRINGN(save->p, player_names[i], MAXPLAYERNAME);
|
||||
|
||||
player_t *player = &players[i];
|
||||
@@ -364,16 +349,11 @@ static void P_NetUnArchivePlayers(savebuffer_t *save, boolean reloading)
|
||||
player->flashpal = READUINT16(save->p);
|
||||
player->flashcount = READUINT16(save->p);
|
||||
|
||||
#ifdef PHOBOS_BUILD
|
||||
player->skincolor = READUINT8(save->p);
|
||||
player->skin = READINT32(save->p);
|
||||
#else
|
||||
if (reloading)
|
||||
{
|
||||
player->skincolor = READUINT8(save->p);
|
||||
player->skin = READINT32(save->p);
|
||||
}
|
||||
#endif
|
||||
|
||||
player->score = READUINT32(save->p);
|
||||
player->dashspeed = READFIXED(save->p); // dashing speed
|
||||
@@ -1128,11 +1108,7 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
|
||||
diff2 = 0;
|
||||
|
||||
// not the default but the most probable
|
||||
#ifdef PHOBOS_BUILD
|
||||
if (mobj->momx != 0 || mobj->momy != 0 || mobj->momz != 0 || mobj->pmomz !=0)
|
||||
#else
|
||||
if (mobj->momx != 0 || mobj->momy != 0 || mobj->momz != 0)
|
||||
#endif
|
||||
diff |= MD_MOM;
|
||||
if (mobj->radius != mobj->info->radius)
|
||||
diff |= MD_RADIUS;
|
||||
@@ -1260,9 +1236,6 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
|
||||
WRITEFIXED(save->p, mobj->momx);
|
||||
WRITEFIXED(save->p, mobj->momy);
|
||||
WRITEFIXED(save->p, mobj->momz);
|
||||
#ifdef PHOBOS_BUILD
|
||||
WRITEFIXED(save->p, mobj->pmomz);
|
||||
#endif
|
||||
}
|
||||
if (diff & MD_RADIUS)
|
||||
WRITEFIXED(save->p, mobj->radius);
|
||||
@@ -1324,7 +1297,7 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
|
||||
if (diff2 & MD2_CVMEM)
|
||||
WRITEINT32(save->p, mobj->cvmem);
|
||||
if (diff2 & MD2_SKIN)
|
||||
WRITESKIN(save->p, (skinnum_t)((skin_t *)mobj->skin - skins));
|
||||
WRITEUINT8(save->p, (UINT8)((skin_t *)mobj->skin - skins));
|
||||
if (diff2 & MD2_COLOR)
|
||||
WRITEUINT8(save->p, mobj->color);
|
||||
if (diff2 & MD2_EXTVAL1)
|
||||
@@ -2082,9 +2055,6 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
|
||||
mobj->momx = READFIXED(save->p);
|
||||
mobj->momy = READFIXED(save->p);
|
||||
mobj->momz = READFIXED(save->p);
|
||||
#ifdef PHOBOS_BUILD
|
||||
mobj->pmomz = READFIXED(save->p);
|
||||
#endif
|
||||
} // otherwise they're zero, and the memset took care of it
|
||||
|
||||
if (diff & MD_RADIUS)
|
||||
@@ -2185,7 +2155,7 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
|
||||
if (diff2 & MD2_CVMEM)
|
||||
mobj->cvmem = READINT32(save->p);
|
||||
if (diff2 & MD2_SKIN)
|
||||
mobj->skin = &skins[READSKIN(save->p)];
|
||||
mobj->skin = &skins[READUINT8(save->p)];
|
||||
if (diff2 & MD2_COLOR)
|
||||
mobj->color = READUINT8(save->p);
|
||||
if (diff2 & MD2_EXTVAL1)
|
||||
|
||||
+2
-2
@@ -24,8 +24,8 @@
|
||||
typedef struct
|
||||
{
|
||||
UINT8 skincolor;
|
||||
skinnum_t skin;
|
||||
skinnum_t botskin;
|
||||
UINT8 skin;
|
||||
UINT8 botskin;
|
||||
UINT8 botcolor;
|
||||
INT32 score;
|
||||
INT32 lives;
|
||||
|
||||
+84
-105
@@ -180,7 +180,7 @@ FUNCNORETURN static ATTRNORETURN void CorruptMapError(const char *msg)
|
||||
// don't use va() because the calling function probably uses it
|
||||
char mapnum[10];
|
||||
|
||||
snprintf(mapnum, sizeof(mapnum), "%hd", gamemap);
|
||||
sprintf(mapnum, "%hd", gamemap);
|
||||
CON_LogMessage("Map ");
|
||||
CON_LogMessage(mapnum);
|
||||
CON_LogMessage(" is corrupt: ");
|
||||
@@ -266,8 +266,8 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
|
||||
mapheaderinfo[num]->actnum[0] = '\0';
|
||||
mapheaderinfo[num]->typeoflevel = 0;
|
||||
mapheaderinfo[num]->nextlevel = (INT16)(i + 1);
|
||||
snprintf(mapheaderinfo[num]->musname, sizeof(mapheaderinfo[num]->musname), "%sM", G_BuildMapName(i));
|
||||
mapheaderinfo[num]->musname[sizeof(mapheaderinfo[num]->musname)-1] = 0;
|
||||
snprintf(mapheaderinfo[num]->musname, 7, "%sM", G_BuildMapName(i));
|
||||
mapheaderinfo[num]->musname[6] = 0;
|
||||
mapheaderinfo[num]->mustrack = 0;
|
||||
mapheaderinfo[num]->muspos = 0;
|
||||
mapheaderinfo[num]->forcecharacter[0] = '\0';
|
||||
@@ -318,15 +318,15 @@ void P_AllocMapHeader(INT16 i)
|
||||
// Loads the vertexes for a level.
|
||||
FUNCINLINE static ATTRINLINE void P_LoadVertices(UINT8 *data)
|
||||
{
|
||||
mapvertex_t *mv = (mapvertex_t *)data;
|
||||
vertex_t *v = vertexes;
|
||||
mapvertex_t *ml = (mapvertex_t *)data;
|
||||
vertex_t *li = vertexes;
|
||||
size_t i;
|
||||
|
||||
// Copy and convert vertex coordinates, internal representation as fixed.
|
||||
for (i = 0; i < numvertexes; i++, v++, mv++)
|
||||
for (i = 0; i < numvertexes; i++, li++, ml++)
|
||||
{
|
||||
v->x = SHORT(mv->x)<<FRACBITS;
|
||||
v->y = SHORT(mv->y)<<FRACBITS;
|
||||
li->x = SHORT(ml->x)<<FRACBITS;
|
||||
li->y = SHORT(ml->y)<<FRACBITS;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -479,30 +479,65 @@ static void P_SetupDirectionalLight(void)
|
||||
static void P_LoadSegs(UINT8 *data)
|
||||
{
|
||||
INT32 rawlinedef, rawside;
|
||||
mapseg_t *ms = (mapseg_t*)data;
|
||||
seg_t *seg = segs;
|
||||
mapseg_t *ml = (mapseg_t*)data;
|
||||
seg_t *li = segs;
|
||||
line_t *ldef;
|
||||
size_t i;
|
||||
|
||||
// Set map lighting settings.
|
||||
P_SetupDirectionalLight();
|
||||
|
||||
for (i = 0; i < numsegs; i++, seg++, ms++)
|
||||
for (i = 0; i < numsegs; i++, li++, ml++)
|
||||
{
|
||||
INT16 v1, v2;
|
||||
|
||||
v1 = SHORT(ms->v1);
|
||||
v2 = SHORT(ms->v2);
|
||||
v1 = SHORT(ml->v1);
|
||||
v2 = SHORT(ml->v2);
|
||||
|
||||
// e6y
|
||||
// moved down for additional checks to avoid overflow
|
||||
// if wrong vertexe's indexes are in SEGS lump
|
||||
// see below for more detailed information
|
||||
// check and fix wrong references to non-existent vertexes
|
||||
// see e1m9 @ NIVELES.WAD
|
||||
// http://www.doomworld.com/idgames/index.php?id=12647
|
||||
if ((unsigned)v1 >= numvertexes || (unsigned)v2 >= numvertexes)
|
||||
{
|
||||
if ((unsigned)v1 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v1));
|
||||
if ((unsigned)v2 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v2));
|
||||
|
||||
seg->angle = (SHORT(ms->angle)) << FRACBITS;
|
||||
seg->offset = (SHORT(ms->offset)) << FRACBITS;
|
||||
if (li->sidedef == &sides[li->linedef->sidenum[0]])
|
||||
{
|
||||
li->v1 = lines[ml->linedef].v1;
|
||||
li->v2 = lines[ml->linedef].v2;
|
||||
}
|
||||
else
|
||||
{
|
||||
li->v1 = lines[ml->linedef].v2;
|
||||
li->v2 = lines[ml->linedef].v1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
li->v1 = &vertexes[v1];
|
||||
li->v2 = &vertexes[v2];
|
||||
}
|
||||
|
||||
rawlinedef = SHORT(ms->linedef);
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
li->fv1.x = FixedToFloat(li->v1->x);
|
||||
li->fv1.y = FixedToFloat(li->v1->y);
|
||||
//li->fv1.z = FixedToFloat(li->v1->z); // z is unused in gl
|
||||
|
||||
li->fv2.x = FixedToFloat(li->v2->x);
|
||||
li->fv2.y = FixedToFloat(li->v2->y);
|
||||
//li->fv2.z = FixedToFloat(li->v2->z);
|
||||
}
|
||||
#endif
|
||||
li->length = P_SegLength(li);
|
||||
li->angle = (SHORT(ml->angle))<<FRACBITS;
|
||||
li->offset = (SHORT(ml->offset))<<FRACBITS;
|
||||
rawlinedef = SHORT(ml->linedef);
|
||||
|
||||
//e6y: check for wrong indexes
|
||||
if ((unsigned)rawlinedef >= numlines)
|
||||
@@ -511,8 +546,8 @@ static void P_LoadSegs(UINT8 *data)
|
||||
}
|
||||
|
||||
ldef = &lines[rawlinedef];
|
||||
seg->linedef = ldef;
|
||||
rawside = SHORT(ms->side);
|
||||
li->linedef = ldef;
|
||||
rawside = SHORT(ml->side);
|
||||
|
||||
//e6y: fix wrong side index
|
||||
if (rawside != 0 && rawside != 1)
|
||||
@@ -527,9 +562,9 @@ static void P_LoadSegs(UINT8 *data)
|
||||
I_Error("P_LoadSegs: linedef %d for seg %s references a non-existent sidedef %d", rawlinedef, sizeu1(i), ldef->sidenum[rawside]);
|
||||
}
|
||||
|
||||
seg->side = rawside;
|
||||
li->side = rawside;
|
||||
|
||||
seg->sidedef = &sides[ldef->sidenum[rawside]];
|
||||
li->sidedef = &sides[ldef->sidenum[rawside]];
|
||||
|
||||
/* cph 2006/09/30 - our frontsector can be the second side of the
|
||||
* linedef, so must check for NO_INDEX in case we are incorrectly
|
||||
@@ -537,11 +572,11 @@ static void P_LoadSegs(UINT8 *data)
|
||||
if (ldef->sidenum[rawside] == NO_INDEX)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadSegs: front of seg %s has no sidedef\n", sizeu1(i)));
|
||||
seg->frontsector = NULL;
|
||||
li->frontsector = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
seg->frontsector = sides[ldef->sidenum[rawside]].sector;
|
||||
li->frontsector = sides[ldef->sidenum[rawside]].sector;
|
||||
}
|
||||
|
||||
if (ldef->flags & ML_TWOSIDED)
|
||||
@@ -549,58 +584,15 @@ static void P_LoadSegs(UINT8 *data)
|
||||
if (ldef->sidenum[rawside^1] == NO_INDEX)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadSegs: back of seg %s has no sidedef while being marked as double sided\n", sizeu1(i)));
|
||||
seg->backsector = NULL;
|
||||
li->backsector = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
seg->backsector = sides[ldef->sidenum[rawside^1]].sector;
|
||||
li->backsector = sides[ldef->sidenum[rawside^1]].sector;
|
||||
}
|
||||
}
|
||||
|
||||
// e6y
|
||||
// check and fix wrong references to non-existent vertexes
|
||||
// see e1m9 @ NIVELES.WAD
|
||||
// http://www.doomworld.com/idgames/index.php?id=12647
|
||||
if ((unsigned)v1 >= numvertexes || (unsigned)v2 >= numvertexes)
|
||||
{
|
||||
if ((unsigned)v1 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v1));
|
||||
if ((unsigned)v2 >= numvertexes)
|
||||
CorruptMapWarning(va("P_LoadSegs: seg %s references a non-existent vertex %d\n", sizeu1(i), v2));
|
||||
|
||||
if (seg->sidedef == &sides[seg->linedef->sidenum[0]])
|
||||
{
|
||||
seg->v1 = lines[ms->linedef].v1;
|
||||
seg->v2 = lines[ms->linedef].v2;
|
||||
}
|
||||
else
|
||||
{
|
||||
seg->v1 = lines[ms->linedef].v2;
|
||||
seg->v2 = lines[ms->linedef].v1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
seg->v1 = &vertexes[v1];
|
||||
seg->v2 = &vertexes[v2];
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
seg->fv1.x = FixedToFloat(seg->v1->x);
|
||||
seg->fv1.y = FixedToFloat(seg->v1->y);
|
||||
//seg->fv1.z = FixedToFloat(seg->v1->z); // z is unused in gl
|
||||
|
||||
seg->fv2.x = FixedToFloat(seg->v2->x);
|
||||
seg->fv2.y = FixedToFloat(seg->v2->y);
|
||||
//seg->fv2.z = FixedToFloat(seg->v2->z);
|
||||
}
|
||||
#endif
|
||||
|
||||
seg->length = P_SegLength(seg);
|
||||
|
||||
P_UpdateSegLightOffset(seg);
|
||||
P_UpdateSegLightOffset(li);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -618,6 +610,10 @@ FUNCINLINE static ATTRINLINE void P_LoadSubsectors(void *data)
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// P_LoadSectors
|
||||
//
|
||||
|
||||
//
|
||||
// levelflats
|
||||
//
|
||||
@@ -669,17 +665,13 @@ static void P_CheckCyanFlat(levelflat_t *levelflat)
|
||||
const char *flatname = W_CheckNameForNum(levelflat->lumpnum);
|
||||
|
||||
// hack for gba rainbow roads cyan floors
|
||||
if (UNLIKELY(flatname && memcmp(flatname, "GBA_RRF5", 8) == 0 && flatname[8] == 0))
|
||||
if (UNLIKELY(memcmp(flatname, "GBA_RRF5", 8) == 0 && flatname[8] == 0))
|
||||
{
|
||||
levelflat->cyan = false;
|
||||
return;
|
||||
}
|
||||
|
||||
const UINT8 *flat = R_GetFlat(levelflat->lumpnum);
|
||||
|
||||
if (!flat)
|
||||
return;
|
||||
|
||||
const size_t size = W_LumpLength(levelflat->lumpnum);
|
||||
|
||||
for (size_t steppy = 0; steppy < size; steppy++)
|
||||
@@ -799,10 +791,6 @@ INT32 P_CheckLevelFlat(const char *flatname)
|
||||
return (INT32)i;
|
||||
}
|
||||
|
||||
//
|
||||
// P_LoadSectors
|
||||
//
|
||||
|
||||
static const sector_t sector_default = {
|
||||
.nexttag = -1,
|
||||
.firsttag = -1,
|
||||
@@ -1906,7 +1894,7 @@ static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count)
|
||||
// because making both the WAD and PK3 loading code use
|
||||
// the same functions is trickier than it looks for blockmap
|
||||
// -- Monster Iestyn 09/01/18
|
||||
static boolean P_LoadBlockMap(UINT8 *data, size_t count)
|
||||
static boolean P_LoadRawBlockMap(UINT8 *data, size_t count)
|
||||
{
|
||||
if (!count || count >= 0x20000)
|
||||
return false;
|
||||
@@ -2074,14 +2062,14 @@ static void P_LoadReject(UINT8 *data, size_t rejectsize)
|
||||
if (rejectsize < neededsize)
|
||||
{
|
||||
CorruptMapWarning(va("P_LoadReject: REJECT is %s byte%s too small. REJECT might be invalid!\n", sizeu1(neededsize - rejectsize), (neededsize - rejectsize) == 1 ? "" : "s"));
|
||||
#ifdef PHOBOS_BUILD
|
||||
rejectmatrix = NULL;
|
||||
return;
|
||||
#else
|
||||
#ifdef COMPAT_VANILLA
|
||||
// we can pad this and somewhat prevent desyncs
|
||||
// probs not cool if the reject is from a completely different map
|
||||
// but whatever
|
||||
allocsize = neededsize;
|
||||
#else
|
||||
rejectmatrix = NULL;
|
||||
return;
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -2132,7 +2120,7 @@ static void P_LoadMapLUT(const virtres_t* virt)
|
||||
rejectmatrix = NULL;
|
||||
}
|
||||
|
||||
if (!(virtblockmap && P_LoadBlockMap(virtblockmap->data, virtblockmap->size)))
|
||||
if (!(virtblockmap && P_LoadRawBlockMap(virtblockmap->data, virtblockmap->size)))
|
||||
P_CreateBlockMap();
|
||||
}
|
||||
|
||||
@@ -2205,7 +2193,7 @@ void P_SetupLevelSky(INT32 skynum, boolean global)
|
||||
{
|
||||
char skytexname[12];
|
||||
|
||||
snprintf(skytexname, sizeof(skytexname), "SKY%d", skynum);
|
||||
sprintf(skytexname, "SKY%d", skynum);
|
||||
skytexture = R_TextureNumForName(skytexname);
|
||||
levelskynum = skynum;
|
||||
|
||||
@@ -2425,8 +2413,7 @@ static void P_RunLevelScript(const char *scriptname)
|
||||
lumpnum_t lumpnum;
|
||||
char newname[9];
|
||||
|
||||
strncpy(newname, scriptname, sizeof(newname)-1);
|
||||
newname[sizeof(newname)-1] = '\0';
|
||||
strlcpy(newname, scriptname, sizeof(newname));
|
||||
|
||||
lumpnum = W_CheckNumForName(newname);
|
||||
|
||||
@@ -2436,7 +2423,7 @@ static void P_RunLevelScript(const char *scriptname)
|
||||
return;
|
||||
}
|
||||
|
||||
COM_BufInsertTextEx(W_CacheLumpNum(lumpnum, PU_CACHE), W_LumpLength(lumpnum));
|
||||
COM_BufInsertText(W_CacheLumpNum(lumpnum, PU_CACHE));
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2451,26 +2438,23 @@ static void P_ForceCharacter(const char *forcecharskin)
|
||||
if (netgame)
|
||||
{
|
||||
char skincmd[33];
|
||||
|
||||
if (splitscreen)
|
||||
{
|
||||
snprintf(skincmd, sizeof(skincmd), "skin2 %s\n", forcecharskin);
|
||||
sprintf(skincmd, "skin2 %s\n", forcecharskin);
|
||||
CV_Set(&cv_skin2, forcecharskin);
|
||||
|
||||
if (splitscreen > 1)
|
||||
{
|
||||
snprintf(skincmd, sizeof(skincmd), "skin3 %s\n", forcecharskin);
|
||||
sprintf(skincmd, "skin3 %s\n", forcecharskin);
|
||||
CV_Set(&cv_skin3, forcecharskin);
|
||||
|
||||
if (splitscreen > 2)
|
||||
{
|
||||
snprintf(skincmd, sizeof(skincmd), "skin4 %s\n", forcecharskin);
|
||||
sprintf(skincmd, "skin4 %s\n", forcecharskin);
|
||||
CV_Set(&cv_skin4, forcecharskin);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(skincmd, sizeof(skincmd), "skin %s\n", forcecharskin);
|
||||
sprintf(skincmd, "skin %s\n", forcecharskin);
|
||||
COM_BufAddText(skincmd);
|
||||
}
|
||||
else
|
||||
@@ -2527,7 +2511,7 @@ static void P_LoadRecordGhosts(void)
|
||||
|
||||
const char *mapname = G_BuildMapName(gamemap);
|
||||
|
||||
snprintf(gpath, glen, "%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, mapname);
|
||||
sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, mapname);
|
||||
|
||||
// Best Time ghost
|
||||
if (cv_ghost_besttime.value)
|
||||
@@ -2883,8 +2867,7 @@ static void P_SetupPlayer(void)
|
||||
if (!demo.playback && multiplayer && D_NumPlayers())
|
||||
{
|
||||
static char buf[256];
|
||||
|
||||
snprintf(buf, sizeof(buf), "replay"PATHSEP"online"PATHSEP"%d-%s", (int)(time(NULL)), G_BuildMapName(gamemap));
|
||||
sprintf(buf, "replay"PATHSEP"online"PATHSEP"%d-%s", (int)(time(NULL)), G_BuildMapName(gamemap));
|
||||
|
||||
I_mkdir(va("%s"PATHSEP"replay", srb2home), 0755);
|
||||
I_mkdir(va("%s"PATHSEP"replay"PATHSEP"online", srb2home), 0755);
|
||||
@@ -3001,9 +2984,6 @@ boolean P_SetupLevel(boolean fromnetsave, boolean reloadinggamestate)
|
||||
CON_Drawer(); // let the user know what we are going to do
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
|
||||
// Initialize sector node list.
|
||||
P_Initsecnode();
|
||||
|
||||
if (netgame || multiplayer)
|
||||
cv_debug = botskin = 0;
|
||||
|
||||
@@ -3069,7 +3049,7 @@ boolean P_SetupLevel(boolean fromnetsave, boolean reloadinggamestate)
|
||||
// Don't include these in the fade!
|
||||
char tx[64];
|
||||
V_DrawSmallString(1, 191, V_ALLOWLOWERCASE, M_GetText("Speeding off to..."));
|
||||
snprintf(tx, sizeof(tx)-1, "%s%s%s",
|
||||
snprintf(tx, 63, "%s%s%s",
|
||||
mapheader->lvlttl,
|
||||
(strlen(mapheader->zonttl) > 0) ? va(" %s",mapheader->zonttl) : // SRB2kart
|
||||
((mapheader->levelflags & LF_NOZONE) ? "" : " Zone"),
|
||||
@@ -3331,7 +3311,6 @@ static boolean P_CheckSoundReplacements(UINT16 wadnum, char *name, size_t i)
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//
|
||||
// P_CheckReplacMapReplacements
|
||||
//
|
||||
|
||||
+17
-24
@@ -2161,7 +2161,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
newname[1] = 'C';
|
||||
newname[2] = 'R';
|
||||
|
||||
scrnum = sides[line->sidenum[0]].textureoffset >> FRACBITS;
|
||||
scrnum = sides[line->sidenum[0]].textureoffset>>FRACBITS;
|
||||
if (scrnum < 0 || scrnum > 999)
|
||||
{
|
||||
scrnum = 0;
|
||||
@@ -2169,9 +2169,9 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
}
|
||||
else
|
||||
{
|
||||
newname[5] = (char)('0' + (char)((scrnum / 100)));
|
||||
newname[6] = (char)('0' + (char)((scrnum % 100) / 10));
|
||||
newname[7] = (char)('0' + (char)(scrnum % 10));
|
||||
newname[5] = (char)('0' + (char)((scrnum/100)));
|
||||
newname[6] = (char)('0' + (char)((scrnum%100)/10));
|
||||
newname[7] = (char)('0' + (char)(scrnum%10));
|
||||
}
|
||||
newname[8] = '\0';
|
||||
|
||||
@@ -2184,7 +2184,14 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
else
|
||||
{
|
||||
// W_CacheLumpNum may not have null terminator, so we need to do this :blobcatgooglyholditsheadinitshands:
|
||||
COM_BufInsertTextEx(W_CacheLumpNum(lumpnum, PU_CACHE), W_LumpLength(lumpnum));
|
||||
size_t len = W_LumpLength(lumpnum);
|
||||
char *script = Z_Malloc(len+1, PU_STATIC, NULL);
|
||||
memcpy(script, W_CacheLumpNum(lumpnum, PU_CACHE), len);
|
||||
script[len] = 0;
|
||||
|
||||
COM_BufInsertText(script);
|
||||
|
||||
Z_Free(script);
|
||||
}
|
||||
}
|
||||
break;
|
||||
@@ -3394,7 +3401,7 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
|
||||
break;
|
||||
case 12: // SRB2kart: Invert Encore Remap
|
||||
break;
|
||||
case 15: // also Invert Encore Remap....
|
||||
case 15: // no idea but keep it dont want anything to break
|
||||
break;
|
||||
}
|
||||
DoneSection2:
|
||||
@@ -4604,7 +4611,7 @@ void P_UpdateSpecials(void)
|
||||
// POINT LIMIT
|
||||
P_CheckPointLimit();
|
||||
|
||||
#ifndef PHOBOS_BUILD
|
||||
#ifdef COMPAT_VANILLA
|
||||
// Dynamic slopeness
|
||||
// we run this here only when not joined midrace
|
||||
// for vanilla compat reasons :chaosleep:
|
||||
@@ -5368,11 +5375,6 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
case 11: // Custom global gravity!
|
||||
gravity = sector->floorheight/1000;
|
||||
break;
|
||||
|
||||
case 12: // SRB2kart: Invert Encore Remap
|
||||
case 15: // NOTE: vanilla kart checks only for this for some reason!
|
||||
sector->flags |= SF_INVERTENCORE;
|
||||
break;
|
||||
}
|
||||
|
||||
// Process Section 4
|
||||
@@ -5382,10 +5384,6 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
if (G_RaceGametype())
|
||||
circuitmap = true;
|
||||
break;
|
||||
|
||||
case 12: // Camera noclip
|
||||
sector->flags |= SF_NOCLIPCAMERA;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5470,11 +5468,11 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
sectors[s].gravity = §ors[sec].floorheight; // This allows it to change in realtime!
|
||||
|
||||
if (lines[i].flags & ML_NOCLIMB)
|
||||
sectors[s].flags |= SF_GRAVITYFLIP;
|
||||
sectors[s].verticalflip = true;
|
||||
else
|
||||
sectors[s].flags &= ~SF_GRAVITYFLIP;
|
||||
sectors[s].verticalflip = false;
|
||||
|
||||
CheckForReverseGravity = (boolean)(sectors[s].flags & SF_GRAVITYFLIP);
|
||||
CheckForReverseGravity = sectors[s].verticalflip;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -5567,11 +5565,6 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
sectors[s].cullheight = &lines[i]; // This allows it to change in realtime!
|
||||
break;
|
||||
|
||||
case 13: // Heat wave effect
|
||||
for (s = -1; (s = P_FindSectorFromLineTag(lines + i, s)) >= 0 ;)
|
||||
sectors[s].flags |= SF_HEATWAVE;
|
||||
break;
|
||||
|
||||
case 50: // Insta-Lower Sector
|
||||
EV_DoFloor(&lines[i], instantLower);
|
||||
break;
|
||||
|
||||
+2
-8
@@ -38,8 +38,6 @@
|
||||
#include "i_video.h" // rendermode
|
||||
#include "m_perfstats.h"
|
||||
|
||||
#include "lua_profile.h"
|
||||
|
||||
// Object place
|
||||
#include "m_cheat.h"
|
||||
|
||||
@@ -624,8 +622,6 @@ void P_Ticker(boolean run)
|
||||
}
|
||||
}
|
||||
|
||||
LUA_ResetTicTimers();
|
||||
|
||||
ps_lua_mobjhooks.value.i = 0;
|
||||
ps_checkposition_calls.value.i = 0;
|
||||
|
||||
@@ -633,7 +629,6 @@ void P_Ticker(boolean run)
|
||||
LUA_HookPreThinkFrame();
|
||||
PS_STOP_TIMING(ps_lua_prethinkframe_time);
|
||||
|
||||
// OK! Now that we got all of that sorted, players can think!
|
||||
PS_START_TIMING(ps_playerthink_time);
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
@@ -651,7 +646,7 @@ void P_Ticker(boolean run)
|
||||
if (run)
|
||||
{
|
||||
// Dynamic slopeness
|
||||
#ifndef PHOBOS_BUILD
|
||||
#ifdef COMPAT_VANILLA
|
||||
if (midgamejoin) // only run here if we joined midgame to fix some desynchs
|
||||
#endif
|
||||
P_RunDynamicSlopes();
|
||||
@@ -680,7 +675,6 @@ void P_Ticker(boolean run)
|
||||
PS_STOP_TIMING(ps_lua_thinkframe_time);
|
||||
}
|
||||
|
||||
// Run shield positioning
|
||||
P_RunOverlays();
|
||||
P_RunShadows();
|
||||
|
||||
@@ -802,7 +796,7 @@ void P_Ticker(boolean run)
|
||||
if (!player->mo)
|
||||
continue;
|
||||
|
||||
const boolean skybox = (skyboxmo[0] && cv_skybox.value); // True if there's a skybox object and skyboxes are on
|
||||
const boolean skybox = (skyboxmo[0] && cv_skybox.value);
|
||||
|
||||
if (skyVisiblePerPlayer[i] && skybox)
|
||||
{
|
||||
|
||||
+10
-19
@@ -625,23 +625,15 @@ boolean P_EndingMusic(player_t *player)
|
||||
}
|
||||
|
||||
if (G_RaceGametype() && bestlocalpos == MAXPLAYERS+1)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "k*fail"); // F-Zero death results theme
|
||||
}
|
||||
sprintf(buffer, "k*fail"); // F-Zero death results theme
|
||||
else
|
||||
{
|
||||
if (bestlocalpos == 1)
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "k*win");
|
||||
}
|
||||
sprintf(buffer, "k*win");
|
||||
else if (isPlayerLosing(bestlocalplayer))
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "k*lose");
|
||||
}
|
||||
sprintf(buffer, "k*lose");
|
||||
else
|
||||
{
|
||||
snprintf(buffer, sizeof(buffer), "k*ok");
|
||||
}
|
||||
sprintf(buffer, "k*ok");
|
||||
}
|
||||
|
||||
S_SpeedMusic(1.0f);
|
||||
@@ -1017,7 +1009,7 @@ boolean P_IsLocalPlayer(const player_t *player)
|
||||
}
|
||||
|
||||
//
|
||||
// P_IsLocalPlayerNum
|
||||
// P_IsLocalPlayer
|
||||
//
|
||||
// Returns true if playernum is
|
||||
// on the local machine.
|
||||
@@ -3561,7 +3553,7 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
|
||||
for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL) || (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL) || UNLIKELY(GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
|
||||
@@ -3626,7 +3618,7 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
|
||||
// We're inside it! Yess...
|
||||
polysec = po->lines[0]->backsector;
|
||||
|
||||
if (polysec->flags & SF_NOCLIPCAMERA)
|
||||
if (UNLIKELY(GETSECSPECIAL(polysec->special, 4) == 12))
|
||||
{ // Camera noclip polyobj.
|
||||
plink = (polymaplink_t *)(plink->link.next);
|
||||
continue;
|
||||
@@ -3682,8 +3674,7 @@ static boolean P_CheckNoclipCameraPosition(player_t *player, camera_t *thiscam,
|
||||
for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
if ((rover->flags & FF_BLOCKOTHERS) && (rover->flags & FF_RENDERALL) && (rover->flags & FF_EXISTS) && (rover->master->frontsector->flags & SF_NOCLIPCAMERA))
|
||||
if (UNLIKELY((rover->flags & FF_BLOCKOTHERS) && (rover->flags & FF_RENDERALL) && (rover->flags & FF_EXISTS) && GETSECSPECIAL(rover->master->frontsector->special, 4) == 12))
|
||||
{
|
||||
topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
|
||||
bottomheight = P_CameraGetFOFBottomZ(thiscam, newsubsec->sector, rover, midx, midy, NULL);
|
||||
@@ -4263,7 +4254,7 @@ boolean P_SpectatorJoinGame(player_t *player)
|
||||
|
||||
static boolean P_CameraCheckHeatFirstperson(player_t *player, sector_t *sector, fixed_t pviewheight)
|
||||
{
|
||||
if (sector->flags & SF_HEATWAVE)
|
||||
if (P_FindSpecialLineFromTag(13, sector->tag, -1) != -1)
|
||||
return true;
|
||||
|
||||
if (sector->ffloors)
|
||||
@@ -4281,7 +4272,7 @@ static boolean P_CameraCheckHeatFirstperson(player_t *player, sector_t *sector,
|
||||
if (pviewheight <= P_GetFFloorBottomZAt(rover, player->mo->x, player->mo->y))
|
||||
continue;
|
||||
|
||||
if (rover->master->frontsector->flags & SF_HEATWAVE)
|
||||
if (P_FindSpecialLineFromTag(13, rover->master->frontsector->tag, -1) != -1)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
+5
-4
@@ -48,7 +48,8 @@ boolean g_walloffscreen = false;
|
||||
|
||||
boolean R_NoEncore(sector_t *sector, boolean ceiling)
|
||||
{
|
||||
const boolean invertEncore = (sector->flags & SF_INVERTENCORE);
|
||||
const INT32 invspecial = GETSECSPECIAL(sector->special, 2);
|
||||
boolean invertencore = (invspecial == 12 || invspecial == 15); // keeping this incase its used
|
||||
|
||||
#if 0 // perfect implementation
|
||||
const INT32 sprnspecial = GETSECSPECIAL(sector->special, 3);
|
||||
@@ -58,10 +59,10 @@ boolean R_NoEncore(sector_t *sector, boolean ceiling)
|
||||
#endif
|
||||
&& GETSECSPECIAL(sector->special, 4) != 6) // sneaker panel
|
||||
{
|
||||
return invertEncore;
|
||||
return invertencore;
|
||||
}
|
||||
|
||||
if (invertEncore)
|
||||
if (invertencore)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@@ -394,7 +395,7 @@ static void R_AddLine(seg_t *line)
|
||||
// Find the other side!
|
||||
INT32 line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->linedef->tag, -1);
|
||||
|
||||
if (line2 >= 0 && line->linedef == &lines[line2])
|
||||
if (line->linedef == &lines[line2])
|
||||
line2 = P_FindSpecialLineFromTag(PORTALSPECIAL, line->linedef->tag, line2);
|
||||
|
||||
if (line2 >= 0) // found it!
|
||||
|
||||
+5
-13
@@ -307,19 +307,10 @@ typedef struct pslope_s
|
||||
|
||||
typedef enum
|
||||
{
|
||||
// flipspecial - planes with effect
|
||||
SF_FLIPSPECIAL_FLOOR = 1,
|
||||
SF_FLIPSPECIAL_CEILING = 1<<1,
|
||||
SF_FLIPSPECIAL_BOTH = (SF_FLIPSPECIAL_FLOOR|SF_FLIPSPECIAL_CEILING),
|
||||
// triggerspecial - conditions under which plane touch causes effect
|
||||
SF_TRIGGERSPECIAL_TOUCH = 1<<2,
|
||||
|
||||
SF_GRAVITYFLIP = 1<<3,
|
||||
SF_HEATWAVE = 1<<4,
|
||||
SF_NOCLIPCAMERA = 1<<5,
|
||||
|
||||
// invert encore color remap status
|
||||
SF_INVERTENCORE = 1<<6,
|
||||
SF_FLIPSPECIAL_FLOOR = 1,
|
||||
SF_FLIPSPECIAL_CEILING = 2,
|
||||
SF_FLIPSPECIAL_BOTH = 3,
|
||||
SF_TRIGGERSPECIAL_TOUCH = 4,
|
||||
} sectorflags_t;
|
||||
|
||||
//
|
||||
@@ -400,6 +391,7 @@ typedef struct sector_s
|
||||
|
||||
// This points to the master's floorheight, so it can be changed in realtime!
|
||||
fixed_t *gravity; // per-sector gravity
|
||||
boolean verticalflip; // If gravity < 0, then allow flipped physics
|
||||
sectorflags_t flags;
|
||||
|
||||
// Sprite culling feature
|
||||
|
||||
+12
-10
@@ -174,10 +174,15 @@ static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
|
||||
{
|
||||
frontrgba = pGammaCorrectedPalette[fg];
|
||||
|
||||
#if 0 // perfect implementation
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
#else // performance scrabbler
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
|
||||
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue); // pGammaCorrectedPalette
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -185,7 +190,6 @@ static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
|
||||
static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
RGBA_t backrgba, frontrgba, result;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Subtractive: input table was NULL!");
|
||||
@@ -198,11 +202,11 @@ static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
backrgba = pLocalPalette[bg]; // intentionally uses pLocalPalette
|
||||
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
frontrgba = pLocalPalette[fg];
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.s.red = std::max(0, result.s.red - blendamt);
|
||||
@@ -217,19 +221,17 @@ static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
|
||||
static void BlendTab_Modulative(UINT8 *table)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
RGBA_t backrgba, frontrgba, result;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Modulative: input table was NULL!");
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
backrgba = pGammaCorrectedPalette[bg];
|
||||
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
frontrgba = pGammaCorrectedPalette[fg];
|
||||
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, AST_MODULATE, 0);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue);
|
||||
}
|
||||
|
||||
+8
-4
@@ -340,14 +340,18 @@ void R_InterpolateMobjState(mobj_t *mobj, fixed_t frac, interpmobjstate_t *out)
|
||||
return;
|
||||
}
|
||||
|
||||
out->x = R_LerpFixed(mobj->old_x, mobj->x, frac);
|
||||
out->y = R_LerpFixed(mobj->old_y, mobj->y, frac);
|
||||
out->z = R_LerpFixed(mobj->old_z, mobj->z, frac);
|
||||
const boolean doreset = mobj->resetinterp && (mobj->type != MT_GHOST) && (mobj->type != MT_PLAYERRETICULE) && (mobj->type != MT_SHADOW);
|
||||
|
||||
out->x = doreset ? mobj->x : R_LerpFixed(mobj->old_x, mobj->x, frac);
|
||||
out->y = doreset ? mobj->y : R_LerpFixed(mobj->old_y, mobj->y, frac);
|
||||
out->z = doreset ? mobj->z : R_LerpFixed(mobj->old_z, mobj->z, frac);
|
||||
|
||||
out->scale = mobj->resetinterp ? mobj->scale : R_LerpFixed(mobj->old_scale, mobj->scale, frac);
|
||||
out->spritexscale = mobj->resetinterp ? mobj->spritexscale : R_LerpFixed(mobj->old_spritexscale, mobj->spritexscale, frac);
|
||||
out->spriteyscale = mobj->resetinterp ? mobj->spriteyscale : R_LerpFixed(mobj->old_spriteyscale, mobj->spriteyscale, frac);
|
||||
out->spritexoffset = mobj->resetinterp ? mobj->spritexoffset : R_LerpFixed(mobj->old_spritexoffset, mobj->spritexoffset, frac);
|
||||
out->spriteyoffset = mobj->resetinterp ? mobj->spriteyoffset : R_LerpFixed(mobj->old_spriteyoffset, mobj->spriteyoffset, frac);
|
||||
out->scale = mobj->resetinterp ? mobj->scale : R_LerpFixed(mobj->old_scale, mobj->scale, frac);
|
||||
|
||||
//out->subsector = R_PointInSubsector(out->x, out->y); // this is unused
|
||||
|
||||
if (mobj->player)
|
||||
|
||||
+1
-1
@@ -1882,7 +1882,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
|
||||
// big room fix
|
||||
if (longboi)
|
||||
rw_distance = (fixed_t)R_CalcSegDist(curline, viewx, viewy);
|
||||
rw_distance = (fixed_t)R_CalcSegDist(curline,viewx,viewy);
|
||||
|
||||
ds_p->x1 = rw_x = start;
|
||||
ds_p->x2 = stop;
|
||||
|
||||
+6
-6
@@ -42,8 +42,8 @@ INT32 numallskins = 0;
|
||||
INT32 numlocalskins = 0;
|
||||
skin_t skins[MAXSKINS];
|
||||
|
||||
skinnum_t skinstats[9][9][MAXSKINS];
|
||||
skinnum_t skinstatscount[9][9] = {
|
||||
UINT8 skinstats[9][9][MAXSKINS];
|
||||
UINT8 skinstatscount[9][9] = {
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0},
|
||||
@@ -55,7 +55,7 @@ skinnum_t skinstatscount[9][9] = {
|
||||
{0, 0, 0, 0, 0, 0, 0, 0, 0}
|
||||
};
|
||||
|
||||
skinnum_t skinsorted[MAXSKINS] = {};
|
||||
UINT8 skinsorted[MAXSKINS] = {};
|
||||
skin_t localskins[MAXLOCALSKINS] = {};
|
||||
skin_t allskins[MAXSKINS+MAXLOCALSKINS] = {};
|
||||
|
||||
@@ -398,8 +398,8 @@ static UINT16 W_CheckForSkinMarkerInPwad(UINT16 wadid, UINT16 startlump)
|
||||
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 skinnum_t val_a = *(const skinnum_t *)a;
|
||||
const skinnum_t val_b = *(const skinnum_t *)b;
|
||||
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];
|
||||
|
||||
@@ -474,7 +474,7 @@ static int skinSortFunc(const void *a, const void *b) // tbh i have no clue what
|
||||
void sortSkinGrid(void)
|
||||
{
|
||||
//CONS_Printf("Sorting skin list (%d)...\n", cv_skinselectgridsort.value);
|
||||
qs22j(skinsorted, numskins, sizeof(skinnum_t), skinSortFunc);
|
||||
qs22j(skinsorted, numskins, sizeof(UINT8), skinSortFunc);
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
+3
-3
@@ -71,9 +71,9 @@ extern INT32 numskins;
|
||||
extern INT32 numlocalskins;
|
||||
extern INT32 numallskins;
|
||||
extern skin_t skins[MAXSKINS];
|
||||
extern skinnum_t skinstats[9][9][MAXSKINS];
|
||||
extern skinnum_t skinstatscount[9][9];
|
||||
extern skinnum_t skinsorted[MAXSKINS];
|
||||
extern UINT8 skinstats[9][9][MAXSKINS];
|
||||
extern UINT8 skinstatscount[9][9];
|
||||
extern UINT8 skinsorted[MAXSKINS];
|
||||
|
||||
extern skin_t localskins[MAXLOCALSKINS];
|
||||
extern skin_t allskins[MAXSKINS+MAXLOCALSKINS];
|
||||
|
||||
+11
-11
@@ -334,7 +334,7 @@ lumpnum_t S_GetSfxLumpNum(sfxinfo_t *sfx)
|
||||
char namebuf[9];
|
||||
lumpnum_t sfxlump;
|
||||
|
||||
snprintf(namebuf, sizeof(namebuf), "ds%s", sfx->name);
|
||||
sprintf(namebuf, "ds%s", sfx->name);
|
||||
|
||||
sfxlump = W_CheckNumForName(namebuf);
|
||||
if (sfxlump != LUMPERROR)
|
||||
@@ -433,7 +433,7 @@ static boolean S_CheckSameSoundLimit(sfxenum_t sfx_id)
|
||||
return true;
|
||||
|
||||
for (cnum = 0; cnum < numofchannels; cnum++)
|
||||
if (channels[cnum].sfxinfo == &S_sfx[sfx_id])
|
||||
if ((size_t)(channels[cnum].sfxinfo - S_sfx) == (size_t)sfx_id)
|
||||
scount++;
|
||||
|
||||
//CONS_Printf("same sound count: %d for sfx: %d\n", scount, sfx_id);
|
||||
@@ -864,18 +864,18 @@ void S_SetSfxVolume(INT32 volume)
|
||||
if (volume < 0 || volume > 31)
|
||||
CONS_Alert(CONS_WARNING, "sfxvolume should be between 0-31\n");
|
||||
|
||||
CV_SetValue(&cv_soundvolume, volume & 0x1F);
|
||||
CV_SetValue(&cv_soundvolume, volume&0x1F);
|
||||
actualsfxvolume = cv_soundvolume.value; // check for change of var
|
||||
|
||||
// now hardware volume
|
||||
I_SetSfxVolume(volume & 0x1F);
|
||||
I_SetSfxVolume(volume&0x1F);
|
||||
}
|
||||
|
||||
void S_ClearSfx(void)
|
||||
{
|
||||
size_t i;
|
||||
for (i = 1; i < NUMSFX; i++)
|
||||
I_FreeSfx(&S_sfx[i]);
|
||||
I_FreeSfx(S_sfx + i);
|
||||
}
|
||||
|
||||
static void S_StopChannel(INT32 cnum)
|
||||
@@ -1067,12 +1067,12 @@ INT32 S_OriginPlaying(void *origin)
|
||||
|
||||
// Searches through the channels and checks if a given id
|
||||
// is playing anywhere.
|
||||
INT32 S_IdPlaying(sfxenum_t sfx_id)
|
||||
INT32 S_IdPlaying(sfxenum_t id)
|
||||
{
|
||||
INT32 cnum;
|
||||
|
||||
for (cnum = 0; cnum < numofchannels; cnum++)
|
||||
if (channels[cnum].sfxinfo == &S_sfx[sfx_id])
|
||||
if ((size_t)(channels[cnum].sfxinfo - S_sfx) == (size_t)id)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
@@ -1080,7 +1080,7 @@ INT32 S_IdPlaying(sfxenum_t sfx_id)
|
||||
|
||||
// Searches through the channels and checks for
|
||||
// origin x playing sound id y.
|
||||
INT32 S_SoundPlaying(void *origin, sfxenum_t sfx_id)
|
||||
INT32 S_SoundPlaying(void *origin, sfxenum_t id)
|
||||
{
|
||||
INT32 cnum;
|
||||
|
||||
@@ -1089,8 +1089,8 @@ INT32 S_SoundPlaying(void *origin, sfxenum_t sfx_id)
|
||||
|
||||
for (cnum = 0; cnum < numofchannels; cnum++)
|
||||
{
|
||||
if (channels[cnum].origin == origin &&
|
||||
channels[cnum].sfxinfo == &S_sfx[sfx_id])
|
||||
if (channels[cnum].origin == origin
|
||||
&& (size_t)(channels[cnum].sfxinfo - S_sfx) == (size_t)id)
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -2193,7 +2193,7 @@ static void Command_Tunes_f(void)
|
||||
track = (UINT16)atoi(COM_Argv(2))-1;
|
||||
|
||||
if (tunenum)
|
||||
snprintf(mapmusic.name, sizeof(mapmusic.name), "%sM", G_BuildMapName(tunenum));
|
||||
snprintf(mapmusic.name, 7, "%sM", G_BuildMapName(tunenum));
|
||||
else
|
||||
strlcpy(mapmusic.name, tunearg, sizeof(mapmusic.name));
|
||||
|
||||
|
||||
+2
-2
@@ -286,8 +286,8 @@ void S_SetSfxVolume(INT32 volume);
|
||||
void S_SetMusicVolume(INT32 volume);
|
||||
|
||||
INT32 S_OriginPlaying(void *origin);
|
||||
INT32 S_IdPlaying(sfxenum_t sfx_id);
|
||||
INT32 S_SoundPlaying(void *origin, sfxenum_t sfx_id);
|
||||
INT32 S_IdPlaying(sfxenum_t id);
|
||||
INT32 S_SoundPlaying(void *origin, sfxenum_t id);
|
||||
|
||||
void S_StartSoundName(void *mo, const char *soundname);
|
||||
|
||||
|
||||
@@ -177,10 +177,6 @@ if(${SDL2_FOUND})
|
||||
)
|
||||
endif()
|
||||
|
||||
if("${CMAKE_SYSTEM_NAME}" MATCHES "OpenBSD")
|
||||
target_link_libraries(SRB2SDL2 PRIVATE pthread execinfo)
|
||||
endif()
|
||||
|
||||
if(${CMAKE_SYSTEM} MATCHES Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "GNU" AND ${SRB2_SYSTEM_BITS} EQUAL 32)
|
||||
target_link_libraries(SRB2SDL2 PRIVATE
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/../../libs/drmingw/lib/win32/libexchndl.a"
|
||||
@@ -247,10 +243,6 @@ if(${SDL2_FOUND})
|
||||
target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
|
||||
endif()
|
||||
|
||||
if(NOT SRB2_CONFIG_MUMBLE)
|
||||
target_compile_options(SRB2SDL2 PRIVATE -DNOMUMBLE)
|
||||
endif()
|
||||
|
||||
## strip debug symbols into separate file when using gcc
|
||||
# if(CMAKE_COMPILER_IS_GNUCC)
|
||||
# if(${CMAKE_BUILD_TYPE} MATCHES Debug)
|
||||
|
||||
+35
-74
@@ -57,13 +57,10 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
|
||||
#include <time.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef __GNUC__
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#if defined (__unix__) || defined (UNIXCOMMON)
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
|
||||
@@ -580,7 +577,7 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
I_Error("I_OutputMsg: Out of memory!\n");
|
||||
|
||||
va_start(argptr, fmt);
|
||||
vsnprintf(txt, len+1, fmt, argptr);
|
||||
vsprintf(txt, fmt, argptr);
|
||||
va_end(argptr);
|
||||
|
||||
#ifdef HAVE_TTF
|
||||
@@ -588,7 +585,7 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
DEFAULTFONTBGR, DEFAULTFONTBGG, DEFAULTFONTBGB, DEFAULTFONTBGA, txt);
|
||||
#endif
|
||||
|
||||
len = strnlen(txt, len+1);
|
||||
len = strlen(txt);
|
||||
|
||||
#ifdef LOGMESSAGES
|
||||
if (logstream)
|
||||
@@ -986,13 +983,13 @@ void I_InitJoystick(UINT8 index)
|
||||
|
||||
{
|
||||
char dbpath[1024];
|
||||
snprintf(dbpath, sizeof(dbpath), "%s" PATHSEP "gamecontrollerdb.txt", srb2path);
|
||||
sprintf(dbpath, "%s" PATHSEP "gamecontrollerdb.txt", srb2path);
|
||||
SDL_GameControllerAddMappingsFromFile(dbpath);
|
||||
}
|
||||
|
||||
{
|
||||
char dbpath[1024];
|
||||
snprintf(dbpath, sizeof(dbpath), "%s" PATHSEP "gamecontrollerdb_user.txt", srb2home);
|
||||
sprintf(dbpath, "%s" PATHSEP "gamecontrollerdb_user.txt", srb2home);
|
||||
SDL_GameControllerAddMappingsFromFile(dbpath);
|
||||
}
|
||||
|
||||
@@ -1021,8 +1018,6 @@ void I_InitJoystick(UINT8 index)
|
||||
}
|
||||
}
|
||||
|
||||
#if 0 // no dont do this
|
||||
// reset everything just in case
|
||||
JoyInfo[index].dev = NULL;
|
||||
JoyInfo[index].oldjoy = -1;
|
||||
#if (SDL_VERSION_ATLEAST(2,32,4))
|
||||
@@ -1030,7 +1025,6 @@ void I_InitJoystick(UINT8 index)
|
||||
#endif
|
||||
JoyInfo[index].hasled = false;
|
||||
JoyInfo[index].hasrumble = false;
|
||||
#endif
|
||||
|
||||
if (cv_usejoystick[index].value)
|
||||
newcontroller = SDL_GameControllerOpen(cv_usejoystick[index].value-1);
|
||||
@@ -1157,7 +1151,8 @@ const char *I_GetJoyName(INT32 joyindex)
|
||||
|
||||
if (tempname)
|
||||
{
|
||||
snprintf(joyname, sizeof(joyname), "%s", tempname);
|
||||
memcpy(joyname, tempname, 255);
|
||||
joyname[255] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1284,7 +1279,7 @@ static void I_SetupMumble(void)
|
||||
int shmfd;
|
||||
char memname[256];
|
||||
|
||||
snprintf(memname, sizeof(memname), "/MumbleLink.%d", getuid());
|
||||
snprintf(memname, 256, "/MumbleLink.%d", getuid());
|
||||
shmfd = shm_open(memname, O_RDWR, S_IRUSR | S_IWUSR);
|
||||
|
||||
if (shmfd < 0)
|
||||
@@ -1401,31 +1396,19 @@ void I_Sleep(UINT32 ms)
|
||||
|
||||
void I_SleepDuration(precise_t duration)
|
||||
{
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__) || defined(__OpenBSD__)
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__)
|
||||
UINT64 precision = I_GetPrecisePrecision();
|
||||
precise_t dest = I_GetPreciseTime() + duration;
|
||||
#ifdef __OpenBSD__
|
||||
precise_t slack = (precision / 50); // 20 ms slack
|
||||
#else
|
||||
precise_t slack = (precision / 5000); // 0.2 ms slack
|
||||
#endif
|
||||
if (duration > slack)
|
||||
{
|
||||
duration -= slack;
|
||||
struct timespec ts = {
|
||||
.tv_sec = static_cast<__time_t>(duration / precision),
|
||||
#ifdef __BIONIC__
|
||||
.tv_nsec = static_cast<long>(duration * 1000000000 / precision % 1000000000),
|
||||
#else
|
||||
.tv_nsec = static_cast<__syscall_slong_t>(duration * 1000000000 / precision % 1000000000),
|
||||
#endif
|
||||
};
|
||||
int status;
|
||||
#ifdef __OpenBSD__
|
||||
do status = nanosleep(&ts, &ts);
|
||||
#else
|
||||
do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
|
||||
#endif
|
||||
while (status == EINTR);
|
||||
}
|
||||
|
||||
@@ -1710,20 +1693,16 @@ static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_ms
|
||||
if (core_dumped)
|
||||
{
|
||||
if (sigmsg)
|
||||
{
|
||||
snprintf(signal_msg, 512, "%s (core dumped)", sigmsg);
|
||||
}
|
||||
sprintf(signal_msg, "%s (core dumped)", sigmsg);
|
||||
else
|
||||
{
|
||||
strcat(signal_msg, " (core dumped)");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf(signal_msg, 512, "%s", sigmsg);
|
||||
sprintf(signal_msg, "%s", sigmsg);
|
||||
}
|
||||
|
||||
snprintf(signal_name, 128, "%s", signame);
|
||||
sprintf(signal_name, "%s", signame);
|
||||
}
|
||||
|
||||
int I_OpenURL(const char *url)
|
||||
@@ -1901,7 +1880,7 @@ FUNCNORETURN static ATTRNORETURN void newsignalhandler_Warn(const char *pr)
|
||||
{
|
||||
char text[128];
|
||||
|
||||
snprintf(text, sizeof(text),
|
||||
snprintf(text, sizeof text,
|
||||
"Error while setting up signal reporting: %s: %s",
|
||||
pr,
|
||||
strerror(errno)
|
||||
@@ -2117,7 +2096,7 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
|
||||
if (errorcount > 20)
|
||||
{
|
||||
va_start(argptr, error);
|
||||
vsnprintf(buffer, sizeof(buffer), error, argptr);
|
||||
vsnprintf(buffer, 8192, error, argptr);
|
||||
va_end(argptr);
|
||||
|
||||
sigttl = "SRB2Kart " VERSIONSTRING " Recursive Error";
|
||||
@@ -2131,7 +2110,7 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
|
||||
|
||||
// Display error message in the console before we start shutting it down
|
||||
va_start(argptr, error);
|
||||
vsnprintf(buffer, sizeof(buffer), error, argptr);
|
||||
vsnprintf(buffer, 8192, error, argptr);
|
||||
va_end(argptr);
|
||||
I_OutputMsg("\nI_Error(): %s\n", buffer);
|
||||
|
||||
@@ -2274,7 +2253,6 @@ void I_ShutdownSystem(void)
|
||||
for (c = MAX_QUIT_FUNCS-1; c >= 0; c--)
|
||||
if (quit_funcs[c])
|
||||
(*quit_funcs[c])();
|
||||
|
||||
#ifdef LOGMESSAGES
|
||||
if (logstream)
|
||||
{
|
||||
@@ -2359,8 +2337,7 @@ char *I_GetUserName(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(username, sizeof(username), "%s", p);
|
||||
strncpy(username, p, MAXPLAYERNAME);
|
||||
}
|
||||
|
||||
if (!fastcmp(username, ""))
|
||||
@@ -2384,24 +2361,6 @@ INT32 I_mkdir(const char *dirname, INT32 unixright)
|
||||
#endif
|
||||
}
|
||||
|
||||
INT32 I_ChDir(const char *path)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return (SetCurrentDirectoryA(path) ? 0 : -1);
|
||||
#else
|
||||
return chdir(path);
|
||||
#endif
|
||||
}
|
||||
|
||||
char *I_GetCwd(char *buf, size_t size)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return (GetCurrentDirectoryA((DWORD)size, buf) ? buf : NULL);
|
||||
#else
|
||||
return getcwd(buf, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
#ifdef NEED_SDL_GETENV
|
||||
@@ -2423,15 +2382,13 @@ INT32 I_PutEnv(char *variable)
|
||||
INT32 I_ClipboardCopy(const char *data, size_t size)
|
||||
{
|
||||
char storage[256];
|
||||
|
||||
if (size > 255)
|
||||
size = 255;
|
||||
|
||||
snprintf(storage, sizeof(storage), "%.*s", (int)size, data);
|
||||
memcpy(storage, data, size);
|
||||
storage[size] = 0;
|
||||
|
||||
if (SDL_SetClipboardText(storage))
|
||||
return 0;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -2444,7 +2401,7 @@ const char *I_ClipboardPaste(void)
|
||||
return NULL;
|
||||
|
||||
clipboard_contents = SDL_GetClipboardText();
|
||||
snprintf(clipboard_modified, sizeof(clipboard_modified), "%s", clipboard_contents);
|
||||
strlcpy(clipboard_modified, clipboard_contents, 256);
|
||||
SDL_free(clipboard_contents);
|
||||
|
||||
while (*i)
|
||||
@@ -2460,7 +2417,6 @@ const char *I_ClipboardPaste(void)
|
||||
*i = '?'; // Nonprintable chars become question marks
|
||||
++i;
|
||||
}
|
||||
|
||||
return (const char *)&clipboard_modified;
|
||||
}
|
||||
|
||||
@@ -2474,23 +2430,28 @@ const char *I_ClipboardPaste(void)
|
||||
*/
|
||||
static boolean isWadPathOk(const char *path)
|
||||
{
|
||||
char wad3path[256];
|
||||
char *wad3path = static_cast<char*>(malloc(256));
|
||||
|
||||
snprintf(wad3path, sizeof(wad3path), pandf, path, WADKEYWORD);
|
||||
if (!wad3path)
|
||||
return false;
|
||||
|
||||
sprintf(wad3path, pandf, path, WADKEYWORD);
|
||||
|
||||
if (FIL_ReadFileOK(wad3path))
|
||||
{
|
||||
free(wad3path);
|
||||
return true;
|
||||
}
|
||||
|
||||
free(wad3path);
|
||||
return false;
|
||||
}
|
||||
|
||||
static void pathonly(char *s, size_t size)
|
||||
static void pathonly(char *s)
|
||||
{
|
||||
size_t j;
|
||||
|
||||
for (j = strnlen(s, size); j != (size_t)-1; j--)
|
||||
for (j = strlen(s); j != (size_t)-1; j--)
|
||||
{
|
||||
if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
|
||||
{
|
||||
@@ -2517,12 +2478,11 @@ static const char *searchWad(const char *searchDir)
|
||||
static char tempsw[256] = "";
|
||||
filestatus_t fstemp;
|
||||
|
||||
snprintf(tempsw, sizeof(tempsw), "%s", WADKEYWORD);
|
||||
strcpy(tempsw, WADKEYWORD);
|
||||
fstemp = filesearch(tempsw, searchDir, NULL, true, 20);
|
||||
|
||||
if (fstemp == FS_FOUND)
|
||||
{
|
||||
pathonly(tempsw, sizeof(tempsw));
|
||||
pathonly(tempsw);
|
||||
return tempsw;
|
||||
}
|
||||
|
||||
@@ -2560,7 +2520,7 @@ static const char *locateWad(void)
|
||||
|
||||
#ifndef NOCWD
|
||||
// examine current dir
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s", ".");
|
||||
strcpy(returnWadPath, ".");
|
||||
I_OutputMsg(",%s", returnWadPath);
|
||||
if (isWadPathOk(returnWadPath))
|
||||
return NULL;
|
||||
@@ -2572,7 +2532,7 @@ static const char *locateWad(void)
|
||||
// examine user jart directory
|
||||
if ((envstr = I_GetEnv("HOME")) != NULL)
|
||||
{
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s" PATHSEP DEFAULTDIR, envstr);
|
||||
sprintf(returnWadPath, "%s" PATHSEP DEFAULTDIR, envstr);
|
||||
CHECKWADPATH(returnWadPath);
|
||||
}
|
||||
#endif
|
||||
@@ -2586,7 +2546,7 @@ static const char *locateWad(void)
|
||||
// examine default dirs
|
||||
for (i = 0; wadDefaultPaths[i]; i++)
|
||||
{
|
||||
snprintf(returnWadPath, sizeof(returnWadPath), "%s", wadDefaultPaths[i]);
|
||||
strcpy(returnWadPath, wadDefaultPaths[i]);
|
||||
CHECKWADPATH(returnWadPath);
|
||||
}
|
||||
|
||||
@@ -2614,11 +2574,12 @@ extern "C" const char *I_LocateWad(void)
|
||||
// change to the directory where we found srb2.srb
|
||||
#if defined (_WIN32)
|
||||
waddir = _fullpath(NULL, waddir, MAX_PATH);
|
||||
SetCurrentDirectoryA(waddir);
|
||||
#else
|
||||
waddir = realpath(waddir, NULL);
|
||||
#endif
|
||||
if (waddir == NULL || I_ChDir(waddir) == -1)
|
||||
if (waddir == NULL || chdir(waddir) == -1)
|
||||
I_OutputMsg("Couldn't change working directory\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
return waddir;
|
||||
|
||||
+2
-8
@@ -183,17 +183,13 @@ void I_TTFDrawText(TTF_Font *font, TextQuality quality, INT32 fgR, INT32 fgG, IN
|
||||
TTFRect.x = TTFRectCheck.x;
|
||||
TTFRect.y = TTFRectCheck.y;
|
||||
}
|
||||
|
||||
// Copy the character to the text buffer.
|
||||
snprintf(textbuffer, sizeof(textbuffer), "%s%c", textbuffer, c);
|
||||
|
||||
sprintf(textbuffer, "%s%c", textbuffer, c);
|
||||
// Hack to allow TTF_SizeText to work properly.
|
||||
snprintf(linebuffer, sizeof(linebuffer), "%c", c);
|
||||
|
||||
sprintf(linebuffer, "%c", c);
|
||||
// If we have reached the end of the screen, move to the next available line.
|
||||
TTF_SizeText(currentfont, linebuffer, &w, &h);
|
||||
TTFRectCheck.x += w;
|
||||
|
||||
if (TTFRectCheck.x >= res.width)
|
||||
{
|
||||
// Render cached text to the SDL surface.
|
||||
@@ -208,10 +204,8 @@ void I_TTFDrawText(TTF_Font *font, TextQuality quality, INT32 fgR, INT32 fgG, IN
|
||||
TTFRect.y = TTFRectCheck.y;
|
||||
}
|
||||
}
|
||||
|
||||
// Add 1 to the pointer reference for the character to process.
|
||||
textmsg++;
|
||||
|
||||
// Copy contents of the now-old buffer to somewhere else, so it can be referenced in next loop.
|
||||
prevc = c;
|
||||
}
|
||||
|
||||
+3
-3
@@ -1538,9 +1538,9 @@ const char *VID_GetModeName(INT32 modeNum)
|
||||
if (modeNum > MAXWINMODES)
|
||||
return NULL;
|
||||
|
||||
snprintf(&vidModeName[modeNum][0], sizeof(vidModeName[modeNum]), "%dx%d",
|
||||
windowedModes[modeNum][0],
|
||||
windowedModes[modeNum][1]);
|
||||
sprintf(&vidModeName[modeNum][0], "%dx%d",
|
||||
windowedModes[modeNum][0],
|
||||
windowedModes[modeNum][1]);
|
||||
|
||||
return &vidModeName[modeNum][0];
|
||||
}
|
||||
|
||||
@@ -868,7 +868,7 @@ boolean I_SetSongSpeed(float speed)
|
||||
{
|
||||
// deprecated in 0.5.0
|
||||
char modspd[13];
|
||||
snprintf(modspd, sizeof(modspd), "%g", speed);
|
||||
sprintf(modspd, "%g", speed);
|
||||
openmpt_module_ctl_set(openmpt_mhandle, "play.tempo_factor", modspd);
|
||||
}
|
||||
#else
|
||||
|
||||
+3
-3
@@ -410,7 +410,7 @@ static void ST_drawDebugInfo(void)
|
||||
}
|
||||
|
||||
if (cv_debug & DBG_MEMORY)
|
||||
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("Heap used: %7sKB", sizeu1(Z_TotalUsage()>>10)));
|
||||
V_DrawRightAlignedString(320, height, V_MONOSPACE, va("Heap used: %7sKB", sizeu1(Z_TagsUsage(0, INT32_MAX)>>10)));
|
||||
}
|
||||
|
||||
static void ST_drawLevelTitle(void)
|
||||
@@ -568,7 +568,7 @@ static void ST_overlayDrawer(void)
|
||||
{
|
||||
if (!(multiplayer && demo.playback))
|
||||
{
|
||||
if (!P_IsLocalPlayer(stplyr))
|
||||
if(!P_IsLocalPlayer(stplyr))
|
||||
{
|
||||
/*char name[MAXPLAYERNAME+1];
|
||||
// shorten the name if its more than twelve characters.
|
||||
@@ -591,7 +591,7 @@ static void ST_overlayDrawer(void)
|
||||
char name[MAXPLAYERNAME+12];
|
||||
|
||||
INT32 y = (stplyrnum == 0) ? 4 : BASEVIDHEIGHT/2-12;
|
||||
snprintf(name, sizeof(name), "VIEWPOINT: %s", player_names[stplyr-players]);
|
||||
sprintf(name, "VIEWPOINT: %s", player_names[stplyr-players]);
|
||||
V_DrawRightAlignedThinString(BASEVIDWIDTH-40, y, V_HUDTRANSHALF|V_ALLOWLOWERCASE|K_calcSplitFlags(V_SNAPTOTOP|V_SNAPTOBOTTOM|V_SNAPTORIGHT), name);
|
||||
}
|
||||
else if (splitscreen)
|
||||
|
||||
+6
-13
@@ -581,19 +581,13 @@ const char *GetPalette(void)
|
||||
|
||||
if (user && user[0])
|
||||
{
|
||||
const lumpnum_t palnum = W_CheckNumForName(user);
|
||||
|
||||
if (palnum == LUMPERROR)
|
||||
if (W_CheckNumForName(user) == LUMPERROR)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "cv_palette %s lump does not exist\n", user);
|
||||
}
|
||||
else if (W_LumpLength(palnum) % (256 * 3) != 0) // not divisable by 768, so most def not a valid palette, idk if theres a better way to check this
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "cv_palette %s is not a valid palette lump\n", user);
|
||||
}
|
||||
else
|
||||
{
|
||||
return user;
|
||||
return cv_palette.string;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -615,16 +609,15 @@ void V_ReloadPalette(void)
|
||||
void V_SetPalette(INT32 palettenum)
|
||||
{
|
||||
RGBA_t *pal = NULL;
|
||||
|
||||
if (!pLocalPalette)
|
||||
V_ReloadPalette();
|
||||
|
||||
if (palettenum == 0)
|
||||
{
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_soft ||
|
||||
(rendermode == render_opengl && HWR_ShouldUsePaletteRendering())) // opengl without paletterendering hates subpalettes
|
||||
if (rendermode == render_soft ||
|
||||
(rendermode == render_opengl && HWR_ShouldUsePaletteRendering())) // opengl without paletterendering hates subpalettes
|
||||
#endif
|
||||
{
|
||||
if (palettenum == 0)
|
||||
{
|
||||
palettenum = cv_palettenum.value;
|
||||
}
|
||||
|
||||
+11
-10
@@ -292,7 +292,8 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
|
||||
if (!name)
|
||||
I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
|
||||
|
||||
snprintf(name, length + 1, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
name[length] = '\0';
|
||||
CONS_Printf("Loading SOC from %s\n", name);
|
||||
DEH_LoadDehackedLumpPwad(wadnum, posStart);
|
||||
free(name);
|
||||
@@ -327,7 +328,8 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum)
|
||||
if (!name)
|
||||
I_Error("W_LoadDehackedLumps: Out of memory!\n");
|
||||
|
||||
snprintf(name, length + 1, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
sprintf(name, "%s|%s", wadfiles[wadnum]->filename, lump_p->fullname);
|
||||
name[length] = '\0';
|
||||
|
||||
CONS_Printf(M_GetText("Loading SOC from %s\n"), name);
|
||||
DEH_LoadDehackedLumpPwad(wadnum, lump);
|
||||
@@ -396,11 +398,6 @@ FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
|
||||
return FNV1a_HashLowercaseString(name);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE UINT32 W_HashLumpNameLen(const char *name, size_t len)
|
||||
{
|
||||
return FNV1a_QuickCaseHash(name, len);
|
||||
}
|
||||
|
||||
/** Detect a file type.
|
||||
* \todo Actually detect the wad/pkzip headers and whatnot, instead of just checking the extensions.
|
||||
*/
|
||||
@@ -1100,14 +1097,18 @@ const char *W_CheckNameForNum(lumpnum_t lumpnum)
|
||||
UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
UINT16 i;
|
||||
static char uname[8 + 1];
|
||||
UINT32 hash;
|
||||
size_t namelen;
|
||||
|
||||
if (!TestValidLump(wad, 0))
|
||||
return INT16_MAX;
|
||||
|
||||
namelen = strnlen(name, 8); // :chaosleep:
|
||||
hash = W_HashLumpNameLen(name, namelen);
|
||||
memset(uname, 0, sizeof(uname));
|
||||
strncpy(uname, name, sizeof(uname)-1);
|
||||
strupr(uname);
|
||||
namelen = strlen(uname);
|
||||
hash = W_HashLumpName(uname);
|
||||
|
||||
//
|
||||
// scan forward
|
||||
@@ -1122,7 +1123,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
if (lump_p->namelength == namelen
|
||||
&& lump_p->hash.name == hash
|
||||
&& !strncasecmp(lump_p->name, name, namelen))
|
||||
&& !memcmp(lump_p->name, uname, sizeof(uname) - 1))
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -118,7 +118,7 @@ static VOID FPrintf(HANDLE fileHandle, LPCSTR lpFmt, ...)
|
||||
DWORD bytesWritten;
|
||||
|
||||
va_start(arglist, lpFmt);
|
||||
vsnprintf(str, sizeof(str), lpFmt, arglist);
|
||||
vsnprintf(str, 1999, lpFmt, arglist);
|
||||
va_end(arglist);
|
||||
|
||||
WriteFile(fileHandle, str, (DWORD)strlen(str), &bytesWritten, NULL);
|
||||
|
||||
+21
-39
@@ -153,7 +153,7 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
|
||||
;
|
||||
else if ((data.rankingsmode = (boolean)rankingsmode))
|
||||
{
|
||||
snprintf(data.levelstring, sizeof(data.levelstring), "* Total Rankings *");
|
||||
sprintf(data.levelstring, "* Total Rankings *");
|
||||
data.encore = false;
|
||||
}
|
||||
else
|
||||
@@ -162,41 +162,32 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
|
||||
if (mapheaderinfo[prevmap]->levelflags & LF_NOZONE)
|
||||
{
|
||||
if (mapheaderinfo[prevmap]->actnum[0])
|
||||
{
|
||||
snprintf(data.levelstring,
|
||||
sizeof(data.levelstring),
|
||||
sizeof data.levelstring,
|
||||
"* %s %s *",
|
||||
mapheaderinfo[prevmap]->lvlttl, mapheaderinfo[prevmap]->actnum);
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf(data.levelstring,
|
||||
sizeof(data.levelstring),
|
||||
sizeof data.levelstring,
|
||||
"* %s *",
|
||||
mapheaderinfo[prevmap]->lvlttl);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const char *zonttl = (mapheaderinfo[prevmap]->zonttl[0] ? mapheaderinfo[prevmap]->zonttl : "Zone");
|
||||
|
||||
if (mapheaderinfo[prevmap]->actnum[0])
|
||||
{
|
||||
snprintf(data.levelstring,
|
||||
sizeof(data.levelstring),
|
||||
sizeof data.levelstring,
|
||||
"* %s %s %s *",
|
||||
mapheaderinfo[prevmap]->lvlttl, zonttl, mapheaderinfo[prevmap]->actnum);
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf(data.levelstring,
|
||||
sizeof(data.levelstring),
|
||||
sizeof data.levelstring,
|
||||
"* %s %s *",
|
||||
mapheaderinfo[prevmap]->lvlttl, zonttl);
|
||||
}
|
||||
}
|
||||
|
||||
data.levelstring[sizeof(data.levelstring) - 1] = '\0';
|
||||
data.levelstring[sizeof data.levelstring - 1] = '\0';
|
||||
|
||||
data.encore = encoremode;
|
||||
|
||||
@@ -256,7 +247,6 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
|
||||
}
|
||||
|
||||
if (demo.recording && !rankingsmode)
|
||||
{
|
||||
G_WriteStanding(
|
||||
data.pos[data.numplayers],
|
||||
data.name[data.numplayers],
|
||||
@@ -264,7 +254,6 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
|
||||
*data.color[data.numplayers],
|
||||
data.val[data.numplayers]
|
||||
);
|
||||
}
|
||||
|
||||
data.numplayers++;
|
||||
}
|
||||
@@ -276,13 +265,13 @@ static void Y_CalculateMatchData(UINT8 rankingsmode, void (*comparison)(INT32))
|
||||
//
|
||||
static void Y_PlayerStandingsDrawer(y_data_t *standings, INT32 x, INT32 hilicol)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
if (standings->numplayers == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
INT32 i;
|
||||
|
||||
#define NUMFORNEWCOLUMN 8
|
||||
INT32 y = 41, gutter = ((standings->numplayers > NUMFORNEWCOLUMN) ? 0 : (BASEVIDWIDTH/2));
|
||||
INT32 dupadjust = cv_betainterscreen.value ? 314 : vid.scaledwidth, duptweak = cv_betainterscreen.value ? -3 : (dupadjust - BASEVIDWIDTH)/2;
|
||||
@@ -323,12 +312,6 @@ static void Y_PlayerStandingsDrawer(y_data_t *standings, INT32 x, INT32 hilicol)
|
||||
const UINT8 pnum = standings->num[i];
|
||||
player_t *player = &players[pnum];
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
// 32 Player TODO: port over and cleanup standings drawer from sat-32p/blankart
|
||||
if (i > 16)
|
||||
break;
|
||||
#endif
|
||||
|
||||
if (pnum == MAXPLAYERS)
|
||||
;
|
||||
else if (!playeringame[pnum] || player->spectator)
|
||||
@@ -377,9 +360,9 @@ static void Y_PlayerStandingsDrawer(y_data_t *standings, INT32 x, INT32 hilicol)
|
||||
if (standings->increase[pnum] != UINT8_MAX)
|
||||
{
|
||||
if (standings->increase[pnum] > 9)
|
||||
snprintf(strtime, sizeof(strtime), "(+%02d)", standings->increase[pnum]);
|
||||
snprintf(strtime, sizeof strtime, "(+%02d)", standings->increase[pnum]);
|
||||
else
|
||||
snprintf(strtime, sizeof(strtime), "(+ %d)", standings->increase[pnum]);
|
||||
snprintf(strtime, sizeof strtime, "(+ %d)", standings->increase[pnum]);
|
||||
|
||||
if (standings->numplayers > NUMFORNEWCOLUMN)
|
||||
V_DrawRightAlignedThinString(x+135+gutter, y-1, V_6WIDTHSPACE, strtime);
|
||||
@@ -387,7 +370,7 @@ static void Y_PlayerStandingsDrawer(y_data_t *standings, INT32 x, INT32 hilicol)
|
||||
V_DrawRightAlignedString(x+120+gutter, y, 0, strtime);
|
||||
}
|
||||
|
||||
snprintf(strtime, sizeof(strtime), "%d", standings->val[i]);
|
||||
snprintf(strtime, sizeof strtime, "%d", standings->val[i]);
|
||||
|
||||
if (standings->numplayers > NUMFORNEWCOLUMN)
|
||||
V_DrawRightAlignedThinString(x+152+gutter, y-1, V_6WIDTHSPACE, strtime);
|
||||
@@ -402,9 +385,9 @@ static void Y_PlayerStandingsDrawer(y_data_t *standings, INT32 x, INT32 hilicol)
|
||||
{
|
||||
if (intertype == int_race)
|
||||
{
|
||||
snprintf(strtime, sizeof(strtime), "%i'%02i\"%02i", G_TicsToMinutes(standings->val[i], true),
|
||||
snprintf(strtime, sizeof strtime, "%i'%02i\"%02i", G_TicsToMinutes(standings->val[i], true),
|
||||
G_TicsToSeconds(standings->val[i]), G_TicsToCentiseconds(standings->val[i]));
|
||||
strtime[sizeof(strtime) - 1] = '\0';
|
||||
strtime[sizeof strtime - 1] = '\0';
|
||||
|
||||
if (standings->numplayers > NUMFORNEWCOLUMN)
|
||||
V_DrawRightAlignedThinString(x+152+gutter, y-1, V_6WIDTHSPACE, strtime);
|
||||
@@ -669,16 +652,15 @@ static void Y_UpdateRecordReplays(void)
|
||||
if ((gpath = malloc(glen)) == NULL)
|
||||
I_Error("Out of memory for replay filepath\n");
|
||||
|
||||
snprintf(gpath, glen, "%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(gamemap));
|
||||
|
||||
snprintf(lastdemo, sizeof(lastdemo)-1, "%s-%s-last.lmp", gpath, cv_chooseskin.string);
|
||||
sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(gamemap));
|
||||
snprintf(lastdemo, 255, "%s-%s-last.lmp", gpath, cv_chooseskin.string);
|
||||
|
||||
if (FIL_FileExists(lastdemo))
|
||||
{
|
||||
UINT8 *buf;
|
||||
size_t len = FIL_ReadFile(lastdemo, &buf);
|
||||
|
||||
snprintf(bestdemo, sizeof(bestdemo)-1, "%s-%s-time-best.lmp", gpath, cv_chooseskin.string);
|
||||
snprintf(bestdemo, 255, "%s-%s-time-best.lmp", gpath, cv_chooseskin.string);
|
||||
if (!FIL_FileExists(bestdemo) || G_CmpDemoTime(bestdemo, lastdemo) & 1)
|
||||
{ // Better time, save this demo.
|
||||
if (FIL_FileExists(bestdemo))
|
||||
@@ -687,7 +669,7 @@ static void Y_UpdateRecordReplays(void)
|
||||
CONS_Printf("\x83%s\x80 %s '%s'\n", M_GetText("NEW RECORD TIME!"), M_GetText("Saved replay as"), bestdemo);
|
||||
}
|
||||
|
||||
snprintf(bestdemo, sizeof(bestdemo)-1, "%s-%s-lap-best.lmp", gpath, cv_chooseskin.string);
|
||||
snprintf(bestdemo, 255, "%s-%s-lap-best.lmp", gpath, cv_chooseskin.string);
|
||||
if (!FIL_FileExists(bestdemo) || G_CmpDemoTime(bestdemo, lastdemo) & (1<<1))
|
||||
{ // Better lap time, save this demo.
|
||||
if (FIL_FileExists(bestdemo))
|
||||
@@ -1517,12 +1499,12 @@ void Y_StartVote(void)
|
||||
{
|
||||
if (mapheaderinfo[votelevels[i][0]]->actnum[0])
|
||||
snprintf(levelinfo[i].str,
|
||||
sizeof(levelinfo[i].str),
|
||||
sizeof levelinfo[i].str,
|
||||
"%s %s",
|
||||
mapheaderinfo[votelevels[i][0]]->lvlttl, mapheaderinfo[votelevels[i][0]]->actnum);
|
||||
else
|
||||
snprintf(levelinfo[i].str,
|
||||
sizeof(levelinfo[i].str),
|
||||
sizeof levelinfo[i].str,
|
||||
"%s",
|
||||
mapheaderinfo[votelevels[i][0]]->lvlttl);
|
||||
}
|
||||
@@ -1530,12 +1512,12 @@ void Y_StartVote(void)
|
||||
{
|
||||
if (mapheaderinfo[votelevels[i][0]]->actnum[0])
|
||||
snprintf(levelinfo[i].str,
|
||||
sizeof(levelinfo[i].str),
|
||||
sizeof levelinfo[i].str,
|
||||
"%s %s %s",
|
||||
mapheaderinfo[votelevels[i][0]]->lvlttl, mapheaderinfo[votelevels[i][0]]->zonttl, mapheaderinfo[votelevels[i][0]]->actnum);
|
||||
else
|
||||
snprintf(levelinfo[i].str,
|
||||
sizeof(levelinfo[i].str),
|
||||
sizeof levelinfo[i].str,
|
||||
"%s %s",
|
||||
mapheaderinfo[votelevels[i][0]]->lvlttl, mapheaderinfo[votelevels[i][0]]->zonttl);
|
||||
}
|
||||
|
||||
+147
-130
@@ -44,6 +44,7 @@
|
||||
#ifdef HAVE_VALGRIND
|
||||
#include "valgrind.h"
|
||||
static boolean Z_calloc = false;
|
||||
#include "memcheck.h"
|
||||
#endif
|
||||
|
||||
#define ZONEID 0xa441d13d
|
||||
@@ -75,7 +76,7 @@ typedef struct memblock_s
|
||||
#define MEMBLOCK(x) (memblock_t *)((uintptr_t)(x) - ALIGNPAD - sizeof(memblock_t))
|
||||
|
||||
// both the head and tail of the zone memory block list
|
||||
static memblock_t headlist[NUM_PURGETAGS];
|
||||
static memblock_t head;
|
||||
|
||||
static constexpr size_t kLevelLargePoolBlockSize = sizeof(mobj_t);
|
||||
static constexpr size_t kLevelMedPoolBlockSize = sizeof(precipmobj_t);
|
||||
@@ -107,14 +108,10 @@ static void Command_Memdump_f(void);
|
||||
void Z_Init(void)
|
||||
{
|
||||
size_t total, memfree;
|
||||
size_t i;
|
||||
|
||||
memset(&headlist, 0x00, sizeof(headlist));
|
||||
memset(&head, 0x00, sizeof(head));
|
||||
|
||||
for (i = 0; i < NUM_PURGETAGS; i++)
|
||||
{
|
||||
headlist[i].next = headlist[i].prev = &headlist[i];
|
||||
}
|
||||
head.next = head.prev = &head;
|
||||
|
||||
memfree = I_GetFreeMem(&total)>>20;
|
||||
|
||||
@@ -183,7 +180,7 @@ void Z_Free(void *ptr)
|
||||
if (block->user != NULL)
|
||||
*block->user = NULL;
|
||||
|
||||
#ifdef HAVE_VALGRIND
|
||||
#ifdef VALGRIND_DESTROY_MEMPOOL
|
||||
VALGRIND_DESTROY_MEMPOOL(block);
|
||||
#endif
|
||||
block->prev->next = block->next;
|
||||
@@ -208,7 +205,7 @@ static void *xm(size_t size)
|
||||
if (p == NULL)
|
||||
{
|
||||
// Oh crumbs: we're out of heap. Try purging the cache and reallocating.
|
||||
Z_FreeTags(PU_PURGELEVEL, NUM_PURGETAGS-1);
|
||||
Z_FreeTags(PU_PURGELEVEL, INT32_MAX);
|
||||
p = malloc(padedsize);
|
||||
|
||||
if (p == NULL)
|
||||
@@ -249,9 +246,13 @@ void *Z_Malloc(size_t size, INT32 tag, void *user)
|
||||
ptr = MEMORY(block);
|
||||
I_Assert((intptr_t)ptr % alignof (max_align_t) == 0);
|
||||
|
||||
block->next = headlist[tag].next;
|
||||
block->prev = &headlist[tag];
|
||||
headlist[tag].next = block;
|
||||
#ifdef HAVE_VALGRIND
|
||||
Z_calloc = false;
|
||||
#endif
|
||||
|
||||
block->next = head.next;
|
||||
block->prev = &head;
|
||||
head.next = block;
|
||||
block->next->prev = block;
|
||||
|
||||
block->tag = tag;
|
||||
@@ -262,9 +263,8 @@ void *Z_Malloc(size_t size, INT32 tag, void *user)
|
||||
#endif
|
||||
block->size = size;
|
||||
|
||||
#ifdef HAVE_VALGRIND
|
||||
#ifdef VALGRIND_CREATE_MEMPOOL
|
||||
VALGRIND_CREATE_MEMPOOL(block, size, Z_calloc);
|
||||
Z_calloc = false;
|
||||
#endif
|
||||
|
||||
#ifdef PARANOIA
|
||||
@@ -301,8 +301,7 @@ void *Z_Calloc2(size_t size, INT32 tag, void *user, const char *file, INT32 line
|
||||
void *Z_Calloc(size_t size, INT32 tag, void *user)
|
||||
#endif
|
||||
{
|
||||
|
||||
#ifdef HAVE_VALGRIND
|
||||
#ifdef VALGRIND_MEMPOOL_ALLOC
|
||||
Z_calloc = true;
|
||||
#endif
|
||||
#ifdef ZDEBUG
|
||||
@@ -415,7 +414,6 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
|
||||
#endif
|
||||
{
|
||||
memblock_t *block, *next;
|
||||
INT32 i;
|
||||
|
||||
#ifdef ZDEBUG
|
||||
Z_CheckHeap2(file, line);
|
||||
@@ -432,13 +430,11 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
|
||||
g_level_tiny_pool.release();
|
||||
}
|
||||
|
||||
for (i = lowtag; i <= hightag; i++)
|
||||
for (block = head.next; block != &head; block = next)
|
||||
{
|
||||
for (block = headlist[i].next; block != &headlist[i]; block = next)
|
||||
{
|
||||
next = block->next; // get link before freeing
|
||||
next = block->next; // get link before freeing
|
||||
if (block->tag >= lowtag && block->tag <= hightag)
|
||||
Z_Free(MEMORY(block));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -451,20 +447,18 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
|
||||
void Z_IterateTags(INT32 lowtag, INT32 hightag, boolean (*iterfunc)(void *))
|
||||
{
|
||||
memblock_t *block, *next;
|
||||
INT32 i;
|
||||
|
||||
if (!iterfunc)
|
||||
I_Error("Z_IterateTags: no iterator function was given");
|
||||
|
||||
for (i = lowtag; i <= hightag; i++)
|
||||
for (block = head.next; block != &head; block = next)
|
||||
{
|
||||
for (block = headlist[i].next; block != &headlist[i]; block = next)
|
||||
{
|
||||
next = block->next; // get link before possibly freeing
|
||||
next = block->next; // get link before possibly freeing
|
||||
|
||||
if (block->tag >= lowtag && block->tag <= hightag)
|
||||
{
|
||||
void *mem = MEMORY(block);
|
||||
boolean free = iterfunc(mem);
|
||||
|
||||
if (free)
|
||||
Z_Free(mem);
|
||||
}
|
||||
@@ -495,7 +489,7 @@ void Z_CheckMemCleanup(void)
|
||||
if (nextcleanup-- == 0)
|
||||
{
|
||||
nextcleanup = CLEANUPCOUNT;
|
||||
Z_FreeTags(PU_PURGELEVEL, NUM_PURGETAGS-1);
|
||||
Z_FreeTags(PU_PURGELEVEL, INT32_MAX);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -513,64 +507,124 @@ void Z_CheckHeap(INT32 tag)
|
||||
{
|
||||
memblock_t *block;
|
||||
UINT32 blocknumon = 0;
|
||||
size_t j;
|
||||
void *given;
|
||||
|
||||
#ifndef ZDEBUG
|
||||
(void)tag;
|
||||
#endif
|
||||
|
||||
#ifdef ZDEBUG
|
||||
#define HeapError(msg) \
|
||||
I_Error("Z_CheckHeap : %s:%d, block %u (owned by %s:%d) %s", \
|
||||
file, line, blocknumon, block->ownerfile, block->ownerline, msg)
|
||||
#else
|
||||
#define HeapError(msg) \
|
||||
I_Error("Z_CheckHeap : block %u (owned by %s:%d) %s", \
|
||||
blocknumon, block->ownerfile, block->ownerline, msg)
|
||||
#endif
|
||||
|
||||
for (j = 0; j < NUM_PURGETAGS; j++)
|
||||
for (block = head.next; block != &head; block = block->next)
|
||||
{
|
||||
for (block = headlist[j].next; block != &headlist[j]; block = block->next)
|
||||
{
|
||||
blocknumon++;
|
||||
given = MEMORY(block);
|
||||
blocknumon++;
|
||||
given = MEMORY(block);
|
||||
#ifdef ZDEBUG2
|
||||
CONS_Debug(DBG_MEMORY, "block %u owned by %s:%d\n",
|
||||
blocknumon, block->ownerfile, block->ownerline);
|
||||
CONS_Debug(DBG_MEMORY, "block %u owned by %s:%d\n",
|
||||
blocknumon, block->ownerfile, block->ownerline);
|
||||
#endif
|
||||
#ifdef HAVE_VALGRIND
|
||||
if (RUNNING_ON_VALGRIND && !VALGRIND_MEMPOOL_EXISTS(block))
|
||||
{
|
||||
HeapError(" should not exist");
|
||||
}
|
||||
#ifdef VALGRIND_MEMPOOL_EXISTS
|
||||
if (!VALGRIND_MEMPOOL_EXISTS(block))
|
||||
{
|
||||
I_Error("Z_CheckHeap :"
|
||||
#ifdef ZDEBUG
|
||||
" %s %d"
|
||||
#endif
|
||||
if (block->user != NULL && *(block->user) != given)
|
||||
{
|
||||
HeapError(" doesn't have a proper user");
|
||||
}
|
||||
|
||||
if (block->next->prev != block)
|
||||
{
|
||||
HeapError(" lacks proper backlink");
|
||||
}
|
||||
|
||||
if (block->prev->next != block)
|
||||
{
|
||||
HeapError(" lacks proper forward link");
|
||||
}
|
||||
#ifdef PARANOIA
|
||||
if (block->id != ZONEID)
|
||||
{
|
||||
HeapError(" has the wrong ID");
|
||||
}
|
||||
" block %u"
|
||||
#ifdef ZDEBUG
|
||||
" (owned by %s:%d)"
|
||||
#endif
|
||||
if (block->tag != j)
|
||||
{
|
||||
HeapError(va(" block is contained in the wrong headlist (got: %d expected: %s)", block->tag, sizeu1(j)));
|
||||
}
|
||||
" should not exist"
|
||||
#ifdef ZDEBUG
|
||||
, file, line
|
||||
#endif
|
||||
, blocknumon
|
||||
#ifdef ZDEBUG
|
||||
, block->ownerfile, block->ownerline
|
||||
#endif
|
||||
);
|
||||
}
|
||||
#endif
|
||||
if (block->user != NULL && *(block->user) != given)
|
||||
{
|
||||
I_Error("Z_CheckHeap :"
|
||||
#ifdef ZDEBUG
|
||||
" %s %d"
|
||||
#endif
|
||||
" block %u"
|
||||
#ifdef ZDEBUG
|
||||
" (owned by %s:%d)"
|
||||
#endif
|
||||
" doesn't have a proper user"
|
||||
#ifdef ZDEBUG
|
||||
, file, line
|
||||
#endif
|
||||
, blocknumon
|
||||
#ifdef ZDEBUG
|
||||
, block->ownerfile, block->ownerline
|
||||
#endif
|
||||
);
|
||||
}
|
||||
if (block->next->prev != block)
|
||||
{
|
||||
I_Error("Z_CheckHeap :"
|
||||
#ifdef ZDEBUG
|
||||
" %s %d"
|
||||
#endif
|
||||
" block %u"
|
||||
#ifdef ZDEBUG
|
||||
" (owned by %s:%d)"
|
||||
#endif
|
||||
" lacks proper backlink"
|
||||
#ifdef ZDEBUG
|
||||
, file, line
|
||||
#endif
|
||||
, blocknumon
|
||||
#ifdef ZDEBUG
|
||||
, block->ownerfile, block->ownerline
|
||||
#endif
|
||||
);
|
||||
}
|
||||
if (block->prev->next != block)
|
||||
{
|
||||
I_Error("Z_CheckHeap :"
|
||||
#ifdef ZDEBUG
|
||||
" %s %d"
|
||||
#endif
|
||||
" block %u"
|
||||
#ifdef ZDEBUG
|
||||
" (owned by %s:%d)"
|
||||
#endif
|
||||
" lacks proper forward link"
|
||||
#ifdef ZDEBUG
|
||||
, file, line
|
||||
#endif
|
||||
, blocknumon
|
||||
#ifdef ZDEBUG
|
||||
, block->ownerfile, block->ownerline
|
||||
#endif
|
||||
);
|
||||
}
|
||||
#ifdef PARANOIA
|
||||
if (block->id != ZONEID)
|
||||
{
|
||||
I_Error("Z_CheckHeap :"
|
||||
#ifdef ZDEBUG
|
||||
" %s %d"
|
||||
#endif
|
||||
" block %u"
|
||||
#ifdef ZDEBUG
|
||||
" (owned by %s:%d)"
|
||||
#endif
|
||||
" have the wrong ID"
|
||||
#ifdef ZDEBUG
|
||||
, file, line
|
||||
#endif
|
||||
, blocknumon
|
||||
#ifdef ZDEBUG
|
||||
, block->ownerfile, block->ownerline
|
||||
#endif
|
||||
);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -599,22 +653,13 @@ void Z_ChangeTag(void *ptr, INT32 tag)
|
||||
block = MEMBLOCK(ptr);
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (block->id != ZONEID)
|
||||
I_Error("Z_ChangeTag at %s:%d: wrong id", file, line);
|
||||
if (block->id != ZONEID) I_Error("Z_ChangeTag at %s:%d: wrong id", file, line);
|
||||
#endif
|
||||
|
||||
if (tag >= PU_PURGELEVEL && block->user == NULL)
|
||||
I_Error("Internal memory management error: "
|
||||
"tried to make block purgable but it has no owner");
|
||||
|
||||
block->prev->next = block->next;
|
||||
block->next->prev = block->prev;
|
||||
|
||||
block->next = headlist[tag].next;
|
||||
block->prev = &headlist[tag];
|
||||
headlist[tag].next = block;
|
||||
block->next->prev = block;
|
||||
|
||||
block->tag = tag;
|
||||
}
|
||||
|
||||
@@ -639,8 +684,7 @@ void Z_SetUser(void *ptr, void **newuser)
|
||||
block = MEMBLOCK(ptr);
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (block->id != ZONEID)
|
||||
I_Error("Z_SetUser at %s:%d: wrong id", file, line);
|
||||
if (block->id != ZONEID) I_Error("Z_SetUser at %s:%d: wrong id", file, line);
|
||||
#endif
|
||||
|
||||
if (block->tag >= PU_PURGELEVEL && newuser == NULL)
|
||||
@@ -665,21 +709,18 @@ void Z_SetUser(void *ptr, void **newuser)
|
||||
size_t Z_TagsUsage(INT32 lowtag, INT32 hightag)
|
||||
{
|
||||
size_t cnt = 0;
|
||||
memblock_t *head; // why was this called rover before?????
|
||||
INT32 i;
|
||||
memblock_t *rover;
|
||||
|
||||
for (i = lowtag; i <= hightag; i++)
|
||||
for (rover = head.next; rover != &head; rover = rover->next)
|
||||
{
|
||||
for (head = headlist[i].next; head != &headlist[i]; head = head->next)
|
||||
{
|
||||
cnt += head->size + sizeof *head;
|
||||
}
|
||||
if (rover->tag < lowtag || rover->tag > hightag)
|
||||
continue;
|
||||
cnt += rover->size + sizeof(memblock_t);
|
||||
}
|
||||
|
||||
return cnt;
|
||||
}
|
||||
|
||||
|
||||
// -----------------------
|
||||
// Miscellaneous functions
|
||||
// -----------------------
|
||||
@@ -693,8 +734,8 @@ static void Command_Memfree_f(void)
|
||||
|
||||
Z_CheckHeap(-1);
|
||||
CONS_Printf("\x82%s", M_GetText("Memory Info\n"));
|
||||
CONS_Printf(M_GetText("Total heap used : %7s KB\n"), sizeu1((Z_TotalUsage()>>10) + LUA_MemoryUsage()));
|
||||
CONS_Printf(M_GetText("Lua : %7s KB\n"), sizeu1(LUA_MemoryUsage())); // No longer uses z_zone memory but for consistency keep it here
|
||||
CONS_Printf(M_GetText("Total heap used : %7s KB\n"), sizeu1(Z_TotalUsage()>>10));
|
||||
CONS_Printf(M_GetText("Lua : %7s KB\n"), sizeu1(Z_TagUsage(PU_LUA)>>10));
|
||||
CONS_Printf(M_GetText("Static : %7s KB\n"), sizeu1(Z_TagUsage(PU_STATIC)>>10));
|
||||
CONS_Printf(M_GetText("Static (sound) : %7s KB\n"), sizeu1(Z_TagUsage(PU_SOUND)>>10));
|
||||
CONS_Printf(M_GetText("Static (music) : %7s KB\n"), sizeu1(Z_TagUsage(PU_MUSIC)>>10));
|
||||
@@ -708,7 +749,7 @@ static void Command_Memfree_f(void)
|
||||
CONS_Printf(M_GetText("Level (pooled) : %7s KB\n"), sizeu1(Z_LevelPoolUsage()>>10));
|
||||
CONS_Printf(M_GetText("Special thinker : %7s KB\n"), sizeu1(Z_TagUsage(PU_LEVSPEC)>>10));
|
||||
CONS_Printf(M_GetText("All purgable : %7s KB\n"),
|
||||
sizeu1(Z_TagsUsage(PU_PURGELEVEL, NUM_PURGETAGS-1)>>10));
|
||||
sizeu1(Z_TagsUsage(PU_PURGELEVEL, INT32_MAX)>>10));
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
@@ -737,24 +778,21 @@ static void Command_Memfree_f(void)
|
||||
static void Command_Memdump_f(void)
|
||||
{
|
||||
memblock_t *block;
|
||||
INT32 mintag = 0, maxtag = NUM_PURGETAGS-1;
|
||||
INT32 check;
|
||||
INT32 mintag = 0, maxtag = INT32_MAX;
|
||||
INT32 i;
|
||||
|
||||
if ((check = COM_CheckParm("-min")))
|
||||
mintag = atoi(COM_Argv(check + 1));
|
||||
if ((i = COM_CheckParm("-min")))
|
||||
mintag = atoi(COM_Argv(i + 1));
|
||||
|
||||
if ((check = COM_CheckParm("-max")))
|
||||
maxtag = atoi(COM_Argv(check + 1));
|
||||
if ((i = COM_CheckParm("-max")))
|
||||
maxtag = atoi(COM_Argv(i + 1));
|
||||
|
||||
for (i = mintag; i <= maxtag; i++)
|
||||
{
|
||||
for (block = headlist[i].next; block != &headlist[i]; block = block->next)
|
||||
for (block = head.next; block != &head; block = block->next)
|
||||
if (block->tag >= mintag && block->tag <= maxtag)
|
||||
{
|
||||
const char *filename = strrchr(block->ownerfile, PATHSEP[0]);
|
||||
CONS_Printf("[%3d] %s (%s) bytes @ %s:%d tag: %d (%d)\n", block->tag, sizeu1(block->size + sizeof(memblock_t)), sizeu2(block->size), filename ? filename + 1 : block->ownerfile, block->ownerline, block->tag, i);
|
||||
CONS_Printf("[%3d] %s (%s) bytes @ %s:%d\n", block->tag, sizeu1(block->size + sizeof(memblock_t)), sizeu2(block->size), filename ? filename + 1 : block->ownerfile, block->ownerline);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -804,27 +842,6 @@ void* Z_LevelPoolMalloc(size_t size)
|
||||
return p;
|
||||
}
|
||||
|
||||
boolean Z_IsMobjValid2(void *p, const char *file, INT32 line)
|
||||
{
|
||||
//(void)file;
|
||||
//(void)line;
|
||||
|
||||
// mobj was removed
|
||||
// no need to worry here
|
||||
if (p == NULL)
|
||||
return false;
|
||||
|
||||
// mobjs reside in the large pool
|
||||
if (!g_level_large_pool.ptrcheck(p))
|
||||
{
|
||||
//I_Error("invalid mobj! at %s:%d", file, line);
|
||||
CONS_Alert(CONS_ERROR, "invalid mobj! at %s:%d", file, line);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void* Z_LevelPoolCalloc(size_t size)
|
||||
{
|
||||
void* p = Z_LevelPoolMalloc(size);
|
||||
|
||||
+25
-30
@@ -42,42 +42,39 @@ extern "C" {
|
||||
enum
|
||||
{
|
||||
// Tags < PU_LEVEL are not purged until freed explicitly.
|
||||
PU_STATIC = 0, // static entire execution time
|
||||
PU_LUA, // static entire execution time -- used by lua so it doesn't get caught in loops forever
|
||||
PU_PERFSTATS, // static between changes to ps_samplesize cvar
|
||||
PU_STATIC = 1, // static entire execution time
|
||||
PU_LUA = 2, // static entire execution time -- used by lua so it doesn't get caught in loops forever
|
||||
PU_PERFSTATS = 3, // static between changes to ps_samplesize cvar
|
||||
|
||||
PU_SOUND, // static while playing
|
||||
PU_MUSIC, // static while playing
|
||||
PU_SOUND = 11, // static while playing
|
||||
PU_MUSIC = 12, // static while playing
|
||||
|
||||
PU_PATCH, // static entire execution time
|
||||
PU_PATCH_LOWPRIORITY, // lower priority patch, static until level exited
|
||||
PU_PATCH_ROTATED, // rotated patch, static until level exited or WAD added
|
||||
PU_PATCH_DATA, // patch data, lifetime depends on the patch that owns it
|
||||
PU_SPRITE, // sprite patch, static until WAD added
|
||||
PU_HUDGFX, // HUD patch, static until WAD added
|
||||
PU_PATCH = 14, // static entire execution time
|
||||
PU_PATCH_LOWPRIORITY = 15, // lower priority patch, static until level exited
|
||||
PU_PATCH_ROTATED = 16, // rotated patch, static entire execution time
|
||||
PU_PATCH_DATA = 17, // patch data, lifetime depends on the patch that owns it
|
||||
PU_SPRITE = 18, // sprite patch, static until WAD added
|
||||
PU_HUDGFX = 19, // HUD patch, static until WAD added
|
||||
|
||||
PU_HWRPATCHINFO, // Hardware GLPatch_t struct for OpenGL texture cache
|
||||
PU_HWRPATCHCOLMIPMAP, // Hardware GLMipmap_t struct colormap variation of patch
|
||||
PU_HWRMODELTEXTURE, // Hardware model texture
|
||||
PU_HWRPATCHINFO = 21, // Hardware GLPatch_t struct for OpenGL texture cache
|
||||
PU_HWRPATCHCOLMIPMAP = 22, // Hardware GLMipmap_t struct colormap variation of patch
|
||||
PU_HWRMODELTEXTURE = 23, // Hardware model texture
|
||||
|
||||
PU_HWRCACHE, // static until unlocked
|
||||
PU_CACHE, // static until unlocked
|
||||
PU_HWRCACHE = 48, // static until unlocked
|
||||
PU_CACHE = 49, // static until unlocked
|
||||
|
||||
// Tags s.t. PU_LEVEL <= tag < PU_PURGELEVEL are purged at level start
|
||||
PU_LEVEL, // static until level exited
|
||||
PU_LEVSPEC, // a special thinker in a level
|
||||
PU_HWRPLANE, // if ZPLANALLOC is enabled in hw_bsp.c, this is used to alloc polygons for OpenGL
|
||||
PU_LEVEL = 50, // static until level exited
|
||||
PU_LEVSPEC = 51, // a special thinker in a level
|
||||
PU_HWRPLANE = 52, // if ZPLANALLOC is enabled in hw_bsp.c, this is used to alloc polygons for OpenGL
|
||||
|
||||
// Tags >= PU_PURGELEVEL are purgable whenever needed
|
||||
PU_PURGELEVEL, // Note: this is never actually used as a tag
|
||||
PU_CACHE_UNLOCKED, // Note: unused
|
||||
PU_HWRCACHE_UNLOCKED, // 'unlocked' PU_HWRCACHE memory:
|
||||
PU_PURGELEVEL = 100, // Note: this is never actually used as a tag
|
||||
PU_CACHE_UNLOCKED = 101, // Note: unused
|
||||
PU_HWRCACHE_UNLOCKED = 102, // 'unlocked' PU_HWRCACHE memory:
|
||||
// 'second-level' cache for graphics
|
||||
|
||||
// stored in hardware format and downloaded as needed
|
||||
PU_HWRMODELTEXTURE_UNLOCKED, // 'unlocked' PU_HWRMODELTEXTURE memory
|
||||
|
||||
NUM_PURGETAGS
|
||||
// stored in hardware format and downloaded as needed
|
||||
PU_HWRMODELTEXTURE_UNLOCKED = 103, // 'unlocked' PU_HWRMODELTEXTURE memory
|
||||
};
|
||||
|
||||
//
|
||||
@@ -160,7 +157,7 @@ void Z_SetUser(void *ptr, void **newuser);
|
||||
//
|
||||
#define Z_TagUsage(tagnum) Z_TagsUsage(tagnum, tagnum)
|
||||
size_t Z_TagsUsage(INT32 lowtag, INT32 hightag);
|
||||
#define Z_TotalUsage() Z_TagsUsage(0, NUM_PURGETAGS-1)
|
||||
#define Z_TotalUsage() Z_TagsUsage(0, INT32_MAX)
|
||||
|
||||
//
|
||||
// Miscellaneous functions
|
||||
@@ -173,8 +170,6 @@ char *Z_StrDup(const char *in);
|
||||
size_t Z_LevelPoolUsage(void);
|
||||
void *Z_LevelPoolMalloc(size_t size);
|
||||
void *Z_LevelPoolCalloc(size_t size);
|
||||
#define Z_IsMobjValid(p) Z_IsMobjValid2(p, __FILE__, __LINE__)
|
||||
boolean Z_IsMobjValid2(void *p, const char *file, INT32 line);
|
||||
void Z_LevelPoolFree(void *p, size_t size);
|
||||
|
||||
// for use with CLEANUP macro
|
||||
|
||||
Reference in new issue
Block a user