z_zone: add asserts if zone memory functions are called from non main thread

also taken from srb2classic thanks!

src/CMakeLists.txt

@@ -54,7 +54,7 @@ set(SRB2_CORE_SOURCES
 	string.c
 	tables.c
 	v_video.c
-	w_wad.cpp
+	w_wad.c
 	y_inter.c
 	z_zone.cpp
 )
@@ -191,6 +191,7 @@ set(SRB2_CORE_GAME_SOURCES
 	k_kart.c
 	k_stats.c
 	i_time.c
+	i_threads.c
 
 	p_local.h
 	p_maputl.h

src/Makefile

@@ -269,13 +269,13 @@ endif
 
 ifdef USEASAN
 # compile with asan
-opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
+opts+=-fsanitize=address
 libs+=-fsanitize=address
 endif
 
 ifdef USEUBSAN
-# compile with ubsan
-opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
+# compile with asan
+opts+=-fsanitize=undefined
 libs+=-fsanitize=undefined
 endif
 
@@ -295,7 +295,6 @@ opts+=$(debug_opts)
 
 opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))
 
-CWFLAGS+=-std=gnu17
 CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers
 
 opts+=$(WFLAGS) $(CFLAGS)

src/Makefile.d/dedicated.mk

@@ -8,11 +8,6 @@ ifdef MINGW
 libs+=-mconsole
 endif
 
-ifndef NOTHREADS
-opts+=-DHAVE_THREADS
-sources+=dedicated/i_threads.c
-endif
-
 NOOPENMPT=1
 NOLIBGME=1
 NOHW=1

src/Makefile.d/features.mk

@@ -27,6 +27,11 @@ endif
 sources+=$(call List,hardware/Sourcefile)
 endif
 
+ifndef NOTHREADS
+opts+=-DHAVE_THREADS
+sources+=i_threads.c
+endif
+
 ifndef NOMD5
 sources+=md5.c
 endif

src/Makefile.d/sdl.mk

@@ -40,11 +40,6 @@ sources+=sdl/mixer_sound.c
   endif
 endif
 
-ifndef NOTHREADS
-opts+=-DHAVE_THREADS
-sources+=sdl/i_threads.c
-endif
-
 ifdef SDL_PKGCONFIG
 $(eval $(call Use_pkg_config,SDL))
 else

src/Makefile.d/versions.mk

@@ -20,8 +20,7 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wnull-dereference
-#WFLAGS+=-Wno-trigraphs
+WFLAGS:=-Wall -Wno-trigraphs -Wnull-dereference
 ifdef GCC152
 WFLAGS+=-Wzero-as-null-pointer-constant
 endif
@@ -32,7 +31,7 @@ ifndef RELAXWARNINGS
  WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
-# WFLAGS+=-Wno-div-by-zero
+ WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -63,7 +62,7 @@ endif
 endif
  WFLAGS+=-Wsign-compare
 ifdef GCC91
-# WFLAGS+=-Wno-error=address-of-packed-member
+ WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
  WFLAGS+=-Wlogical-op
@@ -106,14 +105,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-#WFLAGS+=-Wno-error=format-overflow=2
+WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-#WFLAGS+=-Wno-suggest-attribute=noreturn
+WFLAGS+=-Wno-suggest-attribute=noreturn
 endif
 
 ifdef NOLDWARNING
@@ -131,21 +130,21 @@ ifdef GCC44
 #WFLAGS+=-Wno-error=array-bounds
 endif
 ifdef GCC46
-# WFLAGS+=-Wno-error=suggest-attribute=noreturn
+ WFLAGS+=-Wno-error=suggest-attribute=noreturn
 endif
 ifdef GCC54
-# WFLAGS+=-Wno-logical-op -Wno-error=logical-op
+ WFLAGS+=-Wno-logical-op -Wno-error=logical-op
 endif
 ifdef GCC61
-# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
+ WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
 endif
 ifdef GCC71
  WFLAGS+=-Wimplicit-fallthrough=4
 endif
 ifdef GCC81
-# WFLAGS+=-Wno-error=format-overflow
-# WFLAGS+=-Wno-format-overflow
-# WFLAGS+=-Wno-error=multistatement-macros
+ WFLAGS+=-Wno-error=format-overflow
+ WFLAGS+=-Wno-format-overflow
+ WFLAGS+=-Wno-error=multistatement-macros
 endif
 
 ifneq (,$(filter $(CC) $(CXX),clang clang++))
@@ -184,6 +183,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-#WFLAGS+=-Wno-logical-op
+WFLAGS+=-Wno-logical-op
 endif
 endif

src/blua/lapi.c

@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
 LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
   lua_lock(L);
   luaC_checkGC(L);
-  setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len));
+  setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
   api_incr_top(L);
   lua_unlock(L);
 }

src/command.c

@@ -1178,7 +1178,7 @@ consvar_t *CV_FindVar(const char *name)
 	consvar_t *cvar;
 
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
-		if (fasticmp(name, cvar->name))
+		if (fasticmp(name,cvar->name))
 			return cvar;
 
 	return NULL;
@@ -1793,7 +1793,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
 					if (newvalue == oldvalue)
 						break; // don't loop forever if there's none of a certain gametype
 
-					if (newvalue >= 0 && newvalue < NUMMAPS && !mapheaderinfo[newvalue])
+					if (newvalue >= 0 && !mapheaderinfo[newvalue])
 						continue; // Don't allocate the header.  That just makes memory usage skyrocket.
 
 				} while (!M_CanShowLevelInList(newvalue, gt));

src/console.c

@@ -44,18 +44,18 @@
 #define MAXHUDLINES 20
 
 #ifdef HAVE_THREADS
-I_mutex con_mutex;
+I_Mutex con_mutex;
 
-// I_In_Exiting_Signal_Handler is an evil hack
+// g_in_exiting_signal_handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_LockMutex(&con_mutex); }
+#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_UnlockMutex(con_mutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/
 
 static boolean con_started = false; // console has been initialised
        boolean con_startup = false; // true at game startup, screen need refreshing
@@ -640,25 +640,65 @@ INT32 CON_ShiftChar(INT32 ch)
 
 	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
 	{
-		if (shiftdown ^ capslock)
-			ch = shiftxform[ch];
-	}
-	else // if we're holding shift we should still shift non letter symbols
-	{
-		if (shiftdown)
-			ch = shiftxform[ch];
-		else if (cv_keyboardlayout.value == 3)
+		if (cv_keyboardlayout.value == 3)
 		{
-			if (altdown & 0x2)
+			if (shiftdown ^ capslock)
+				ch = shiftxform[ch];
+			else if (altdown & 0x2)
 				ch = french_altgrxform[ch];
 			else
 				ch = HU_FallBackFrSpecialLetter(ch);
 		}
+		else
+		{
+			if (shiftdown ^ capslock)
+				ch = shiftxform[ch];
+		}
+	}
+	else	// if we're holding shift we should still shift non letter symbols
+	{
+		if (cv_keyboardlayout.value == 3)
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+			else if (altdown & 0x2)
+				ch = french_altgrxform[ch];
+			else
+				ch = HU_FallBackFrSpecialLetter(ch);
+		}
+		else
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+		}
 	}
 
 	return ch;
 }
 
+INT32 CON_ShitAndAltGrChar(INT32 ch)
+{
+	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
+	{
+		if (shiftdown ^ capslock)
+			ch = shiftxform[ch];
+	}
+	else	// if we're holding shift we should still shift non letter symbols
+	{
+		if (shiftdown)
+			ch = shiftxform[ch];
+		else if (altdown & 0x2)
+		{
+			ch = french_altgrxform[ch];
+		}
+		else
+		{
+			ch = HU_FallBackFrSpecialLetter(ch);
+		}
+	}
+
+	return ch;
+}
 
 // Clear time of console heads up messages
 //
@@ -852,7 +892,7 @@ boolean CON_Responder(event_t *ev)
 		return true;
 
 	// ctrl modifier -- changes behavior, adds shortcuts
-	if (ctrldown && (cv_keyboardlayout.value != 3 || (cv_keyboardlayout.value == 3 && !altdown)))
+	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
 	{
 		// show all cvars/commands that match what we have inputted
 		if (key == KEY_TAB)
@@ -1182,10 +1222,19 @@ void CON_LogMessage(const char *msg)
 // Console print! Wahooo! Lots o fun!
 //
 
-static inline void CONS_PrintMsg(char *txt)
+void CONS_Printf(const char *fmt, ...)
 {
+	va_list argptr;
+	static char *txt = NULL;
 	boolean startup;
 
+	if (txt == NULL)
+		txt = malloc(8192);
+
+	va_start(argptr, fmt);
+	vsnprintf(txt, 8192, fmt, argptr);
+	va_end(argptr);
+
 	// echo console prints to log file
 	DEBFILE(txt);
 
@@ -1211,21 +1260,6 @@ static inline void CONS_PrintMsg(char *txt)
 	}
 }
 
-void CONS_Printf(const char *fmt, ...)
-{
-	va_list argptr;
-	static char *txt = NULL;
-
-	if (txt == NULL)
-		txt = malloc(8192);
-
-	va_start(argptr, fmt);
-	vsnprintf(txt, 8192, fmt, argptr);
-	va_end(argptr);
-
-	CONS_PrintMsg(txt);
-}
-
 void CONS_Alert(alerttype_t level, const char *fmt, ...)
 {
 	va_list argptr;
@@ -1254,7 +1288,9 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
 			break;
 	}
 
-	CONS_PrintMsg(txt);
+	// I am lazy and I feel like just letting CONS_Printf take care of things.
+	// Is that okay?
+	CONS_Printf("%s", txt);
 }
 
 void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1272,9 +1308,11 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 	vsnprintf(txt, 8192, fmt, argptr);
 	va_end(argptr);
 
-	CONS_PrintMsg(txt);
+	// Again I am lazy, oh well
+	CONS_Printf("%s", txt);
 }
 
+
 // Print an error message, and wait for ENTER key to continue.
 // To make sure the user has seen the message
 //

src/console.h

@@ -13,10 +13,6 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -26,7 +22,7 @@ void CON_Init(void);
 boolean CON_Responder(event_t *ev);
 
 #ifdef HAVE_THREADS
-extern I_mutex con_mutex;
+extern I_Mutex con_mutex;
 #endif
 
 // set true when screen size has changed, to adapt console
@@ -49,6 +45,7 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
 extern UINT8 *consolebgmap;
 
 INT32 CON_ShiftChar(INT32 ch);
+INT32 CON_ShitAndAltGrChar(INT32 ch);
 
 void CON_SetupBackColormap(void);
 void CON_ClearHUD(void); // clear heads up messages
@@ -66,8 +63,4 @@ boolean CON_Ready(void);
 
 void CON_LogMessage(const char *msg);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

src/d_clisrv.h

@@ -654,17 +654,15 @@ void D_ResetTiccmds(void);
 
 tic_t GetLag(INT32 node);
 
-extern boolean hu_resynching;
+extern UINT8 hu_resynching;
 #ifdef SATURNPAK
-extern boolean hu_redownloadinggamestate;
+extern UINT8 hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 
-#define SAVEGAMESIZE (768*1024)
-
 typedef struct rewind_s
 {
-	UINT8 savebuffer[SAVEGAMESIZE];
+	UINT8 savebuffer[(768*1024)];
 	tic_t leveltime;
 	size_t demopos;
 

src/d_main.c

@@ -130,8 +130,8 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadwadcount = 0;
-static size_t postloadwadcount = 0;
+static size_t autoloadcount = 0;
+static size_t postloadcount = 0;
 //
 
 boolean devparm = false; // started game with -devparm
@@ -223,13 +223,13 @@ void D_ProcessEvents(void)
 
 		// Menu input
 #ifdef HAVE_THREADS
-		I_lock_mutex(&m_menu_mutex);
+		I_LockMutex(&m_menu_mutex);
 #endif
 		{
 			eaten = M_Responder(ev);
 		}
 #ifdef HAVE_THREADS
-		I_unlock_mutex(m_menu_mutex);
+		I_UnlockMutex(m_menu_mutex);
 #endif
 
 		if (eaten)
@@ -244,13 +244,13 @@ void D_ProcessEvents(void)
 
 		// console input
 #ifdef HAVE_THREADS
-		I_lock_mutex(&con_mutex);
+		I_LockMutex(&con_mutex);
 #endif
 		{
 			eaten = CON_Responder(ev);
 		}
 #ifdef HAVE_THREADS
-		I_unlock_mutex(con_mutex);
+		I_UnlockMutex(con_mutex);
 #endif
 
 		if (eaten)
@@ -274,17 +274,21 @@ static void D_Renderview(void)
 
 	R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL));
 
-	if (rendermode == render_soft && cv_homremoval.value)
+	if (rendermode == render_soft)
 	{
-		if (cv_homremoval.value == 1)
+		// if this is display player 1
+		if (cv_homremoval.value)
 		{
-			// Clear the software screen buffer to remove HOM
-			memset(vid.screens[0], 31, vid.width * vid.height);
-		}
-		else if (cv_homremoval.value == 2)
-		{
-			//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
-			memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
+			if (cv_homremoval.value == 1)
+			{
+				// Clear the software screen buffer to remove HOM
+				memset(vid.screens[0], 31, vid.width * vid.height);
+			}
+			else if (cv_homremoval.value == 2)
+			{
+				//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
+				memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
+			}
 		}
 	}
 
@@ -318,6 +322,7 @@ static void D_Renderview(void)
 					break;
 				default: // Initialize for P1
 					viewwindowy = viewwindowx = 0;
+					objectsdrawn = 0;
 					break;
 			}
 
@@ -328,17 +333,19 @@ static void D_Renderview(void)
 			}
 			else if (rendermode == render_soft)
 #endif
-			{
 				R_RenderPlayerView(&players[displayplayers[i]]);
+		}
+
+		if (rendermode == render_soft)
+		{
+			if (i == 0)
+				R_ApplyViewMorph();
 
-				if (i == 0)
-					R_ApplyViewMorph();
 #ifdef MOTIONBLUR
-				V_DoPostProcessor(i, postimgparam[i]);
+			V_DoPostProcessor(i, postimgparam[i]);
 #else
-				V_DoPostProcessor(i, 0);
+			V_DoPostProcessor(i, 0);
 #endif
-			}
 		}
 	}
 
@@ -570,11 +577,11 @@ static boolean D_Display(void)
 	vid.recalc = false;
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&m_menu_mutex);
+	I_LockMutex(&m_menu_mutex);
 #endif
 	M_Drawer(); // menu is drawn even on top of everything...
 #ifdef HAVE_THREADS
-	I_unlock_mutex(m_menu_mutex);
+	I_UnlockMutex(m_menu_mutex);
 #endif
 	// focus lost moved to M_Drawer
 
@@ -697,11 +704,6 @@ void D_SRB2Loop(void)
 
 	for (;;)
 	{
-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		// capbudget is the minimum precise_t duration of a single loop iteration
 		precise_t capbudget;
 		precise_t elapsed;
@@ -781,6 +783,11 @@ void D_SRB2Loop(void)
 
 				doDisplay = true;
 			}
+
+			if (!dedicated)
+			{
+				G_DeviceLEDTick();
+			}
 		}
 
 		if (interp)
@@ -822,13 +829,6 @@ void D_SRB2Loop(void)
 		if (takescreenshot)
 			M_DoScreenShot();
 
-#ifndef DEDICATED
-		if (!dedicated && renderisnewtic)
-		{
-			G_DeviceLEDTick();
-		}
-#endif
-
 		// consoleplayer -> displayplayers (hear sounds from viewpoint)
 		S_UpdateSounds(); // move positional sounds
 
@@ -1037,38 +1037,25 @@ static INT32 D_DetectFileType(const char* filename)
 }
 
 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);
 
-	if (*index >= MAX_WADFILES)
-	{
-		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
-		return;
-	}
-
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}
 
-	if (fileType == 1)
-	{
-		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
-		return;
-	}
-
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
+			I_Error("No more free memory to AutoloadFile %s",file);
 
 		strcpy(newfile, file);
-		filearray[*index] = newfile;
-		(*index)++;
+		filearray[index] = newfile;
 	}
 	else
 	{
@@ -1111,7 +1098,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}
 
@@ -1137,34 +1124,27 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';
 
-		// ok so theres still issues with players adding stuff to autoload by accident
-		// sometimes this stuff contains maps
-		// you can probably imagine how that goes in a netgame....
-		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
-		{
-			CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
-			continue;
-		}
-
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}
 
 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
+			autoloadcount++;
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
+			postloadcount++;
 		}
 	}
 
-	autoloadwadfiles[autoloadwadcount] = NULL;
-	autoloadwadfilespost[postloadwadcount] = NULL;
+	autoloadwadfiles[autoloadcount] = NULL;
+	autoloadwadfilespost[postloadcount] = NULL;
 
 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1173,7 +1153,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadwadcount == 0)
+	if (autoloadcount == 0)
 		return;
 
 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1181,15 +1161,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfiles, autoloadwadcount);
+	D_CleanFile(autoloadwadfiles, autoloadcount);
 
-	autoloadwadcount = 0;
+	autoloadcount = 0;
 }
 
 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadwadcount == 0 || !netgame)
+	if (postloadcount == 0 || !netgame)
 		return;
 
 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1197,9 +1177,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfilespost, postloadwadcount);
+	D_CleanFile(autoloadwadfilespost, postloadcount);
 
-	postloadwadcount = 0;
+	postloadcount = 0;
 }
 
 // ==========================================================================
@@ -1208,7 +1188,7 @@ void D_AddPostloadFiles(void)
 
 static boolean AddIWAD(const char * file, const char *dir)
 {
-	char *path = va(pandf, dir, file);
+	char * path = va(pandf, dir, file);
 
 	if (FIL_ReadFileOK(path))
 	{
@@ -1663,6 +1643,12 @@ void D_SRB2Main(void)
 	strcpy(srb2, "SRB2Kart");
 	D_MakeTitleString(srb2);
 
+#if defined (__OS2__) && !defined (HAVE_SDL)
+	// set PM window title
+	snprintf(pmData->title, sizeof (pmData->title), "SRB2Kart" VERSIONSTRING ": %s", title);
+	pmData->title[sizeof (pmData->title) - 1] = '\0';
+#endif
+
 	if (devparm)
 		CONS_Printf(M_GetText("Development mode ON.\n"));
 
@@ -2043,7 +2029,7 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
-		gconst char *replayname = strrchr(replayurl, '/');
+		char *replayname = strrchr(replayurl, '/');
 
 		if (!replayname || !replayurl)
 			I_Error("REPLAY: Invalid URL.");

src/d_net.c

@@ -612,8 +612,12 @@ void Net_WaitAllAckReceived(UINT32 timeout)
 
 static void InitNode(node_t *node)
 {
-	memset(node, 0, sizeof(node_t));
+	node->acktosend_head = node->acktosend_tail = 0;
+	memset(node->acktosend, 0, sizeof(node->acktosend));
+	node->firstacktosend = 0;
 	node->nextacknum = 1;
+	node->remotefirstack = 0;
+	node->flags = 0;
 }
 
 static void InitAck(void)

src/d_netcmd.c

@@ -1208,11 +1208,11 @@ static boolean AllowedPlayerNameChar(char ch)
 
 static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 {
-	size_t ix, len = strlen(name);
+	INT32 ix;
 
-	if (len == 0 || len > MAXPLAYERNAME)
+	if (strlen(name) == 0 || strlen(name) > MAXPLAYERNAME)
 		return false; // Empty or too long.
-	if (name[0] == ' ' || name[len-1] == ' ')
+	if (name[0] == ' ' || name[strlen(name)-1] == ' ')
 		return false; // Starts or ends with a space.
 	if (isdigit(name[0]))
 		return false; // Starts with a digit.
@@ -1226,19 +1226,20 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
 
 	// Also, anything over 0x80 is disallowed too, since compilers love to
 	// differ on whether they're printable characters or not.
-	for (ix = 0; ix < len; ix++)
+	for (ix = 0; name[ix] != '\0'; ix++)
 		if (!AllowedPlayerNameChar(name[ix]))
 			return false;
 
 	// Check if a player is currently using the name, case-insensitively.
 	for (ix = 0; ix < MAXPLAYERS; ix++)
 	{
-		if (ix != (size_t)playernum && playeringame[ix]
+		if (ix != playernum && playeringame[ix]
 			&& fasticmp(name, player_names[ix]))
 		{
 			// We shouldn't kick people out just because
 			// they joined the game with the same name
 			// as someone else -- modify the name instead.
+			size_t len = strlen(name);
 
 			// Recursion!
 			// Slowly strip characters off the end of the
@@ -1457,9 +1458,7 @@ UINT8 CanChangeSkin(INT32 playernum)
 				return true;
 		}
 
-		if (players[playernum].spectator ||
-			players[playernum].playerstate == PST_DEAD ||
-			players[playernum].playerstate == PST_REBORN)
+		if (players[playernum].spectator || players[playernum].playerstate == PST_DEAD || players[playernum].playerstate == PST_REBORN)
 			return true;
 
 		return false;
@@ -1493,144 +1492,445 @@ static void ForceAllSkins(INT32 forcedskin)
 	}
 }
 
-static INT32 chmappending;
-static INT32 snacpending[MAXSPLITSCREENPLAYERS];
-
-// wonky compat, idk if anything uses this....
-#define playerisbot (splitplayer == 1 && botingame)
+static INT32 snacpending = 0, snac2pending = 0, snac3pending = 0, snac4pending = 0, chmappending = 0;
 
 // name, color, or skin has changed
 //
-static void SendNameAndColor(UINT8 splitplayer)
+static void SendNameAndColor(void)
 {
 	char buf[MAXPLAYERNAME+2];
 	char *p;
 
 	p = buf;
 
-	// splitscreen
-	if (splitscreen < splitplayer && !playerisbot)
-		return;
-
-	const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
-
-	player_t *player = &players[pnum];
-
-	// TODO: make those cvars arrays
-	consvar_t *playercolor, *playername, *playerskin;
-	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
-	consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
-	consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
-
-	playercolor = colorvars[splitplayer];
-	playername  = namevars[splitplayer];
-	playerskin  = skinvars[splitplayer];
-
 	// normal player colors
 	if (G_GametypeHasTeams())
 	{
-		if (player->ctfteam == 1 && playercolor->value != skincolor_redteam)
-			CV_StealthSetValue(playercolor, skincolor_redteam);
-		else if (player->ctfteam == 2 && playercolor->value != skincolor_blueteam)
-			CV_StealthSetValue(playercolor, skincolor_blueteam);
+		if (players[consoleplayer].ctfteam == 1 && cv_playercolor.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor, skincolor_redteam);
+		else if (players[consoleplayer].ctfteam == 2 && cv_playercolor.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor, skincolor_blueteam);
 	}
 
 	// never allow the color "none"
-	if (!playercolor->value)
+	if (!cv_playercolor.value)
 	{
-		if (player->skincolor)
-			CV_StealthSetValue(playercolor, player->skincolor);
-		else if (skins[player->skin].prefcolor)
-			CV_StealthSetValue(playercolor, skins[player->skin].prefcolor);
+		if (players[consoleplayer].skincolor)
+			CV_StealthSetValue(&cv_playercolor, players[consoleplayer].skincolor);
+		else if (skins[players[consoleplayer].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
 		else
-			CV_StealthSet(playercolor, playercolor->defaultvalue);
+			CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
 	}
 
+	if (fastcmp(cv_playername.string, player_names[consoleplayer])
+		&& cv_playercolor.value == players[consoleplayer].skincolor
+		&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
+		return;
+
 	// We'll handle it later if we're not playing.
 	if (!Playing())
 		return;
 
-	if (fastcmp(playername->string, player_names[pnum])
-		&& playercolor->value == player->skincolor
-		&& fastcmp(playerskin->string, skins[player->skin].name))
-		return;
-
-	if (playerisbot)
-	{
-		players[pnum].skincolor = botcolor;
-		if (players[pnum].mo)
-			players[pnum].mo->color = players[pnum].skincolor;
-		SetPlayerSkinByNum(pnum, botskin-1);
-		return;
-	}
-
 	// If you're not in a netgame, merely update the skin, color, and name.
 	if (!netgame)
 	{
 		INT32 foundskin;
 
-		CleanupPlayerName(pnum, playername->zstring);
-		strcpy(player_names[pnum], playername->zstring);
+		CleanupPlayerName(consoleplayer, cv_playername.zstring);
+		strcpy(player_names[consoleplayer], cv_playername.zstring);
 
-		player->skincolor = playercolor->value;
+		players[consoleplayer].skincolor = cv_playercolor.value;
 
-		if (player->mo)
-			player->mo->color = player->skincolor;
+		if (players[consoleplayer].mo)
+			players[consoleplayer].mo->color = players[consoleplayer].skincolor;
 
-		if ((foundskin = R_SkinAvailable(playerskin->string)) != -1)
+		if ((foundskin = R_SkinAvailable(cv_skin.string)) != -1)
 		{
-			playerskin->value = foundskin;
-			SetPlayerSkin(pnum, playerskin->string);
-			CV_StealthSet(playerskin, skins[playerskin->value].name);
+			cv_skin.value = foundskin;
+			SetPlayerSkin(consoleplayer, cv_skin.string);
+			CV_StealthSet(&cv_skin, skins[cv_skin.value].name);
 		}
 		else
 		{
-			playerskin->value = player->skin;
-			CV_StealthSet(playerskin, skins[player->skin].name);
+			cv_skin.value = players[consoleplayer].skin;
+			CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 			// will always be same as current
-			SetPlayerSkin(pnum, playerskin->string);
+			SetPlayerSkin(consoleplayer, cv_skin.string);
 		}
 
 		return;
 	}
 
-	snacpending[splitplayer]++;
+	snacpending++;
 
 	// Don't change name if muted
-	if (player_name_changes[pnum] >= MAXNAMECHANGES)
+	if (player_name_changes[consoleplayer] >= MAXNAMECHANGES)
 	{
-		CV_StealthSet(playername, player_names[pnum]);
+		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
 		HU_AddChatText("\x85*You must wait to change your name again", false);
 	}
-	else if (cv_mute.value && !(server || IsPlayerAdmin(pnum)))
-		CV_StealthSet(playername, player_names[pnum]);
+	else if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
+		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
 	else // Cleanup name if changing it
-		CleanupPlayerName(pnum, playername->zstring);
+		CleanupPlayerName(consoleplayer, cv_playername.zstring);
 
 	// Don't change skin if the server doesn't want you to.
-	if (!CanChangeSkin(pnum))
-		CV_StealthSet(playerskin, skins[player->skin].name);
+	if (!CanChangeSkin(consoleplayer))
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 
 	// check if player has the skin loaded (cv_skin may have
 	// the name of a skin that was available in the previous game)
-	playerskin->value = R_SkinAvailable(playerskin->string);
-	if (playerskin->value < 0)
+	cv_skin.value = R_SkinAvailable(cv_skin.string);
+	if (cv_skin.value < 0)
 	{
-		INT32 skinnum = player->skin;
-		CV_StealthSet(playerskin, skins[skinnum].name);
-		playerskin->value = skinnum;
+		INT32 skinnum = players[consoleplayer].skin;
+		CV_StealthSet(&cv_skin, skins[skinnum].name);
+		cv_skin.value = skinnum;
 	}
 
 	// Finally write out the complete packet and send it off.
-	WRITESTRINGN(p, playername->zstring, MAXPLAYERNAME);
-	WRITEUINT8(p, (UINT8)playercolor->value);
-	WRITEUINT8(p, (UINT8)playerskin->value);
-	SendNetXCmdForPlayer(splitplayer, XD_NAMEANDCOLOR, buf, p - buf);
+	WRITESTRINGN(p, cv_playername.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor.value);
+	WRITEUINT8(p, (UINT8)cv_skin.value);
+	SendNetXCmdForPlayer(0, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+// splitscreen
+static void SendNameAndColor2(void)
+{
+	INT32 secondplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 1 && !botingame)
+		return; // can happen if skin2/color2/name2 changed
+
+	if (displayplayers[1] != consoleplayer)
+		secondplaya = displayplayers[1];
+	else if (!netgame) // HACK
+		secondplaya = 1;
+
+	if (secondplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[secondplaya].ctfteam == 1 && cv_playercolor2.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor2, skincolor_redteam);
+		else if (players[secondplaya].ctfteam == 2 && cv_playercolor2.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor2, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor2.value)
+	{
+		if (players[secondplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor2, players[secondplaya].skincolor);
+		else if (skins[players[secondplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor2, skins[players[secondplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor2, cv_playercolor2.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (botingame)
+	{
+		players[secondplaya].skincolor = botcolor;
+		if (players[secondplaya].mo)
+			players[secondplaya].mo->color = players[secondplaya].skincolor;
+		SetPlayerSkinByNum(secondplaya, botskin-1);
+		return;
+	}
+	else if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(secondplaya, cv_playername2.zstring);
+		strcpy(player_names[secondplaya], cv_playername2.zstring);
+
+		// don't use displayplayers[1]: the second player must be 1
+		players[secondplaya].skincolor = cv_playercolor2.value;
+		if (players[secondplaya].mo)
+			players[secondplaya].mo->color = players[secondplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin2.string)) != -1)
+		{
+			cv_skin2.value = foundskin;
+			SetPlayerSkin(secondplaya, cv_skin2.string);
+		}
+		else
+		{
+			cv_skin2.value = players[secondplaya].skin;
+			CV_StealthSet(&cv_skin2, skins[players[secondplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(secondplaya, cv_skin2.string);
+		}
+		return;
+	}
+
+	snac2pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[1]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[1])))
+		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[1], cv_playername2.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[1]))
+		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
+
+	// check if player has the skin loaded (cv_skin2 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin2.value = R_SkinAvailable(cv_skin2.string);
+	if (cv_skin2.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[1]].skin;
+		CV_StealthSet(&cv_skin2, skins[skinnum].name);
+		cv_skin2.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername2.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor2.value);
+	WRITEUINT8(p, (UINT8)cv_skin2.value);
+	SendNetXCmdForPlayer(1, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+static void SendNameAndColor3(void)
+{
+	INT32 thirdplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 2)
+		return; // can happen if skin3/color3/name3 changed
+
+	if (displayplayers[2] != consoleplayer)
+		thirdplaya = displayplayers[2];
+	else if (!netgame) // HACK
+		thirdplaya = 2;
+
+	if (thirdplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[thirdplaya].ctfteam == 1 && cv_playercolor3.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor3, skincolor_redteam);
+		else if (players[thirdplaya].ctfteam == 2 && cv_playercolor3.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor3, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor3.value)
+	{
+		if (players[thirdplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor3, players[thirdplaya].skincolor);
+		else if (skins[players[thirdplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor3, skins[players[thirdplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor3, cv_playercolor3.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(thirdplaya, cv_playername3.zstring);
+		strcpy(player_names[thirdplaya], cv_playername3.zstring);
+
+		// don't use displayplayers[2]: the third player must be 2
+		players[thirdplaya].skincolor = cv_playercolor3.value;
+		if (players[thirdplaya].mo)
+			players[thirdplaya].mo->color = players[thirdplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin3.string)) != -1)
+		{
+			cv_skin3.value = foundskin;
+			SetPlayerSkin(thirdplaya, cv_skin3.string);
+		}
+		else
+		{
+			cv_skin3.value = players[thirdplaya].skin;
+			CV_StealthSet(&cv_skin3, skins[players[thirdplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(thirdplaya, cv_skin3.string);
+		}
+		return;
+	}
+
+	snac3pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[2]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[2])))
+		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[2], cv_playername3.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[2]))
+		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
+
+	// check if player has the skin loaded (cv_skin3 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin3.value = R_SkinAvailable(cv_skin3.string);
+	if (cv_skin3.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[2]].skin;
+		CV_StealthSet(&cv_skin3, skins[skinnum].name);
+		cv_skin3.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername3.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor3.value);
+	WRITEUINT8(p, (UINT8)cv_skin3.value);
+	SendNetXCmdForPlayer(2, XD_NAMEANDCOLOR, buf, p - buf);
+}
+
+static void SendNameAndColor4(void)
+{
+	INT32 fourthplaya = -1;
+	char buf[MAXPLAYERNAME+2];
+	char *p;
+
+	if (splitscreen < 3)
+		return; // can happen if skin4/color4/name4 changed
+
+	if (displayplayers[3] != consoleplayer)
+		fourthplaya = displayplayers[3];
+	else if (!netgame) // HACK
+		fourthplaya = 3;
+
+	if (fourthplaya == -1)
+		return;
+
+	p = buf;
+
+	// normal player colors
+	if (G_GametypeHasTeams())
+	{
+		if (players[fourthplaya].ctfteam == 1 && cv_playercolor4.value != skincolor_redteam)
+			CV_StealthSetValue(&cv_playercolor4, skincolor_redteam);
+		else if (players[fourthplaya].ctfteam == 2 && cv_playercolor4.value != skincolor_blueteam)
+			CV_StealthSetValue(&cv_playercolor4, skincolor_blueteam);
+	}
+
+	// never allow the color "none"
+	if (!cv_playercolor4.value)
+	{
+		if (players[fourthplaya].skincolor)
+			CV_StealthSetValue(&cv_playercolor4, players[fourthplaya].skincolor);
+		else if (skins[players[fourthplaya].skin].prefcolor)
+			CV_StealthSetValue(&cv_playercolor4, skins[players[fourthplaya].skin].prefcolor);
+		else
+			CV_StealthSet(&cv_playercolor4, cv_playercolor4.defaultvalue);
+	}
+
+	// We'll handle it later if we're not playing.
+	if (!Playing())
+		return;
+
+	// If you're not in a netgame, merely update the skin, color, and name.
+	if (botingame)
+	{
+		players[fourthplaya].skincolor = botcolor;
+		if (players[fourthplaya].mo)
+			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
+		SetPlayerSkinByNum(fourthplaya, botskin-1);
+		return;
+	}
+	else if (!netgame)
+	{
+		INT32 foundskin;
+
+		CleanupPlayerName(fourthplaya, cv_playername4.zstring);
+		strcpy(player_names[fourthplaya], cv_playername4.zstring);
+
+		// don't use displayplayers[3]: the second player must be 4
+		players[fourthplaya].skincolor = cv_playercolor4.value;
+		if (players[fourthplaya].mo)
+			players[fourthplaya].mo->color = players[fourthplaya].skincolor;
+
+		if ((foundskin = R_SkinAvailable(cv_skin4.string)) != -1)
+		{
+			cv_skin4.value = foundskin;
+			SetPlayerSkin(fourthplaya, cv_skin4.string);
+		}
+		else
+		{
+			cv_skin4.value = players[fourthplaya].skin;
+			CV_StealthSet(&cv_skin4, skins[players[fourthplaya].skin].name);
+			// will always be same as current
+			SetPlayerSkin(fourthplaya, cv_skin4.string);
+		}
+		return;
+	}
+
+	snac4pending++;
+
+	// Don't change name if muted
+	if (player_name_changes[displayplayers[3]] >= MAXNAMECHANGES)
+	{
+		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
+		HU_AddChatText("\x85*You must wait to change your name again", false);
+	}
+	else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[3])))
+		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
+	else // Cleanup name if changing it
+		CleanupPlayerName(displayplayers[3], cv_playername4.zstring);
+
+	// Don't change skin if the server doesn't want you to.
+	if (!CanChangeSkin(displayplayers[3]))
+		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
+
+	// check if player has the skin loaded (cv_skin4 may have
+	// the name of a skin that was available in the previous game)
+	cv_skin4.value = R_SkinAvailable(cv_skin4.string);
+	if (cv_skin4.value < 0)
+	{
+		INT32 skinnum = players[displayplayers[3]].skin;
+		CV_StealthSet(&cv_skin4, skins[skinnum].name);
+		cv_skin4.value = skinnum;
+	}
+
+	// Finally write out the complete packet and send it off.
+	WRITESTRINGN(p, cv_playername4.zstring, MAXPLAYERNAME);
+	WRITEUINT8(p, (UINT8)cv_playercolor4.value);
+	WRITEUINT8(p, (UINT8)cv_skin4.value);
+	SendNetXCmdForPlayer(3, XD_NAMEANDCOLOR, buf, p - buf);
 }
 
 static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 {
-	player_t *player = &players[playernum];
+	player_t *p = &players[playernum];
 	char name[MAXPLAYERNAME+1];
 	UINT8 color, skin;
 
@@ -1639,14 +1939,19 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		I_Error("There is no player %d!", playernum);
 #endif
 
-	if (P_IsLocalPlayer(player))
-	{
-		snacpending[playernum]--;
+	if (playernum == consoleplayer)
+		snacpending--; // TODO: make snacpending an array instead of 4 separate vars?
+	else if (playernum == displayplayers[1])
+		snac2pending--;
+	else if (playernum == displayplayers[2])
+		snac3pending--;
+	else if (playernum == displayplayers[3])
+		snac4pending--;
+
 #ifdef PARANOIA
-		if (snacpending[playernum] < 0)
-			I_Error("snacpending negative!");
+	if (snacpending < 0 || snac2pending < 0 || snac3pending < 0 || snac4pending < 0)
+		I_Error("snacpending negative!");
 #endif
-	}
 
 	READSTRINGN(*cp, name, MAXPLAYERNAME);
 	color = READUINT8(*cp);
@@ -1660,32 +1965,33 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 	}
 
 	// set color
-	player->skincolor = color % MAXSKINCOLORS;
-	if (player->mo)
-		player->mo->color = (UINT8)player->skincolor;
+	p->skincolor = color % MAXSKINCOLORS;
+	if (p->mo)
+		p->mo->color = (UINT8)p->skincolor;
 	demo_extradata[playernum] |= DXD_COLOR;
 
 	// normal player colors
-	if (server && !P_IsLocalPlayer(player))
+	if (server && (p != &players[consoleplayer] && p != &players[displayplayers[1]]
+		&& p != &players[displayplayers[2]] && p != &players[displayplayers[3]]))
 	{
 		boolean kick = false;
 
 		// team colors
 		if (G_GametypeHasTeams())
 		{
-			if (player->ctfteam == 1 && player->skincolor != skincolor_redteam)
+			if (p->ctfteam == 1 && p->skincolor != skincolor_redteam)
 				kick = true;
-			else if (player->ctfteam == 2 && player->skincolor != skincolor_blueteam)
+			else if (p->ctfteam == 2 && p->skincolor != skincolor_blueteam)
 				kick = true;
 		}
 
 		// don't allow color "none"
-		if (!player->skincolor)
+		if (!p->skincolor)
 			kick = true;
 
 		if (kick)
 		{
-			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], player->ctfteam, player->skincolor);
+			CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], p->ctfteam, p->skincolor);
 			SendKick(playernum, KICK_MSG_CON_FAIL);
 			return;
 		}
@@ -1697,7 +2003,6 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		const INT32 forcedskin = cv_forceskin.value;
 		SetPlayerSkinByNum(playernum, forcedskin);
 
-		// TODO: make cv_skin an array
 		if (playernum == consoleplayer)
 			CV_StealthSet(&cv_skin, skins[forcedskin].name);
 		else if (playernum == displayplayers[1])
@@ -1711,16 +2016,44 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 		SetPlayerSkinByNum(playernum, skin);
 }
 
-void SendWeaponPref(UINT8 splitplayer)
+void SendWeaponPref(void)
 {
 	UINT8 buf[1];
 
 	buf[0] = 0;
-
-	if (cv_flipcam[splitplayer].value)
+	if (cv_flipcam[0].value)
 		buf[0] |= 1;
+	SendNetXCmdForPlayer(0, XD_WEAPONPREF, buf, 1);
+}
 
-	SendNetXCmdForPlayer(splitplayer, XD_WEAPONPREF, buf, 1);
+void SendWeaponPref2(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[1].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(1, XD_WEAPONPREF, buf, 1);
+}
+
+void SendWeaponPref3(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[2].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(2, XD_WEAPONPREF, buf, 1);
+}
+
+void SendWeaponPref4(void)
+{
+	UINT8 buf[1];
+
+	buf[0] = 0;
+	if (cv_flipcam[3].value)
+		buf[0] |= 1;
+	SendNetXCmdForPlayer(3, XD_WEAPONPREF, buf, 1);
 }
 
 static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
@@ -1736,10 +2069,23 @@ static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
 		player->pflags |= PF_ANALOGMODE;
 }
 
-void D_SendPlayerConfig(UINT8 splitplayer)
+void D_SendPlayerConfig(void)
 {
-	SendNameAndColor(splitplayer);
-	SendWeaponPref(splitplayer);
+	SendNameAndColor();
+	if (splitscreen || botingame)
+		SendNameAndColor2();
+	if (splitscreen > 1)
+		SendNameAndColor3();
+	if (splitscreen > 2)
+		SendNameAndColor4();
+
+	SendWeaponPref();
+	if (splitscreen)
+		SendWeaponPref2();
+	if (splitscreen > 1)
+		SendWeaponPref3();
+	if (splitscreen > 2)
+		SendWeaponPref4();
 }
 
 // Only works for displayplayer, sorry!
@@ -1762,12 +2108,10 @@ INT32 D_LookupPlayer(const char *s)
 		return playernum;
 	}
 
-	const size_t len = strlen(s);
-
 	for (playernum = 0; playernum < MAXPLAYERS; ++playernum)
 	{
 		/* Match name case-insensitively: fully, or partially the start. */
-		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, len) == 0))
+		if (playeringame[playernum] && (strnicmp(player_names[playernum], s, strlen(s)) == 0))
 		{
 			return playernum;
 		}
@@ -1807,15 +2151,13 @@ static void GetViewablePlayerPlaceRange(INT32 *first, INT32 *last)
 	(*last) = 0;
 
 	for (i = 0; i < MAXPLAYERS; ++i)
-	{
 		if (G_CouldView(i))
-		{
-			place = players[i].kartstuff[k_position];
-			if (place < (*first))
-				(*first) = place;
-			if (place > (*last))
-				(*last) = place;
-		}
+	{
+		place = players[i].kartstuff[k_position];
+		if (place < (*first))
+			(*first) = place;
+		if (place > (*last))
+			(*last) = place;
 	}
 }
 
@@ -2149,7 +2491,7 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pencoremode, boolean r
 				displayplayers[1] = 1;
 				playeringame[1] = true;
 				players[1].bot = 1;
-				SendNameAndColor(1);
+				SendNameAndColor2();
 			}
 		}
 
@@ -5426,54 +5768,50 @@ static void ForceSkin_OnChange(void)
 	}
 }
 
-// Allows the player's name to be changed if cv_mute is off.
+//Allows the player's name to be changed if cv_mute is off.
 static void Name_OnChange(void)
 {
 	if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername, player_names[consoleplayer]);
-		return;
 	}
-
-	SendNameAndColor(0);
+	else
+		SendNameAndColor();
 
 }
 
 static void Name2_OnChange(void)
 {
-	if (cv_mute.value) // Secondary player can't be admin.
+	if (cv_mute.value) //Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
-		return;
 	}
-
-	SendNameAndColor(1);
+	else
+		SendNameAndColor2();
 }
 
 static void Name3_OnChange(void)
 {
-	if (cv_mute.value) // Third player can't be admin.
+	if (cv_mute.value) //Third player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
-		return;
 	}
-
-	SendNameAndColor(2);
+	else
+		SendNameAndColor3();
 }
 
 static void Name4_OnChange(void)
 {
-	if (cv_mute.value) // Secondary player can't be admin.
+	if (cv_mute.value) //Secondary player can't be admin.
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
 		CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
-		return;
 	}
-
-	SendNameAndColor(3);
+	else
+		SendNameAndColor4();
 }
 
 /** Sends a skin change for the console player, unless that player is moving.
@@ -5495,7 +5833,7 @@ static void Skin_OnChange(void)
 	}
 
 	if (CanChangeSkin(consoleplayer) && !P_PlayerMoving(consoleplayer))
-		SendNameAndColor(0);
+		SendNameAndColor();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5516,7 +5854,7 @@ static void Skin2_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[1]) && !P_PlayerMoving(displayplayers[1]))
-		SendNameAndColor(1);
+		SendNameAndColor2();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5532,7 +5870,7 @@ static void Skin3_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[2]) && !P_PlayerMoving(displayplayers[2]))
-		SendNameAndColor(2);
+		SendNameAndColor3();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5548,7 +5886,7 @@ static void Skin4_OnChange(void)
 		return; // do whatever you want
 
 	if (CanChangeSkin(displayplayers[3]) && !P_PlayerMoving(displayplayers[3]))
-		SendNameAndColor(3);
+		SendNameAndColor4();
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5661,7 +5999,7 @@ static void Color_OnChange(void)
 	if (!P_PlayerMoving(consoleplayer))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(0);
+		SendNameAndColor();
 	}
 	else
 	{
@@ -5683,7 +6021,7 @@ static void Color2_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[1]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(1);
+		SendNameAndColor2();
 	}
 	else
 	{
@@ -5700,7 +6038,7 @@ static void Color3_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[2]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(2);
+		SendNameAndColor3();
 	}
 	else
 	{
@@ -5717,7 +6055,7 @@ static void Color4_OnChange(void)
 	if (!P_PlayerMoving(displayplayers[3]))
 	{
 		// Color change menu scrolling fix is no longer necessary
-		SendNameAndColor(3);
+		SendNameAndColor4();
 	}
 	else
 	{

src/d_netcmd.h

@@ -21,7 +21,10 @@ extern "C" {
 
 #include "command.h"
 
-void SendWeaponPref(UINT8 splitplayer);
+void SendWeaponPref(void);
+void SendWeaponPref2(void);
+void SendWeaponPref3(void);
+void SendWeaponPref4(void);
 
 // console vars
 extern consvar_t cv_playername;
@@ -292,7 +295,7 @@ typedef union {
 // add game commands, needs cleanup
 void D_RegisterServerCommands(void);
 void D_RegisterClientCommands(void);
-void D_SendPlayerConfig(UINT8 splitplayer);
+void D_SendPlayerConfig(void);
 void Command_ExitGame_f(void);
 void Command_Retry_f(void);
 void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore

src/d_netfil.c

@@ -112,7 +112,7 @@ static fileused_t transferFiles[UINT8_MAX + 1];
 INT32 fileneedednum = 0; // Number of files needed to join the server
 fileneeded_t fileneeded[MAX_WADFILES] = {}; // List of needed files
 #ifdef HAVE_THREADS
-static I_mutex downloadmutex;
+static I_Mutex downloadmutex;
 #endif
 char downloaddir[512] = "DOWNLOAD";
 
@@ -960,7 +960,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download base-game file: \"%s\"", filename);
+		I_Error("Tried to download \"%s\"", filename);
 
 	if (filenum >= fileneedednum)
 	{
@@ -1019,21 +1019,21 @@ void Got_Filetxpak(void)
 
 		switch(file->status)
 		{
-			case FS_NOTFOUND:
-				s = "FS_NOTFOUND";
-				break;
-			case FS_FOUND:
-				s = "FS_FOUND";
-				break;
-			case FS_OPEN:
-				s = "FS_OPEN";
-				break;
-			case FS_MD5SUMBAD:
-				s = "FS_MD5SUMBAD";
-				break;
-			default:
-				s = "unknown";
-				break;
+		case FS_NOTFOUND:
+			s = "FS_NOTFOUND";
+			break;
+		case FS_FOUND:
+			s = "FS_FOUND";
+			break;
+		case FS_OPEN:
+			s = "FS_OPEN";
+			break;
+		case FS_MD5SUMBAD:
+			s = "FS_MD5SUMBAD";
+			break;
+		default:
+			s = "unknown";
+			break;
 		}
 
 		I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);
@@ -1427,7 +1427,7 @@ void CURLPrepareFile(const char* url, int dfilenum)
 		filedownload.http_running = true;
 
 #ifdef HAVE_THREADS
-		I_spawn_thread("http-download", (I_thread_fn)CURLGetFile, NULL);
+		(void)!I_SpawnThread("http-download", (I_ThreadFn)CURLGetFile, NULL);
 #endif
 	}
 	else
@@ -1440,15 +1440,15 @@ void CURLAbortFile(void)
 
 #ifdef HAVE_THREADS
 	// lock and unlock to wait for the download thread to exit
-	I_lock_mutex(&downloadmutex);
-	I_unlock_mutex(downloadmutex);
+	I_LockMutex(&downloadmutex);
+	I_UnlockMutex(downloadmutex);
 #endif
 }
 
 static void CURLGetFile(void)
 {
 #ifdef HAVE_THREADS
-	I_lock_mutex(&downloadmutex);
+	I_LockMutex(&downloadmutex);
 #endif
 	CURLMcode mc; /* return code used by curl_multi_wait() */
 	CURLcode easyres; /* Return from easy interface */
@@ -1549,7 +1549,7 @@ static void CURLGetFile(void)
 
 	filedownload.http_running = false;
 #ifdef HAVE_THREADS
-	I_unlock_mutex(downloadmutex);
+	I_UnlockMutex(downloadmutex);
 #endif
 }
 

src/dedicated/Sourcefile

@@ -2,6 +2,5 @@ i_system.c
 i_main.c
 i_video.c
 i_sound.c
-i_threads.c
 dosstr.c
 endtxt.c

src/dedicated/i_system.c

@@ -984,7 +984,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }
 
-static volatile sig_atomic_t g_in_exiting_signal_handler = false;
+boolean g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1048,11 +1048,6 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }
 
-boolean I_In_Exiting_Signal_Handler(void)
-{
-	return g_in_exiting_signal_handler;
-}
-
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1072,17 +1067,11 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-static volatile sig_atomic_t interrupted = 0;
-
-boolean I_Interrupted(void)
+FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
 {
-	return interrupted;
-}
-
-static void quit_handler(int num)
-{
-	(void)num;
-	interrupted = 1;
+	signal(num, SIG_DFL); //default signal action
+	raise(num);
+	I_Quit();
 }
 
 #ifdef HAVE_LIBBACKTRACE
@@ -1384,7 +1373,6 @@ static void I_Fork(void)
 
 INT32 I_StartupSystem(void)
 {
-	W_Startup();
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to
@@ -1393,8 +1381,8 @@ INT32 I_StartupSystem(void)
 		I_Fork();
 #endif
 #ifdef HAVE_THREADS
-	I_start_threads();
-	I_AddExitFunc(I_stop_threads);
+	I_StartThreads();
+	I_AddExitFunc(I_StopThreads);
 #endif
 	I_RegisterSignals();
 #ifndef NOMUMBLE

src/dehacked.c

@@ -115,25 +115,20 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 	size_t i = 0;
 	if (myfeof(f))
 		return NULL;
-
 	// we need one byte for a null terminated string
 	bufsize--;
-
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
-
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
-
 		if (c == '\n')
 			break;
 	}
-
 	buf[i] = '\0';
 
 	dbg_line++;
@@ -143,31 +138,25 @@ char *myfgets(char *buf, size_t bufsize, MYFILE *f)
 static char *myhashfgets(char *buf, size_t bufsize, MYFILE *f)
 {
 	size_t i = 0;
-
 	if (myfeof(f))
 		return NULL;
-
 	// we need one byte for a null terminated string
 	bufsize--;
-
 	while (i < bufsize && !myfeof(f))
 	{
 		char c = *f->curpos++;
-
 		if (c == '^')
 			buf[i++] = myfget_color(f);
 		else if (c == '\\')
 			buf[i++] = myfget_hex(f);
 		else if (c != '\r')
 			buf[i++] = c;
-
 		if (c == '\n') // Ensure debug line is right...
 			dbg_line++;
-
 		if (c == '#')
 			break;
 	}
-
+	i++;
 	buf[i] = '\0';
 
 	return buf;
@@ -184,7 +173,7 @@ FUNCPRINTF static void deh_warning(const char *first, ...)
 	vsnprintf(buf, 1000, first, argptr); // sizeof only returned 4 here. it didn't like that pointer.
 	va_end(argptr);
 
-	if (dbg_line == -1) // Not in a SOC, line number unknown.
+	if(dbg_line == -1) // Not in a SOC, line number unknown.
 		CONS_Alert(CONS_WARNING, "%s\n", buf);
 	else
 		CONS_Alert(CONS_WARNING, "Line %u: %s\n", dbg_line, buf);
@@ -272,6 +261,7 @@ static void clear_levels(void)
 		// (no need to set num to 0, we're freeing the entire header shortly)
 		Z_Free(mapheaderinfo[i]->customopts);
 
+		P_DeleteGrades(i);
 		Z_Free(mapheaderinfo[i]);
 		mapheaderinfo[i] = NULL;
 	}
@@ -325,10 +315,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 					goto done;
 				PlayerMenu[num].status = IT_CALL;
 
-				// A friendly neighborhood alias for brevity's sake
-				const size_t note_size = sizeof(description[num].notes);
-
-				for (i = 0; i < (INT32)(MAXLINELEN-note_size-3); i++)
+				for (i = 0; i < MAXLINELEN-3; i++)
 				{
 					if (s[i] == '=')
 					{
@@ -336,12 +323,10 @@ static void readPlayer(MYFILE *f, INT32 num)
 						break;
 					}
 				}
-
 				if (playertext)
 				{
-					strlcpy(description[num].notes, playertext, note_size);
-					strlcat(description[num].notes,
-							myhashfgets(playertext, note_size, f), note_size);
+					strcpy(description[num].notes, playertext);
+					strcat(description[num].notes, myhashfgets(playertext, sizeof (description[num].notes), f));
 				}
 				else
 					strcpy(description[num].notes, "");
@@ -350,7 +335,7 @@ static void readPlayer(MYFILE *f, INT32 num)
 				// It works down here, though.
 				{
 					INT32 numline = 0;
-					for (i = 0; (size_t)i < note_size-1; i++)
+					for (i = 0; (size_t)i < sizeof(description[num].notes)-1; i++)
 					{
 						if (numline < 20 && description[num].notes[i] == '\n')
 							numline++;
@@ -359,7 +344,6 @@ static void readPlayer(MYFILE *f, INT32 num)
 							break;
 					}
 				}
-
 				description[num].notes[strlen(description[num].notes)-1] = '\0';
 				description[num].notes[i] = '\0';
 				continue;
@@ -835,8 +819,22 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			// Now go to uppercase
 			strupr(word2);
 
+			// NiGHTS grades
+			if (fastncmp(word, "GRADES", 6))
+			{
+				UINT8 mare = (UINT8)atoi(word + 6);
+
+				if (mare <= 0 || mare > 8)
+				{
+					deh_warning("Level header %d: unknown word '%s'", num, word);
+					continue;
+				}
+
+				P_AddGradesForMare((INT16)(num-1), mare-1, word2);
+			}
+
 			// Strings that can be truncated
-			if (fastcmp(word, "SCRIPTNAME"))
+			else if (fastcmp(word, "SCRIPTNAME"))
 			{
 				deh_strlcpy(mapheaderinfo[num-1]->scriptname, word2,
 					sizeof(mapheaderinfo[num-1]->scriptname), va("Level header %d: scriptname", num));
@@ -848,6 +846,10 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			}
 			else if (fastcmp(word, "ACT"))
 			{
+				/*if (i >= 0 && i < 20) // 0 for no act number, TTL1 through TTL19
+					mapheaderinfo[num-1]->actnum = (UINT8)i;
+				else
+					deh_warning("Level header %d: invalid act number %d", num, i);*/
 				deh_strlcpy(mapheaderinfo[num-1]->actnum, word2,
 					sizeof(mapheaderinfo[num-1]->actnum), va("Level header %d: actnum", num));
 			}
@@ -912,7 +914,11 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 				mapheaderinfo[num-1]->mustrack = ((UINT16)i - 1);
 			else if (fastcmp(word, "MUSICPOS"))
 				mapheaderinfo[num-1]->muspos = (UINT32)get_number(word2);
-
+			else if (fastcmp(word, "MUSICINTERFADEOUT"))
+				mapheaderinfo[num-1]->musinterfadeout = (UINT32)get_number(word2);
+			else if (fastcmp(word, "MUSICINTER"))
+				deh_strlcpy(mapheaderinfo[num-1]->musintername, word2,
+					sizeof(mapheaderinfo[num-1]->musintername), va("Level header %d: intermission music", num));
 			else if (fastcmp(word, "FORCECHARACTER"))
 			{
 				strlcpy(mapheaderinfo[num-1]->forcecharacter, word2, SKINNAMESIZE+1);
@@ -954,12 +960,44 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 			else if (fastcmp(word, "SKYBOXSCALEZ"))
 				mapheaderinfo[num-1]->skybox_scalez = (INT16)i;
 
+			else if (fastcmp(word, "BONUSTYPE"))
+			{
+				if      (fastcmp(word2, "NONE"))   i = -1;
+				else if (fastcmp(word2, "NORMAL")) i =  0;
+				else if (fastcmp(word2, "BOSS"))   i =  1;
+				else if (fastcmp(word2, "ERZ3"))   i =  2;
+
+				if (i >= -1 && i <= 2) // -1 for no bonus. Max is 2.
+					mapheaderinfo[num-1]->bonustype = (SINT8)i;
+				else
+					deh_warning("Level header %d: invalid bonus type number %d", num, i);
+			}
+
+			else if (fastcmp(word, "SAVEOVERRIDE"))
+			{
+				if      (fastcmp(word2, "DEFAULT")) i = SAVE_DEFAULT;
+				else if (fastcmp(word2, "ALWAYS"))  i = SAVE_ALWAYS;
+				else if (fastcmp(word2, "NEVER"))   i = SAVE_NEVER;
+
+				if (i >= SAVE_NEVER && i <= SAVE_ALWAYS)
+					mapheaderinfo[num-1]->saveoverride = (SINT8)i;
+				else
+					deh_warning("Level header %d: invalid save override number %d", num, i);
+			}
+
 			else if (fastcmp(word, "LEVELFLAGS"))
 				mapheaderinfo[num-1]->levelflags = get_number(word2);
 			else if (fastcmp(word, "MENUFLAGS"))
 				mapheaderinfo[num-1]->menuflags = get_number(word2);
 
 			// SRB2Kart
+			/*else if (fastcmp(word, "AUTOMAP"))
+			{
+				if (i || word2[0] == 'T' || word2[0] == 'Y')
+					mapheaderinfo[num-1]->automap = true;
+				else
+					mapheaderinfo[num-1]->automap = false;
+			}*/
 			else if (fastcmp(word, "MOBJSCALE"))
 				mapheaderinfo[num-1]->mobj_scale = get_number(word2);
 			else if (fastcmp(word, "LIGHTCONTRAST") || fastcmp(word, "ENCORELIGHTCONTRAST"))
@@ -1072,26 +1110,6 @@ static void readlevelheader(MYFILE *f, INT32 num, INT32 wadnum)
 				else
 					mapheaderinfo[num-1]->menuflags &= ~LF2_NOVISITNEEDED;
 			}
-			else if (fastcmp(word, "MUSICINTERFADEOUT"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "MUSICINTER"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "BONUSTYPE"))
-			{
-				continue; // unused
-			}
-			else if (fastcmp(word, "SAVEOVERRIDE"))
-			{
-				continue; // unused
-			}
-			else if (fastncmp(word, "GRADES", 6)) // NiGHTS grades
-			{
-				continue; // unused
-			}
 			else
 				deh_warning("Level header %d: unknown word '%s'", num, word);
 		}
@@ -1182,6 +1200,7 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
 			i = atoi(word2);
 			usi = (UINT16)i;
 
+
 			if (fastcmp(word, "NUMBEROFPICS"))
 			{
 				cutscenes[num]->scene[scenenum].numpics = (UINT8)i;
@@ -1862,8 +1881,16 @@ static void reademblemdata(MYFILE *f, INT32 num)
 					emblemlocations[num-1].type = ET_GLOBAL;
 				else if (fastcmp(word2, "SKIN"))
 					emblemlocations[num-1].type = ET_SKIN;
+				/*else if (fastcmp(word2, "SCORE"))
+					emblemlocations[num-1].type = ET_SCORE;*/
 				else if (fastcmp(word2, "TIME"))
 					emblemlocations[num-1].type = ET_TIME;
+				/*else if (fastcmp(word2, "RINGS"))
+					emblemlocations[num-1].type = ET_RINGS;
+				else if (fastcmp(word2, "NGRADE"))
+					emblemlocations[num-1].type = ET_NGRADE;
+				else if (fastcmp(word2, "NTIME"))
+					emblemlocations[num-1].type = ET_NTIME;*/
 				else
 					emblemlocations[num-1].type = (UINT8)value;
 			}
@@ -2152,11 +2179,14 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 	}
 	else if ((offset=0) || fastcmp(params[0], "GAMECLEAR")
 	||        (++offset && fastcmp(params[0], "ALLEMERALDS")))
+	//||        (++offset && fastcmp(params[0], "ULTIMATECLEAR")))
 	{
 		ty = UC_GAMECLEAR + offset;
 		re = (params[1]) ? atoi(params[1]) : 1;
 	}
 	else if ((offset=0) || fastcmp(params[0], "OVERALLTIME"))
+	//||        (++offset && fastcmp(params[0], "OVERALLSCORE"))
+	//||        (++offset && fastcmp(params[0], "OVERALLRINGS")))
 	{
 		PARAMCHECK(1);
 		ty = UC_OVERALLTIME + offset;
@@ -2165,6 +2195,8 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 	else if ((offset=0) || fastcmp(params[0], "MAPVISITED")
 	||        (++offset && fastcmp(params[0], "MAPBEATEN"))
 	||        (++offset && fastcmp(params[0], "MAPALLEMERALDS")))
+	//||        (++offset && fastcmp(params[0], "MAPULTIMATE"))
+	//||        (++offset && fastcmp(params[0], "MAPPERFECT")))
 	{
 		PARAMCHECK(1);
 		ty = UC_MAPVISITED + offset;
@@ -2182,6 +2214,8 @@ static void readcondition(UINT8 set, UINT32 id, char *word2)
 		}
 	}
 	else if ((offset=0) || fastcmp(params[0], "MAPTIME"))
+	//||        (++offset && fastcmp(params[0], "MAPSCORE"))
+	//||        (++offset && fastcmp(params[0], "MAPRINGS")))
 	{
 		PARAMCHECK(2);
 		ty = UC_MAPTIME + offset;
@@ -2564,7 +2598,7 @@ static void readmaincfg(MYFILE *f)
 			}
 			else if (fastcmp(word, "MAXXTRALIFE"))
 			{
-				continue; // unused
+				maxXtraLife = (UINT8)get_number(word2);
 			}
 			else if (fastcmp(word, "GAMEDATA"))
 			{
@@ -2594,7 +2628,6 @@ static void readmaincfg(MYFILE *f)
 				strcatbf(savegamename, srb2home, PATHSEP);
 
 				refreshdirmenu |= REFRESHDIR_GAMEDATA;*/
-				continue;
 			}
 			else if (fastcmp(word, "RESETDATA"))
 			{
@@ -8512,7 +8545,7 @@ static inline int lib_action(lua_State *L)
 
 // Hardcoded A_Action name to call for super() or NULL if super() would be invalid.
 // Set in lua_infolib.
-const char *superactions[MAXRECURSION] = {};
+const char *superactions[MAXRECURSION];
 UINT8 superstack = 0;
 
 static int lib_dummysuper(lua_State *L)

src/dehacked.h

@@ -13,10 +13,6 @@
 #ifndef __DEHACKED_H__
 #define __DEHACKED_H__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "m_fixed.h" // for get_number
 #include "info.h"
 
@@ -75,9 +71,4 @@ typedef struct
 } MYFILE;
 #define myfeof(a) (a->data + a->size <= a->curpos)
 char *myfgets(char *buf, size_t bufsize, MYFILE *f);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

src/doomdef.h

@@ -516,6 +516,22 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);
 
+/* http://www.cse.yorku.ca/~oz/hash.html */
+static inline
+UINT32 quickncasehash (const char *p, size_t n)
+{
+	size_t i = 0;
+	UINT32 x = 5381;
+
+	while (i < n && p[i])
+	{
+		x = (x * 33) ^ tolower(p[i]);
+		i++;
+	}
+
+	return x;
+}
+
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))

src/doomstat.h

@@ -205,6 +205,12 @@ extern struct quake
 	fixed_t radius, intensity;
 } quake;
 
+// NiGHTS grades
+typedef struct
+{
+	UINT32 grade[6]; // D, C, B, A, S, X (F: failed to reach any of these)
+} nightsgrades_t;
+
 // Custom Lua values
 // (This is not ifdeffed so the map header structure can stay identical, just in case.)
 typedef struct
@@ -255,16 +261,28 @@ typedef struct
 	UINT8 numlaps;        ///< Number of laps in circuit mode, unless overridden.
 	SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no.
 	UINT8 levelselect;    ///< Is this map available in the level select? If so, which map list is it available in?
+	SINT8 bonustype;      ///< What type of bonus does this level have? (-1 for null.)
+	SINT8 saveoverride;   ///< Set how the game is allowed to save (1 for always, -1 for never, 0 is 2.1 default)
+
 	UINT8 levelflags;     ///< LF_flags:  merged eight booleans into one UINT8 for space, see below
 	UINT8 menuflags;      ///< LF2_flags: options that affect record attack / nights mode menus
 
+	// NiGHTS stuff.
+	UINT8 numGradedMares;   ///< Internal. For grade support.
+	nightsgrades_t *grades; ///< NiGHTS grades. Allocated dynamically for space reasons. Be careful.
+
 	// SRB2kart
+	//boolean automap;    ///< Displays a level's white map outline in modified games
 	fixed_t mobj_scale;   ///< Replacement for TOL_ERZ3
 
 	mapheader_lighting_t lighting;			///< Wall and sprite lighting
 	mapheader_lighting_t lighting_encore;	///< Alternative lighting for Encore mode
 	boolean use_encore_lighting;			///< Whether to use separate Encore lighting
 
+	// Music stuff.
+	UINT32 musinterfadeout;  ///< Fade out level music on intermission screen in milliseconds
+	char musintername[7];    ///< Intermission screen music.
+
 	// Lua stuff.
 	// (This is not ifdeffed so the map header structure can stay identical, just in case.)
 	UINT8 numCustomOptions;     ///< Internal. For Lua custom value support.
@@ -361,6 +379,8 @@ typedef struct
 {
 	tic_t time; ///< Time in which the level was finished.
 	tic_t lap;  ///< Best lap time for this level.
+	//UINT32 score; ///< Score when the level was finished.
+	//UINT16 rings; ///< Rings when the level was finished.
 } recorddata_t;
 
 /** Setup for one NiGHTS map.
@@ -374,19 +394,34 @@ typedef struct
 #define GRADE_A 5
 #define GRADE_S 6
 
+/*typedef struct
+{
+	// 8 mares, 1 overall (0)
+	UINT8	nummares;
+	UINT32	score[9];
+	UINT8	grade[9];
+	tic_t	time[9];
+} nightsdata_t;*/
+
+//extern nightsdata_t *nightsrecords[NUMMAPS];
 extern recorddata_t *mainrecords[NUMMAPS];
 
 // mapvisited is now a set of flags that says what we've done in the map.
 #define MV_VISITED     1
 #define MV_BEATEN      2
 #define MV_ALLEMERALDS 4
+//#define MV_ULTIMATE     8
+//#define MV_PERFECT     16
 #define MV_MAX         7 // used in gamedata check
 extern UINT8 mapvisited[NUMMAPS];
 
-extern UINT32 token;     ///< Number of tokens collected in a level
+// Temporary holding place for nights data for the current map
+//nightsdata_t ntemprecords;
+
+extern UINT32 token; ///< Number of tokens collected in a level
 extern UINT32 tokenlist; ///< List of tokens collected
-extern INT32  tokenbits; ///< Used for setting token bits
-extern INT32  sstimer;   ///< Time allotted in the special stage
+extern INT32 tokenbits; ///< Used for setting token bits
+extern INT32 sstimer; ///< Time allotted in the special stage
 extern UINT32 bluescore; ///< Blue Team Scores
 extern UINT32 redscore;  ///< Red Team Scores
 
@@ -426,6 +461,7 @@ extern UINT8 introtoplay;
 extern UINT8 creditscutscene;
 
 extern UINT8 use1upSound;
+extern UINT8 maxXtraLife; // Max extra lives from rings
 
 extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations
 

src/doomtype.h

@@ -68,21 +68,8 @@ extern "C" {
 	#define strnicmp(x,y,n) strncasecmp(x,y,n)
 #endif
 
-// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
-// to not cause warnings or compile issues on older glibc versions we do this silly thing
-// to not have a gazillion glibc version checks
-#if defined(__GLIBC_PREREQ)
-#if __GLIBC_PREREQ(2, 43)
-	#define gconst const
-#else
-	#define gconst
-#endif
-#else
-	#define gconst
-#endif
-
-#ifndef _GNU_SOURCE
 char *nongnu_strcasestr(const char *in, const char *what);
+#ifndef _GNU_SOURCE
 #define strcasestr nongnu_strcasestr
 #endif
 
@@ -140,9 +127,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)
 
 /* Boolean type definition */
-#include <stdbool.h>
 
 #ifndef _WIN32
+#include <stdbool.h>
 // dont use stdbools _BOOL type
 // its smaller (1 byte) than the old interger bool (4 bytes)
 // which results in packed struct sizes being mismatched between vanilla and this
@@ -150,7 +137,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 // which we cant use as enumeration constants
 typedef int32_t boolean;
 #else
-#define boolean int32_t
+#define false FALSE
+#define true TRUE
+#define boolean BOOL
 #endif
 
 /* 7.18.2.1  Limits of exact-width integer types */
@@ -234,6 +223,8 @@ typedef int32_t boolean;
 
 	#define FUNCNOINLINE __attribute__((noinline))
 
+	#define FUNCWARNRV __attribute__((warn_unused_result))
+
 	#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) // >= GCC 4.4
 		#ifdef __i386__ // i386 only
 			#define FUNCTARGET(X)  __attribute__ ((__target__ (X)))
@@ -279,6 +270,9 @@ typedef int32_t boolean;
 #ifndef FUNCTARGET
 #define FUNCTARGET(x)
 #endif
+#ifndef FUNCWARNRV
+#define FUNCWARNRV
+#endif
 #ifndef ATTRPACK
 #define ATTRPACK
 #endif

src/f_wipe.c

@@ -361,11 +361,6 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 	// on for fade-to-black
 	for (;;)
 	{
-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		// get fademask first so we can tell if it exists or not
 		fmask = F_GetFadeMask(wipetype, wipeframe++);
 
@@ -393,11 +388,11 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 		if (rendermode != render_none && drawMenu)
 		{
 #ifdef HAVE_THREADS
-			I_lock_mutex(&m_menu_mutex);
+			I_LockMutex(&m_menu_mutex);
 #endif
 			M_Drawer(); // menu is drawn even on top of wipes
 #ifdef HAVE_THREADS
-			I_unlock_mutex(m_menu_mutex);
+			I_UnlockMutex(m_menu_mutex);
 #endif
 		}
 

src/g_demo.c

@@ -2605,7 +2605,7 @@ void G_DoPlayDemo(char *defdemoname)
 	boolean skiperrors = false;
 #endif
 	boolean spectator;
-	UINT8 slots[MAXPLAYERS] = {}, kartspeed[MAXPLAYERS] = {}, kartweight[MAXPLAYERS] = {}, numslots = 0;
+	UINT8 slots[MAXPLAYERS], kartspeed[MAXPLAYERS], kartweight[MAXPLAYERS], numslots = 0;
 
 	G_InitDemoRewind();
 
@@ -2616,7 +2616,7 @@ void G_DoPlayDemo(char *defdemoname)
 	if (defdemoname == NULL)
 	{
 		demobuf.p = demobuf.buffer;
-		pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed
+		pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed
 	}
 	else
 	{
@@ -2628,7 +2628,7 @@ void G_DoPlayDemo(char *defdemoname)
 			n++;
 
 		pdemoname = ZZ_Alloc(strlen(n)+1);
-		strcpy(pdemoname, n);
+		strcpy(pdemoname,n);
 
 		M_SetPlaybackMenuPointer();
 
@@ -3090,9 +3090,6 @@ post_compat:
 	if (cv_director.value)
 		CV_SetValue(&cv_director, 0);
 
-	if (demo.timing)
-		G_DoneLevelLoad();
-
 	demo.deferstart = true;
 }
 #undef SKIPERRORS

src/g_game.c

@@ -69,6 +69,9 @@ UINT8 botcolor = 0;
 
 JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
 
+// 1024 bytes is plenty for a savegame
+#define SAVEGAMESIZE (1024)
+
 // SRB2kart
 char gamedatafilename[64] = "kartdata.dat";
 char timeattackfolder[64] = "kart";
@@ -97,6 +100,7 @@ boolean savemoddata = false;
 UINT8 paused = 0;
 UINT8 modeattacking = ATTACKING_NONE;
 boolean imcontinuing = false;
+boolean runemeraldmanager = false;
 
 boolean netgame = false; // only true if packets are broadcast
 boolean multiplayer = false;
@@ -209,6 +213,7 @@ const INT32 wantedfrequency = 10*TICRATE;
 INT32 gameovertics = 15*TICRATE;
 
 UINT8 use1upSound = 0;
+UINT8 maxXtraLife = 2; // Max extra lives from rings
 
 UINT8 introtoplay = 0;
 UINT8 creditscutscene = 0;
@@ -3897,7 +3902,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
+		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -4148,7 +4153,6 @@ static void measurekeywords(mapsearchfreq_t *fr,
 {
 	char *qp;
 	char *sp;
-
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4163,12 +4167,10 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
-
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
-
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);

src/hardware/hw_cache.cpp

@@ -15,6 +15,8 @@
 
 #ifdef HWRENDER
 
+#include <unordered_set>
+
 #include "hw_main.h"
 #include "hw_glob.h"
 #include "hw_gl.h"
@@ -98,7 +100,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
 			position = 0;
 		}
 
-		position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
+		position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
 
 		if (position + count >= pblockheight)
 			count = pblockheight - position;
@@ -162,7 +164,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -212,7 +214,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -288,7 +290,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	INT32 blocksize = (glMipmap->width * glMipmap->height);
 
 	bpp = format2bpp(glMipmap->format);
-	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
+	block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
 
 	switch (bpp)
 	{
@@ -325,7 +327,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];
 
 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
+	gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
 
 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -344,7 +346,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif
 
-	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
 	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -377,7 +379,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
+		pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;
 
 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -413,7 +415,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;
 
 		// setup the texture info
-		glMipmap->format = (GLTextureFormat_t)(patchformat);
+		glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
 
 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -455,7 +457,7 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;
 
-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
@@ -471,7 +473,7 @@ void HWR_FreeTexture(patch_t *patch)
 
 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+		GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 		HWR_FreeTextureColormaps(patch);
 
@@ -497,7 +499,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;
 
-	pat = (GLPatch_t *)(patch->hardware);
+	pat = static_cast<GLPatch_t *>(patch->hardware);
 	if (!pat)
 		return;
 
@@ -612,20 +614,24 @@ void HWR_FreeMapTextures(void)
 	gl_numtextures = 0;
 }
 
-#define NAME    flatcheck
-#define KEY_TY  UINT32
-#define HASH_FN vt_hash_integer
-#define CMPR_FN vt_cmpr_integer
-#include "../verstable.h"
-
 static void HWR_PrecacheLevelFlats(void)
 {
 	// lookup for flats that may´ve been already loaded
-	flatcheck flatpresent;
-	flatcheck_init(&flatpresent);
+	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
+	std::unordered_set<UINT32> flatpresent;
 	size_t i, j;
 	INT32 k;
 
+	auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
+	{
+		// flat already loaded?
+		if (flatpresent.count(lump) == 0)
+		{
+			HWR_GetFlat(lump, noencoremap);
+			flatpresent.insert(lump);
+		}
+	};
+
 	// special case for encore
 #ifdef GLENCORE
 	if (encoremap)
@@ -643,23 +649,14 @@ static void HWR_PrecacheLevelFlats(void)
 
 				const levelflat_t *levelflat = &levelflats[pic];
 
-				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-				{
-					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
-					flatcheck_insert(&flatpresent, levelflat->lumpnum);
-				}
+				load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
 
 				if (levelflat->speed) // is it an animated flat ?
 				{
 					// start from 0, occasionally basenumlump != flat->lumpnum
 					for (k = 0; k < levelflat->numpics; k++)
 					{
-						lumpnum_t lump = levelflat->baselumpnum + k;
-						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-						{
-							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
-							flatcheck_insert(&flatpresent, lump);
-						}
+						load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
 					}
 				}
 			}
@@ -674,29 +671,18 @@ static void HWR_PrecacheLevelFlats(void)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
 
-			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-			{
-				HWR_GetFlat(levelflat->lumpnum, false);
-				flatcheck_insert(&flatpresent, levelflat->lumpnum);
-			}
+			load_flat(levelflat->lumpnum, false);
 
 			if (levelflat->speed) // is it an animated flat ?
 			{
 				// start from 0, occasionally basenumlump != flat->lumpnum
 				for (k = 0; k < levelflat->numpics; k++)
 				{
-					lumpnum_t lump = levelflat->baselumpnum + k;
-					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-					{
-						HWR_GetFlat(lump, false);
-						flatcheck_insert(&flatpresent, lump);
-					}
+					load_flat(levelflat->baselumpnum + k, false);
 				}
 			}
 		}
 	}
-
-	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -706,7 +692,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;
 
-	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
+	texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
 
@@ -881,7 +867,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();
 
 	gl_numtextures = pnumtextures;
-	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
+	gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
 
 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -978,7 +964,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
 
 #ifdef GLENCORE
-	flat = (UINT8 *)(glMipmap->data);
+	flat = static_cast<UINT8 *>(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1022,7 +1008,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+		glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
 		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
@@ -1046,7 +1032,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	if (!glMipmap->downloaded)
 	{
@@ -1067,7 +1053,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 	HWR_MakePatch(patch, glPatch, glMipmap, true);
 
 	// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1103,7 +1089,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 
 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);
 
 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1139,12 +1125,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 	//              (it have a liste of mipmap)
 	//    this malloc is cleared in HWR_FreeColormapCache
 	//    (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
-	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
+	newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;
 
-	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
 	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -1167,7 +1153,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 	{
 		void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
 		Patch_Create(NULL, 0, ptr);
-		Patch_AllocateHardwarePatch((patch_t *)(ptr));
+		Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
 	}
 
 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1184,7 +1170,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1340,7 +1326,7 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = (UINT8 *)(Z_Malloc(
+	UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
 		HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
 		PU_STATIC, NULL));
 #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1385,7 +1371,7 @@ void HWR_SetMapPalette(void)
 		if (palsize < 768) // 256 * 3
 			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));
+		RGB_data = static_cast<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++)
 		{
@@ -1420,7 +1406,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
+	RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
 
 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.

src/hardware/hw_data.h

@@ -54,7 +54,7 @@ struct GLMipmap_s
 	UINT16					width, height;
 	UINT32					downloaded; // The GPU has this texture.
 
-	struct GLMipmap_s		*nextcolormap;
+	struct	GLMipmap_s		*nextcolormap;
 	struct GLColormap_s		*colormap;
 };
 typedef struct GLMipmap_s GLMipmap_t;

src/hardware/hw_defs.h

@@ -110,7 +110,7 @@ typedef struct
 typedef struct
 {
 	poly_t *planepoly;  // the generated convex polygon
-} poly_subsector_t;
+} extrasubsector_t;
 
 // Vanilla features
 //#define USE_MODEL_NEXTFRAME

src/hardware/hw_draw.c

@@ -222,7 +222,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf = {};
+		FSurfaceInfo Surf;
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -385,7 +385,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 	// clip it since it is used for bunny scroll in doom I
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf = {};
+		FSurfaceInfo Surf;
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -490,7 +490,7 @@ void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
 void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
 
 	v[0].x = v[3].x = -1.0f;
@@ -543,7 +543,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 void HWR_DrawConsoleBack(UINT32 color, INT32 height)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	// setup some neat-o translucency effect
 	if (!height) //cool hack 0 height is full height
@@ -598,7 +598,7 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
 void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh, fwait = 0;
 	RGBA_t *palette;
 
@@ -702,7 +702,7 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)
@@ -820,7 +820,7 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
 void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)

src/hardware/hw_glob.h

@@ -52,12 +52,12 @@ void HWR_ObjectLightLevelPost(gl_vissprite_t *spr, const sector_t *sector, INT32
 // --------
 // hw_bsp.c
 // --------
-extern poly_subsector_t *poly_subsectors;
+extern extrasubsector_t *extrasubsectors;
 #ifdef PARANOIA
-extern size_t num_poly_subsector;
+extern size_t addsubsector;
 #endif
-void HWR_InitPolyPool(void);
-void HWR_FreePolyPool(void);
+
+void HWR_FreeExtraSubsectors(void);
 
 // --------
 // hw_cache.c

src/hardware/hw_main.cpp

@@ -125,7 +125,7 @@ ps_metric_t ps_hw_batchdrawtime = {};
 static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags);
 static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
 
-static void HWR_AddTransparentFloor(lumpnum_t lumpnum, poly_subsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
+static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
 static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
 static void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
 
@@ -231,17 +231,6 @@ consvar_t cv_glanisotropicmode = {"gr_anisotropicmode", "1", CV_CALL|CV_SAVE, gl
 
 consvar_t cv_glsolvetjoin = {"gr_solvetjoin", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_glpolytile = {"gr_polytile", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-
-CV_PossibleValue_t grpolyshape_cons_t[] = {
-	{0, "Subsector"},
-	{1, "Fat"},
-	{2, "Trim"},
-	{3, "NotConvex"},
-	{0, NULL}
-};
-consvar_t cv_glpolyshape = {"gr_polygon_shape", "Trim", CV_SAVE, grpolyshape_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-
 consvar_t cv_glbatching = {"gr_batching", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_glwireframe = {"gr_wireframe", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -253,6 +242,7 @@ consvar_t cv_glportals = {"gr_portals", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,
 
 consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_glflashpal = {"gr_flashpal", "On", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL};
 
@@ -559,9 +549,9 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
 
 // HWR_RenderPlane
 // Render a floor or ceiling convex polygon
-static void HWR_RenderPlane(subsector_t *subsector, poly_subsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
+static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
 {
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FOutVector *v3d;
 	polyvertex_t *pv;
 	pslope_t *slope = NULL;
@@ -1386,9 +1376,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	extracolormap_t *colormap = gl_frontsector->extra_colormap;
 	lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap);
 
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
-	Surf.PolyColor.s.alpha = 255;
+	if (gl_frontsector)
+		Surf.PolyColor.s.alpha = 255;
 
 	const INT32 gl_midtexture = R_GetTextureNum(gl_sidedef->midtexture);
 	GLMapTexture_t *glTex = NULL;
@@ -2685,7 +2676,7 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	float           scrollx = 0.0f, scrolly = 0.0f;
 	float           anglef  = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
 	angle_t         angle = 0;
-	FSurfaceInfo    Surf = {};
+	FSurfaceInfo    Surf;
 	fixed_t         tempxsow, tempytow;
 	size_t          nrPlaneVerts;
 
@@ -2832,7 +2823,7 @@ static void HWR_AddPolyObjectPlanes(void)
 	sector_t *polyobjsector;
 	INT32 light = 0;
 
-	// Polyobject Planes need their own function for drawing because they don't have poly_subsectors by themselves
+	// Polyobject Planes need their own function for drawing because they don't have extrasubsectors by themselves
 	// It should be okay because polyobjects should always be convex anyway
 
 	for (i = 0; i < numpolys; i++)
@@ -2852,8 +2843,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
 												(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));
@@ -2874,8 +2866,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
 												(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));
@@ -2960,9 +2953,9 @@ static void HWR_Subsector(size_t num)
 	ffloor_t *rover;
 
 #ifdef PARANOIA // no risk while developing, enough debugging nights!
-	if (num >= num_poly_subsector)
+	if (num >= addsubsector)
 		I_Error("HWR_Subsector: ss %s with numss = %s, addss = %s\n",
-			sizeu1(num), sizeu2(numsubsectors), sizeu3(num_poly_subsector));
+			sizeu1(num), sizeu2(numsubsectors), sizeu3(addsubsector));
 #endif
 
 	if (num < numsubsectors)
@@ -3057,7 +3050,7 @@ static void HWR_Subsector(size_t num)
 			if (sub->validcount != validcount)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false));
-				HWR_RenderPlane(sub, &poly_subsectors[num], false,
+				HWR_RenderPlane(sub, &extrasubsectors[num], false,
 					gl_frontsector->floorheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap);
@@ -3072,7 +3065,7 @@ static void HWR_Subsector(size_t num)
 			if (sub->validcount != validcount)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true));
-				HWR_RenderPlane(sub, &poly_subsectors[num], true,
+				HWR_RenderPlane(sub, &extrasubsectors[num], true,
 					gl_frontsector->ceilingheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap);
@@ -3119,7 +3112,7 @@ static void HWR_Subsector(size_t num)
 					alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
 
 					HWR_AddTransparentFloor(0,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											false,
 											*rover->bottomheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3131,7 +3124,7 @@ static void HWR_Subsector(size_t num)
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < bottomCullHeight));
 
 					HWR_AddTransparentFloor(levelflats[*rover->bottompic].lumpnum,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											false,
 											*rover->bottomheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3143,7 +3136,7 @@ static void HWR_Subsector(size_t num)
 					HWR_GetFlat(levelflats[*rover->bottompic].lumpnum, R_NoEncore(gl_frontsector, false));
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < bottomCullHeight));
 
-					HWR_RenderPlane(sub, &poly_subsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->bottompic].lumpnum,
+					HWR_RenderPlane(sub, &extrasubsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->bottompic].lumpnum,
 									rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
 				}
 			}
@@ -3165,7 +3158,7 @@ static void HWR_Subsector(size_t num)
 					alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
 
 					HWR_AddTransparentFloor(0,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											true,
 											*rover->topheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3177,7 +3170,7 @@ static void HWR_Subsector(size_t num)
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < topCullHeight));
 
 					HWR_AddTransparentFloor(levelflats[*rover->toppic].lumpnum,
-											&poly_subsectors[num],
+											&extrasubsectors[num],
 											true,
 											*rover->topheight,
 											*gl_frontsector->lightlist[light].lightlevel,
@@ -3189,7 +3182,7 @@ static void HWR_Subsector(size_t num)
 					HWR_GetFlat(levelflats[*rover->toppic].lumpnum, R_NoEncore(gl_frontsector, true));
 					light = R_GetPlaneLight(gl_frontsector, centerHeight, (viewz < topCullHeight));
 
-					HWR_RenderPlane(sub, &poly_subsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->toppic].lumpnum,
+					HWR_RenderPlane(sub, &extrasubsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, levelflats[*rover->toppic].lumpnum,
 									rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
 				}
 			}
@@ -3427,7 +3420,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 {
 	float this_scale = 1.0f;
 	FOutVector swallVerts[4];
-	FSurfaceInfo sSurf = {};
+	FSurfaceInfo sSurf;
 	FBITFIELD blendmode = 0;
 	fixed_t floorheight, mobjfloor;
 	pslope_t *floorslope;
@@ -3663,7 +3656,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	FOutVector baseWallVerts[4]; // This is what the verts should end up as
 	patch_t *gpatch;
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	extracolormap_t *colormap;
 	INT32 lightlevel;
 	boolean lightset = true;
@@ -3692,7 +3685,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// Draw shadow BEFORE sprite
 	if (UNLIKELY(cv_shadow.value // Shadows enabled
@@ -3794,10 +3787,10 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	{
 		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
 		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
 
 		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
 	}
 
 	if (HWR_UseShader())
@@ -3948,7 +3941,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FBITFIELD blend = 0;
 
 	INT32 shader = SHADER_NONE;
@@ -3980,7 +3973,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// create the sprite billboard
 	//
@@ -4091,10 +4084,10 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	{
 		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
 		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
 
 		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
 	}
 
 	if (HWR_UseShader())
@@ -4113,7 +4106,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	INT32 shader = SHADER_NONE;
 
@@ -4130,7 +4123,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);
 
-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);
 
 	// create the sprite billboard
 	//
@@ -4270,7 +4263,7 @@ typedef struct
 
 typedef struct
 {
-	poly_subsector_t *xsub;
+	extrasubsector_t *xsub;
 	boolean isceiling;
 	fixed_t fixedheight;
 	INT32 lightlevel;
@@ -4354,7 +4347,7 @@ static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, I
 	wallinfo->wallcolormap = wallcolormap;
 }
 
-static void HWR_AddTransparentFloor(lumpnum_t lumpnum, poly_subsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap)
+static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap)
 {
 	planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE));
 
@@ -4521,6 +4514,7 @@ static void HWR_RenderDrawNodes(void)
 	drawnodes.clear(); // clear so our size is 0 again!
 }
 
+
 // --------------------------------------------------------------------------
 //  Draw all vissprites
 // --------------------------------------------------------------------------
@@ -4857,7 +4851,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		flip = sprframe->flip; // Will only be 0x00 or 0xFF
 
 		if (papersprite && ang < ANGLE_180)
-			flip ^= 0xFF;
+			flip ^= 0xFFFF;
 	}
 	else
 	{
@@ -5824,7 +5818,6 @@ void HWR_RenderPlayerView(void)
 
 void HWR_LoadLevel(void)
 {
-	HWR_FreePolyPool();
 	HWR_CreatePlanePolygons((INT32)numnodes - 1);
 
 	// Build the sky dome
@@ -5909,8 +5902,6 @@ void HWR_AddCommands(void)
 	CV_RegisterVar(&cv_glanisotropicmode);
 
 	CV_RegisterVar(&cv_glsolvetjoin);
-	CV_RegisterVar(&cv_glpolytile);
-	CV_RegisterVar(&cv_glpolyshape);
 
 	CV_RegisterVar(&cv_glbatching);
 
@@ -5923,6 +5914,7 @@ void HWR_AddCommands(void)
 
 	CV_RegisterVar(&cv_glpaletterendering);
 	CV_RegisterVar(&cv_glpalettedepth);
+	CV_RegisterVar(&cv_glflashpal);
 }
 
 // --------------------------------------------------------------------------
@@ -5938,7 +5930,6 @@ void HWR_Startup(void)
 		CONS_Printf("HWR_Startup()...\n");
 		textureformat = patchformat = GL_TEXFMT_RGBA;
 
-		HWR_InitPolyPool();
 		HWR_InitMapTextures();
 		HWR_InitMD2();
 
@@ -6030,7 +6021,7 @@ static void COM_HWR_glinfo(void)
 void HWR_Shutdown(void)
 {
 	CONS_Printf("HWR_Shutdown()\n");
-	HWR_FreePolyPool();
+	HWR_FreeExtraSubsectors();
 	HWR_FreeMapTextures();
 	GL_FlushScreenTextures();
 	HWR_ClearAllTextures();
@@ -6080,7 +6071,7 @@ static void HWR_DoPostProcessor(void)
 {
 	// Armageddon Blast Flash!
 	// Could this even be considered postprocessor?
-	if (!HWR_ShouldUsePaletteRendering())
+	if (!HWR_PalRenderFlashpal())
 	{
 		const player_t *player = &players[displayplayers[viewssnum]];
 
@@ -6093,7 +6084,7 @@ static void HWR_DoPostProcessor(void)
 				{-4.0f, -4.0f, 4.0f, 0.0f, 0.0f}
 			};
 
-			FSurfaceInfo Surf = {};
+			FSurfaceInfo Surf;
 
 			// This won't change if the flash palettes are changed unfortunately, but it works for its purpose
 			if (player->flashpal == PAL_NUKE)

src/hardware/hw_main.h

@@ -195,7 +195,7 @@ extern consvar_t cv_gllightdither;
 extern consvar_t cv_glfiltermode;
 extern consvar_t cv_glanisotropicmode;
 
-extern consvar_t cv_glsolvetjoin, cv_glpolytile, cv_glpolyshape;
+extern consvar_t cv_glsolvetjoin;
 
 extern consvar_t cv_glbatching;
 
@@ -208,6 +208,7 @@ extern consvar_t cv_glportals;
 
 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
+extern consvar_t cv_glflashpal;
 
 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -219,6 +220,11 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }
 
+FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
+{
+	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
+}
+
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {

src/hardware/hw_md2.c

@@ -693,15 +693,17 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
 	GLPatch_t *hwrBlendPatch = blendgpatch->hardware;
 	UINT16 w = gpatch->width, h = gpatch->height;
 	UINT32 size = w*h;
-	RGBA_t *image, *blendimage, *cur;
-	RGBA_t blendcolor = {};
+	RGBA_t *image, *blendimage, *cur, blendcolor;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	UINT8 translation[17] = {}; // First the color index
-	UINT8 cutoff[17] = {}; // Brightness cutoff before using the next color
+	UINT8 translation[17]; // First the color index
+	UINT8 cutoff[17]; // Brightness cutoff before using the next color
 	UINT8 translen = 0;
 	UINT8 i;
-	UINT8 colorbrightnesses[17] = {};
-	UINT8 color_match_lookup[256] = {}; // optimization attempt
+	UINT8 colorbrightnesses[17];
+	UINT8 color_match_lookup[256]; // optimization attempt
+
+	memset(translation, 0, sizeof(translation));
+	memset(cutoff, 0, sizeof(cutoff));
 
 	if (glMipmap->width == 0)
 	{
@@ -714,10 +716,14 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
 		glMipmap->format = GL_TEXFMT_RGBA;
 	}
 
-	Z_Free(glMipmap->data);
-	glMipmap->data = NULL;
+	if (glMipmap->data)
+	{
+		Z_Free(glMipmap->data);
+		glMipmap->data = NULL;
+	}
 
-	cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
+	cur = Z_Malloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
+	memset(cur, 0x00, size*4);
 
 	image = hwrPatch->mipmap->data;
 	blendimage = hwrBlendPatch->mipmap->data;
@@ -1031,6 +1037,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
 	GLPatch_t *glPatch = patch->hardware;
 	GLMipmap_t *glMipmap, *newMipmap;
 
+
 	if (blendgpatch == NULL || colormap == colormaps || colormap == NULL)
 	{
 		// Don't do any blending
@@ -1099,7 +1106,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	INT32 frame = 0;
 	INT32 nextFrame = -1;
 	FTransform p;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	if (!cv_glmdls.value || spr->precip)
 		return;
@@ -1336,8 +1343,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		if (spr->mobj->frame & FF_ANIMATE)
 		{
 			// set duration and tics to be the correct values for FF_ANIMATE states
-			durs = spr->mobj->state->var2;
-			tics = (INT32)spr->mobj->anim_duration;
+			durs = (float)spr->mobj->state->var2;
+			tics = (float)spr->mobj->anim_duration;
 		}
 
 		//FIXME: this is not yet correct
@@ -1475,7 +1482,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	patch_t *gpatch, *blendgpatch;
 	GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
 	FTransform p;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 
 	if (!md2->model)
 	{
@@ -1526,6 +1533,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
 	if (blendgpatch)
 		hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
 
+	memset(&Surf, 0x00, sizeof(FSurfaceInfo));
 	Surf.PolyColor.rgba = 0xFFFFFFFF;
 	Surf.PolyFlags = PF_Occlude | PF_Modulated;
 

src/hardware/hw_shaders.c

@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	gconst char *location = strstr(str1, str2);
+	char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else

src/hardware/r_opengl/r_opengl.c

@@ -1383,19 +1383,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	gconst GLubyte *where, *terminator;
+	GLubyte         *where, *terminator;
 
 	if (!extension || !start)
 		return 0;
 
-	where = (gconst GLubyte *)strchr(extension, ' ');
+	where = (GLubyte *) strchr(extension, ' ');
 
 	if (where || *extension == '\0')
 		return 0;
 
 	for (;;)
 	{
-		where = (gconst GLubyte *)strstr((const char *)start, extension);
+		where = (GLubyte *) strstr((const char *) start, extension);
 
 		if (!where)
 			break;

src/http-mserv.c

@@ -62,7 +62,7 @@ static int hms_started;
 
 static char *hms_api;
 #ifdef HAVE_THREADS
-static I_mutex hms_api_mutex;
+static I_Mutex hms_api_mutex;
 #endif
 
 static char *hms_server_token;
@@ -90,9 +90,9 @@ Printf_url (const char *url)
 	boolean startup;
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&con_mutex);
+	I_LockMutex(&con_mutex);
 	startup = con_startup;
-	I_unlock_mutex(con_mutex);
+	I_UnlockMutex(con_mutex);
 #else
 	startup = con_startup;
 #endif
@@ -183,7 +183,7 @@ HMS_connect (const char *format, ...)
 	}
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&hms_api_mutex);
+	I_LockMutex(&hms_api_mutex);
 #endif
 
 	seek = strlen(hms_api) + 1;/* + '/' */
@@ -195,7 +195,7 @@ HMS_connect (const char *format, ...)
 	sprintf(url, "%s/", hms_api);
 
 #ifdef HAVE_THREADS
-	I_unlock_mutex(hms_api_mutex);
+	I_UnlockMutex(hms_api_mutex);
 #endif
 
 	va_start (ap, format);
@@ -225,10 +225,9 @@ HMS_connect (const char *format, ...)
 	{
 		cc = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-#ifdef LOGMESSAGES
+
 		cc = curl_easy_setopt(curl, CURLOPT_STDERR, logstream);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-#endif
 	}
 
 	if (M_CheckParm("-bindaddr") && M_IsNextParm())
@@ -318,7 +317,6 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
-	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }
@@ -479,12 +477,12 @@ HMS_fetch_servers (msg_server_t *list, int query_id)
 			if (address && port)
 			{
 #ifdef HAVE_THREADS
-				I_lock_mutex(&ms_QueryId_mutex);
+				I_LockMutex(&ms_QueryId_mutex);
 				{
 					if (query_id != ms_QueryId)
 						doing_shit = 0;
 				}
-				I_unlock_mutex(ms_QueryId_mutex);
+				I_UnlockMutex(ms_QueryId_mutex);
 
 				if (! doing_shit)
 					break;
@@ -613,14 +611,14 @@ void
 HMS_set_api (char *api)
 {
 #ifdef HAVE_THREADS
-	I_lock_mutex(&hms_api_mutex);
+	I_LockMutex(&hms_api_mutex);
 #endif
 	{
 		free(hms_api);
 		hms_api = Strip_trailing_slashes(api);
 	}
 #ifdef HAVE_THREADS
-	I_unlock_mutex(hms_api_mutex);
+	I_UnlockMutex(hms_api_mutex);
 #endif
 }
 

src/hu_stuff.c

@@ -97,6 +97,7 @@ static textinput_t w_chat;
 static boolean headsupactive = false;
 boolean hu_showscores = false; // draw rankings
 static char hu_tick;
+static tic_t hu_emoteanim = 0;
 emote_autocomplete_t emote_autocomplete = {0};
 
 static huddrawlist_h luahuddrawlist_scores = NULL;
@@ -496,9 +497,7 @@ static void HU_removeChatText_Log(void)
 	{
 		chat_log[i] = chat_log[i+1];
 	}
-
 	chat_nummsg_log--; // lost 1 msg.
-	chat_log[chat_nummsg_log] = NULL;
 }
 
 static void Chatlogsize_OnChange(void)
@@ -517,7 +516,6 @@ static void Chatlogsize_OnChange(void)
 	if (new_chat_log == NULL)
 	{
         free(chat_log);
-		chat_log = NULL;
 		return;
 	}
 	chat_log = new_chat_log;
@@ -906,7 +904,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 	target = READSINT8(*p);
 	flags = READUINT8(*p);
 	msg = buf;
-	READSTRINGN(*p, msg, HU_MAXMSGLEN + 1);
+	READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);
 
 	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
 	{
@@ -1094,6 +1092,7 @@ void HU_Ticker(void)
 		return;
 
 	hu_tick++;
+	hu_emoteanim++;
 	hu_tick &= 7; // currently only to blink chat input cursor
 
 	if (PLAYER1INPUTDOWN(gc_scores))
@@ -1808,7 +1807,6 @@ static void HU_DrawChat(void)
 	INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
 	UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
 	INT32 cflag = 0;
-	INT32 pm_offset = 0; // for cases when you type emote while also doing /pm
 	size_t select_start = 0, select_end = 0;
 	const char *ntalk = "Say: ", *ttalk = "Team: ";
 	const char *talk = ntalk;
@@ -1920,6 +1918,64 @@ static void HU_DrawChat(void)
 		}
 	}
 
+	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
+	{
+		emote_t *suggest;
+		int skip = 0;
+
+		const char *complete;
+		int complete_len;
+
+		if (emote_autocomplete.complete[0])
+		{
+			complete = emote_autocomplete.complete;
+			complete_len = strlen(complete);
+		}
+		else
+		{
+			complete = &w_chat_buf[emote_autocomplete.emotestart];
+			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
+		}
+
+		// A bit of copy-paste from /pm code :p
+		INT32 suggesty = chaty - charheight - 1;
+		size_t longest_suggestion_length = 0;
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
+			++skip;
+		}
+
+		skip = 0;
+
+#ifdef NETSPLITSCREEN
+		if (splitscreen)
+		{
+			suggesty -= BASEVIDHEIGHT/2;
+			if (splitscreen > 1)
+				suggesty += 16;
+		}
+		else
+#endif
+			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*skip), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			// Highlight currently suggested emote
+			int hlflag = 0;
+			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
+				hlflag = V_YELLOWMAP;
+
+			V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
+			M_DrawEmote(chatx + boxw + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			++skip;
+		}
+	}
+
 	// handle /pm list. It's messy, horrible and I don't care.
 	if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
 	{
@@ -2000,74 +2056,9 @@ static void HU_DrawChat(void)
 
 		if (count == 0) // no results.
 		{
-			pm_offset = 48 + 2;
 			V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
 			V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
 		}
-		else
-		{
-			pm_offset = (longest_name_length+4)*4 + 2;
-		}
-	}
-
-	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
-	{
-		emote_t *suggest;
-		int skip = 0;
-
-		const char *complete;
-		int complete_len;
-
-		if (emote_autocomplete.complete[0])
-		{
-			complete = emote_autocomplete.complete;
-			complete_len = strlen(complete);
-		}
-		else
-		{
-			complete = &w_chat_buf[emote_autocomplete.emotestart];
-			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
-		}
-
-		// A bit of copy-paste from /pm code :p
-		INT32 suggesty = chaty - charheight - 1;
-		size_t longest_suggestion_length = 0;
-
-		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
-		{
-			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
-			++skip;
-		}
-
-		INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
-
-		skip = 0;
-
-#ifdef NETSPLITSCREEN
-		if (splitscreen)
-		{
-			suggesty -= BASEVIDHEIGHT/2;
-			if (splitscreen > 1)
-				suggesty += 16;
-		}
-		else
-#endif
-			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
-
-		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
-		{
-			V_DrawFillConsoleMap(chatx + boxw + pm_offset + 2, suggesty - (7*skip), emote_suggest_boxw, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-
-			// Highlight currently suggested emote
-			int hlflag = 0;
-			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
-				hlflag = V_YELLOWMAP;
-
-			V_DrawSmallString(chatx + boxw + pm_offset + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
-			M_DrawEmote(chatx + boxw + pm_offset + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-
-			++skip;
-		}
 	}
 
 	HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.

src/i_system.h

@@ -43,7 +43,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;
 
 /** \brief Set to true when inside a signal handler that will exit the program. */
-boolean I_In_Exiting_Signal_Handler(void);
+extern boolean g_in_exiting_signal_handler;
 
 /**	\brief	The I_GetFreeMem function
 
@@ -195,10 +195,6 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);
 
-/**	\brief To check if a Interrupt or Terminate Signal was fired
- */
-boolean I_Interrupted(void);
-
 /**	\brief	The I_GetDiskFreeSpace function
 
 	\param	freespace	a INT64 pointer to hold the free space amount

src/i_tcp.c

@@ -496,10 +496,8 @@ static void cleanupnodes(void)
 
 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
-	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
-	}
 }
 
 static SINT8 getfreenode(void)
@@ -509,13 +507,11 @@ static SINT8 getfreenode(void)
 	cleanupnodes();
 
 	for (j = 0; j < MAXNETNODES; j++)
-	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
-	}
 
 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -816,7 +812,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (numnode <= 0 || numnode > MAXNETNODES)
+	if (!numnode || numnode > MAXNETNODES)
 		return;
 
 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1436,12 +1432,14 @@ static void SOCK_RegisterHolePunch(void)
 
 static boolean SOCK_OpenSocket(void)
 {
-	memset(clientaddress, 0, sizeof(clientaddress));
+	size_t i;
+
+	memset(clientaddress, 0, sizeof (clientaddress));
 
-	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
+	for (i = 1; i < MAXNETNODES; i++)
+		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
-
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1481,7 +1479,7 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;
 
-	if (node < 0 || node > MAXNETNODES)
+	if (node > MAXNETNODES)
 		return false;
 
 	ban = numbans;

src/i_threads.c

@@ -1,4 +1,4 @@
-// SONIC ROBO BLAST 2
+// SONIC ROBO BLAST 2 KART
 //-----------------------------------------------------------------------------
 // Copyright (C) 2020-2023 by James R.
 //
@@ -9,12 +9,14 @@
 /// \file  i_threads.c
 /// \brief Multithreading abstraction
 
-#if defined (__unix__) || (!defined(__APPLE__) && defined (UNIXCOMMON))
+#ifdef HAVE_THREADS
+#if defined (__unix__) || defined(UNIXCOMMON)
 
 #include <pthread.h>
 
-#include "../i_threads.h"
-#include "../doomdef.h"
+#include "i_threads.h"
+#include "doomdef.h"
+#include "doomtype.h"
 
 typedef struct thread_s thread_t;
 
@@ -22,7 +24,7 @@ struct thread_s
 {
 	thread_t *next;
 	void *userdata;
-	I_thread_fn func;
+	I_ThreadFn func;
 	pthread_t thread;
 };
 
@@ -41,12 +43,8 @@ static void *HandleThread(void *data)
 	return NULL;
 }
 
-void
-I_spawn_thread (
-	const char  * name,
-	I_thread_fn   entry,
-	void        * userdata
-)
+FUNCWARNRV
+int I_SpawnThread(const char *name, I_ThreadFn entry, void *userdata)
 {
 	thread_t *thread;
 	(void)name;
@@ -66,17 +64,20 @@ I_spawn_thread (
 	if (thread == NULL)
 	{
 		thread = malloc(sizeof(thread_t));
+		if (thread == NULL)
+			return false;
 		thread->next = thread_list;
 		thread_list = thread;
 	}
 
 	thread->func = entry;
 	thread->userdata = userdata;
-	pthread_create(&thread->thread, NULL, HandleThread, thread);
+	int err = pthread_create(&thread->thread, NULL, HandleThread, thread);
 	pthread_mutex_unlock(&thread_lock);
+	return err == 0;
 }
 
-int I_thread_is_stopped(void)
+int I_ThreadIsStopped(void)
 {
 	thread_t *thread;
 	pthread_mutex_lock(&thread_lock);
@@ -94,11 +95,11 @@ int I_thread_is_stopped(void)
 	return true;
 }
 
-void I_start_threads(void)
+void I_StartThreads(void)
 {
 }
 
-void I_stop_threads(void)
+void I_StopThreads(void)
 {
 	thread_t *thread = thread_list;
 	while (thread != NULL)
@@ -109,7 +110,7 @@ void I_stop_threads(void)
 	}
 }
 
-void I_lock_mutex(I_mutex *anchor)
+void I_LockMutex(I_Mutex *anchor)
 {
 	pthread_mutex_lock(&thread_lock);
 	if (*anchor == NULL)
@@ -127,25 +128,25 @@ void I_lock_mutex(I_mutex *anchor)
 	pthread_mutex_lock(*anchor);
 }
 
-void I_unlock_mutex(I_mutex id)
+void I_UnlockMutex(I_Mutex id)
 {
 	pthread_mutex_unlock(id);
 }
 
-void I_hold_cond(I_cond *cond_anchor, I_mutex mutex_id)
+void I_HoldCond(I_Cond *condAnchor, I_Mutex mutexId)
 {
-	I_Assert(mutex_id != NULL);
+	I_Assert(mutexId != NULL);
 	pthread_mutex_lock(&thread_lock);
-	if (*cond_anchor == NULL)
+	if (*condAnchor == NULL)
 	{
-		*cond_anchor = malloc(sizeof(pthread_cond_t));
-		pthread_cond_init(*cond_anchor, NULL);
+		*condAnchor = malloc(sizeof(pthread_cond_t));
+		pthread_cond_init(*condAnchor, NULL);
 	}
 	pthread_mutex_unlock(&thread_lock);
-	pthread_cond_wait(*cond_anchor, mutex_id);
+	pthread_cond_wait(*condAnchor, mutexId);
 }
 
-void I_wake_one_cond(I_cond *anchor)
+void I_WakeOneCond(I_Cond *anchor)
 {
 	pthread_mutex_lock(&thread_lock);
 	if (*anchor == NULL)
@@ -157,7 +158,7 @@ void I_wake_one_cond(I_cond *anchor)
 	pthread_cond_signal(*anchor);
 }
 
-void I_wake_all_cond(I_cond *anchor)
+void I_WakeAllCond(I_Cond *anchor)
 {
 	pthread_mutex_lock(&thread_lock);
 	if (*anchor == NULL)
@@ -168,12 +169,17 @@ void I_wake_all_cond(I_cond *anchor)
 	pthread_mutex_unlock(&thread_lock);
 	pthread_cond_broadcast(*anchor);
 }
+
+thread_handle_t I_GetCurrentThread(void)
+{
+	return pthread_self();
+}
 #elif defined (_WIN32)
 #include <windows.h>
 
-#include "../i_threads.h"
-#include "../doomdef.h"
-#include "../doomtype.h"
+#include "i_threads.h"
+#include "doomdef.h"
+#include "doomtype.h"
 
 typedef struct thread_s thread_t;
 
@@ -181,9 +187,9 @@ struct thread_s
 {
 	thread_t *next;
 	void *userdata;
-	I_thread_fn func;
+	I_ThreadFn func;
 	HANDLE thread;
-	DWORD thread_id;
+	DWORD threadId;
 };
 
 // we use a linked list to avoid moving memory blocks when allocating new threads.
@@ -201,7 +207,8 @@ static DWORD __stdcall HandleThread(void *data)
 	return 0;
 }
 
-void I_spawn_thread(const char *name, I_thread_fn entry, void *userdata)
+FUNCWARNRV
+int I_SpawnThread(const char *name, I_ThreadFn entry, void *userdata)
 {
 	thread_t *thread;
 	(void)name;
@@ -219,17 +226,20 @@ void I_spawn_thread(const char *name, I_thread_fn entry, void *userdata)
 	if (thread == NULL)
 	{
 		thread = malloc(sizeof(thread_t));
+		if (thread == NULL)
+			return false;
 		thread->next = thread_list;
 		thread_list = thread;
 	}
 
 	thread->func = entry;
 	thread->userdata = userdata;
-	thread->thread = CreateThread(NULL, 0, HandleThread, thread, 0, &thread->thread_id);
+	thread->thread = CreateThread(NULL, 0, HandleThread, thread, 0, &thread->threadId);
 	LeaveCriticalSection(&thread_lock);
+	return thread->thread != NULL;
 }
 
-int I_thread_is_stopped(void)
+int I_ThreadIsStopped(void)
 {
 	thread_t *thread;
 	EnterCriticalSection(&thread_lock);
@@ -247,12 +257,12 @@ int I_thread_is_stopped(void)
 	return true;
 }
 
-void I_start_threads(void)
+void I_StartThreads(void)
 {
 	InitializeCriticalSection(&thread_lock);
 }
 
-void I_stop_threads(void)
+void I_StopThreads(void)
 {
 	thread_t *thread = thread_list;
 	while (thread != NULL)
@@ -264,7 +274,7 @@ void I_stop_threads(void)
 	DeleteCriticalSection(&thread_lock);
 }
 
-void I_lock_mutex(I_mutex *anchor)
+void I_LockMutex(I_Mutex *anchor)
 {
 	EnterCriticalSection(&thread_lock);
 	if (*anchor == NULL)
@@ -276,25 +286,25 @@ void I_lock_mutex(I_mutex *anchor)
 	EnterCriticalSection(*anchor);
 }
 
-void I_unlock_mutex(I_mutex id)
+void I_UnlockMutex(I_Mutex id)
 {
 	LeaveCriticalSection(id);
 }
 
-void I_hold_cond(I_cond *cond_anchor, I_mutex mutex_id)
+void I_HoldCond(I_Cond *condAnchor, I_Mutex mutexId)
 {
-	I_Assert(mutex_id != NULL);
+	I_Assert(mutexId != NULL);
 	EnterCriticalSection(&thread_lock);
-	if (*cond_anchor == NULL)
+	if (*condAnchor == NULL)
 	{
-		*cond_anchor = malloc(sizeof(CONDITION_VARIABLE));
-		InitializeConditionVariable(*cond_anchor);
+		*condAnchor = malloc(sizeof(CONDITION_VARIABLE));
+		InitializeConditionVariable(*condAnchor);
 	}
 	LeaveCriticalSection(&thread_lock);
-	SleepConditionVariableCS(*cond_anchor, mutex_id, INFINITE);
+	SleepConditionVariableCS(*condAnchor, mutexId, INFINITE);
 }
 
-void I_wake_one_cond(I_cond *anchor)
+void I_WakeOneCond(I_Cond *anchor)
 {
 	EnterCriticalSection(&thread_lock);
 	if (*anchor == NULL)
@@ -306,7 +316,7 @@ void I_wake_one_cond(I_cond *anchor)
 	WakeConditionVariable(*anchor);
 }
 
-void I_wake_all_cond(I_cond *anchor)
+void I_WakeAllCond(I_Cond *anchor)
 {
 	EnterCriticalSection(&thread_lock);
 	if (*anchor == NULL)
@@ -317,48 +327,66 @@ void I_wake_all_cond(I_cond *anchor)
 	LeaveCriticalSection(&thread_lock);
 	WakeAllConditionVariable(*anchor);
 }
+
+void *I_GetCurrentThread(void)
+{
+	return GetCurrentThread();
+}
 #else
-void I_spawn_thread(const char *name, I_thread_fn entry, void *userdata)
+#include "i_threads.h"
+
+FUNCWARNRV
+int I_SpawnThread(const char *name, I_ThreadFn entry, void *userdata)
 {
 	(void)name;
 	entry(userdata);
+	return true;
 }
 
-int I_thread_is_stopped(void)
+int I_ThreadIsStopped(void)
+{
+	return true;
+}
+
+void I_StartThreads(void)
 {
 }
 
-void I_start_threads(void)
+void I_StopThreads(void)
 {
 }
 
-void I_stop_threads(void)
-{
-}
-
-void I_lock_mutex(I_mutex *anchor)
+void I_LockMutex(I_Mutex *anchor)
 {
 	(void)anchor;
 }
 
-void I_unlock_mutex(I_mutex id)
+void I_UnlockMutex(I_Mutex id)
 {
 	(void)id;
 }
 
-void I_hold_cond(I_cond *cond_anchor, I_mutex mutex_id)
+void I_HoldCond(I_Cond *condAnchor, I_Mutex mutexId)
 {
-	(void)cond_anchor;
-	(void)mutex_id;
+	(void)condAnchor;
+	(void)mutexId;
 }
 
-void I_wake_one_cond(I_cond *anchor)
+void I_WakeOneCond(I_Cond *anchor)
 {
 	(void)anchor;
 }
 
-void I_wake_all_cond(I_cond *anchor)
+void I_WakeAllCond(I_Cond *anchor)
 {
 	(void)anchor;
 }
+
+void *I_GetCurrentThread(void)
+{
+	return NULL;
+}
 #endif
+
+
+#endif // HAVE_THREADS

src/i_threads.h

@@ -1,6 +1,6 @@
 // SONIC ROBO BLAST 2 KART
 //-----------------------------------------------------------------------------
-// Copyright (C) 2020 by James R.
+// Copyright (C) 2020-2023 by James R.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -14,34 +14,46 @@
 #ifndef I_THREADS_H
 #define I_THREADS_H
 
+#include "doomtype.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef void (*I_thread_fn)(void *userdata);
+typedef void (*I_ThreadFn)(void *userdata);
 
-typedef void * I_mutex;
-typedef void * I_cond;
+typedef void * I_Mutex;
+typedef void * I_Cond;
 
-void      I_start_threads (void);
-void      I_stop_threads  (void);
+#ifdef __linux__
+typedef long unsigned int thread_handle_t;
+#else
+typedef void *thread_handle_t;
+#endif
 
-void      I_spawn_thread (const char *name, I_thread_fn, void *userdata);
+void      I_StartThreads (void);
+void      I_StopThreads  (void);
+
+FUNCWARNRV
+int       I_SpawnThread (const char *name, I_ThreadFn, void *userdata);
 
 /* check in your thread whether to return early */
-int       I_thread_is_stopped (void);
+int       I_ThreadIsStopped (void);
 
-void      I_lock_mutex      (I_mutex *);
-void      I_unlock_mutex    (I_mutex);
+void      I_LockMutex      (I_Mutex *);
+void      I_UnlockMutex    (I_Mutex);
 
-void      I_hold_cond       (I_cond *, I_mutex);
+void      I_HoldCond       (I_Cond *, I_Mutex);
 
-void      I_wake_one_cond   (I_cond *);
-void      I_wake_all_cond   (I_cond *);
+void      I_WakeOneCond   (I_Cond *);
+void      I_WakeAllCond   (I_Cond *);
+
+thread_handle_t I_GetCurrentThread(void);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif/*I_THREADS_H*/
+
 #endif/*HAVE_THREADS*/

src/k_hud.c

@@ -931,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
 
 //}
 
-static INT32 ITEM_X, ITEM_Y;	// Item Window
-static INT32 TIME_X, TIME_Y;	// Time Sticker
-static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-static INT32 SPDM_X, SPDM_Y;	// Speedometer
-static INT32 POSI_X, POSI_Y;	// Position Number
-static INT32 FACE_X, FACE_Y;	// Top-four Faces
-static INT32 STCD_X, STCD_Y;	// Starting countdown
-static INT32 CHEK_Y;			// CHECK graphic
-static INT32 MINI_X, MINI_Y;	// Minimap
-static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+INT32 ITEM_X, ITEM_Y;	// Item Window
+INT32 TIME_X, TIME_Y;	// Time Sticker
+INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+INT32 SPDM_X, SPDM_Y;	// Speedometer
+INT32 POSI_X, POSI_Y;	// Position Number
+INT32 FACE_X, FACE_Y;	// Top-four Faces
+INT32 STCD_X, STCD_Y;	// Starting countdown
+INT32 CHEK_Y;			// CHECK graphic
+INT32 MINI_X, MINI_Y;	// Minimap
+INT32 WANT_X, WANT_Y;	// Battle WANTED poster
 
 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-static INT32 ITEM2_X, ITEM2_Y;
-static INT32 LAPS2_X, LAPS2_Y;
-static INT32 POSI2_X, POSI2_Y;
+INT32 ITEM2_X, ITEM2_Y;
+INT32 LAPS2_X, LAPS2_Y;
+INT32 POSI2_X, POSI2_Y;
 
 static void K_initKartHUD(void)
 {
@@ -1415,6 +1415,8 @@ static void K_drawKartStats(void)
 				break;
 		}
 	}
+	else
+		spdoffset = 0;
 
 	if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
 		spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
@@ -3816,7 +3818,7 @@ static void K_drawKartMinimap(void)
 
 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap = NULL;
+			UINT8 *colormap;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3827,27 +3829,10 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;
 
-			if (mobj->color)
-			{
-				if (mobj->colorized)
-				{
-					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-				}
-				else
-				{
-					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
-
-					// special case if startcolor is not the default (160 / Green)
-					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
-					{
-						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
-					}
-					else
-					{
-						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
-					}
-				}
-			}
+			if (mobj->colorized)
+				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+			else
+				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
 
 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);

src/k_kart.c

@@ -660,22 +660,13 @@ INT32 K_GetSkinNum(player_t *player)
 
 //
 // returns the mobj skinnumber
-// accounts for localskins ?
+// accounts for localskins
 //
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
 {
 	return skin - K_GetSkinArray(local);
 }
 
-//
-// returns the mobj skinnumber
-// accounts for localskins
-//
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
-{
-	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
-}
-
 //
 // returns the players skinnumber
 // accounts for localskins
@@ -1489,6 +1480,7 @@ void K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2, boolean bounce, boolean solid)
 		fixed_t nx = FixedDiv(distx, dist);
 		fixed_t ny = FixedDiv(disty, dist);
 
+		dist = dist ? dist : 1;
 		distx = FixedMul(mobj1->radius+mobj2->radius, nx);
 		disty = FixedMul(mobj1->radius+mobj2->radius, ny);
 
@@ -2159,13 +2151,7 @@ static void K_GetKartBoostPower(player_t *player)
 		&& player->speed > 0
 		&& !player->spectator)
 	{
-		mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true);
-
-		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
-		// is to hide them if you are in saltyhop jump
-		if (dust && player->mo->salty.jump)
-			dust->flags2 |= MF2_DONTDRAW;
-
+		K_SpawnWipeoutTrail(player->mo, true);
 		if (leveltime % 6 == 0)
 			S_StartSound(player->mo, sfx_cdfm70);
 	}
@@ -3640,7 +3626,7 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 	P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
 }
 
-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 {
 	mobj_t *dust;
 	angle_t aoff;
@@ -3681,8 +3667,6 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 
 	if (translucent)
 		dust->flags2 |= MF2_SHADOW;
-
-	return dust;
 }
 
 //	K_DriftDustHandling
@@ -6183,13 +6167,6 @@ void K_KartUpdatePosition(player_t *player)
 						}
 					}
 
-					// the player should NOT be checked against themselves! lol
-					// otherwise prevcheck will effectively be halved
-					// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
-					// oh well
-					//if (player == &players[i])
-						//continue;
-
 					const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
 					const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);
 

src/k_kart.h

@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
 void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
 void K_SpawnBoostTrail(player_t *player);
 void K_SpawnSparkleTrail(mobj_t *mo);
-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
 void K_DriftDustHandling(mobj_t *spawner);
 void K_PuntMine(mobj_t *mine, mobj_t *punter);
 void K_DoSneaker(player_t *player, INT32 type);

src/lua_hooklib.c

@@ -199,7 +199,7 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
 
 FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
 {
-	mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
+	mobjtype_t   mobj_type = luaL_optnumber(L, 3, MT_NULL);
 
 	luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t");
 
@@ -296,7 +296,8 @@ struct Hook_State {
 	INT32        status;/* return status to calling function */
 	void       * userdata;
 	int          hook_type;
-	mobjtype_t   mobj_type;/* <NUMMOBJTYPES if mobj hook */
+	mobjtype_t   mobj_type;/* >0 if mobj hook */
+	boolean      force_mobj;// allows mobj_type equal 0
 	const char * string;/* used to fetch table, ran first if set */
 	int          top;/* index of last argument passed to hook */
 	int          id;/* id to fetch ref */
@@ -363,8 +364,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_hook
 		int default_status,
 		int hook_type
 ){
+	hook->force_mobj = false;
+
 	return init_hook_type(hook, default_status,
-			hook_type, NUMMOBJTYPES, NULL,
+			hook_type, 0, NULL,
 			hookIds[hook_type].numHooks);
 }
 
@@ -378,6 +381,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
 	const mobjtype_t mobj_type =
 		primary_mobj ? primary_mobj->type : NUMMOBJTYPES;
 
+	hook->force_mobj = true;
+
 	return init_hook_type(hook, default_status,
 			hook_type, mobj_type, NULL,
 			mobj_hook_available(hook_type, mobj_type));
@@ -390,8 +395,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_string_hook
 		int          hook_type,
 		const char * string
 ){
+	hook->force_mobj = false;
+
 	if (init_hook_type(hook, default_status,
-				hook_type, NUMMOBJTYPES, string,
+				hook_type, 0, string,
 				stringHooks[hook_type].ref))
 	{
 		lua_pushstring(gL, string);
@@ -407,7 +414,7 @@ FUNCINLINE static ATTRINLINE boolean prepare_hud_hook
 		int hook_type
 ){
 	return init_hook_type(hook, 0,
-			hook_type, NUMMOBJTYPES, NULL,
+			hook_type, 0, NULL,
 			hudHookIds[hook_type].numHooks);
 }
 
@@ -547,11 +554,14 @@ static int call_hooks
 	{
 		calls += call_string_hooks(hook);
 	}
-	else if (hook->mobj_type < NUMMOBJTYPES)
+	else if (hook->force_mobj)
 	{
 		/* call generic mobj hooks first */
 		calls += call_mobj_type_hooks(hook, MT_NULL);
-		calls += call_mobj_type_hooks(hook, hook->mobj_type);
+
+		if (hook->mobj_type < NUMMOBJTYPES)
+			calls += call_mobj_type_hooks(hook, hook->mobj_type);
+
 		ps_lua_mobjhooks.value.i += calls;
 	}
 	else
@@ -605,7 +615,7 @@ FUNCINLINE static ATTRINLINE void res_hud(Hook_State *hook)
 
 int LUA_HookMobj(mobj_t *mobj, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_mobj_hook(&hook, false, hook_type, mobj))
 	{
 		LUA_PushUserdata(gL, mobj, META_MOBJ);
@@ -616,7 +626,7 @@ int LUA_HookMobj(mobj_t *mobj, int hook_type)
 
 int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_mobj_hook(&hook, 0, hook_type, t1))
 	{
 		LUA_PushUserdata(gL, t1, META_MOBJ);
@@ -628,14 +638,14 @@ int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
 
 void LUA_HookVoid(int type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, type))
 		call_hooks(&hook, 0, res_none);
 }
 
 void LUA_HookInt(INT32 number, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, hook_type))
 	{
 		lua_pushinteger(gL, number);
@@ -645,7 +655,7 @@ void LUA_HookInt(INT32 number, int hook_type)
 
 /*void LUA_HookBool(boolean value, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, hook_type))
 	{
 		//lua_pushboolean(gL, value);
@@ -655,7 +665,7 @@ void LUA_HookInt(INT32 number, int hook_type)
 
 int LUA_HookPlayer(player_t *player, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, false, hook_type))
 	{
 		LUA_PushUserdata(gL, player, META_PLAYER);
@@ -666,7 +676,7 @@ int LUA_HookPlayer(player_t *player, int hook_type)
 
 int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, false, hook_type))
 	{
 		LUA_PushUserdata(gL, player, META_PLAYER);
@@ -685,7 +695,7 @@ int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
 
 void LUA_HookHUD(int hook_type, huddrawlist_h list)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hud_hook(&hook, hook_type))
 	{
 		LUA_SetHudHook(hook_type, list);
@@ -713,7 +723,7 @@ static void hook_think_frame(int type)
 	int hook_index = 0;
 	precise_t time_taken = 0;
 
-	Hook_State hook = {};
+	Hook_State hook;
 
 	const hook_t * map = &hookIds[type];
 	int k;
@@ -773,7 +783,7 @@ void LUA_HookPostThinkFrame(void)
 
 int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(TouchSpecial), special))
 	{
 		LUA_PushUserdata(gL, special, META_MOBJ);
@@ -792,7 +802,7 @@ static int damage_hook
 		int     hook_type,
 		Hook_Callback results_handler
 ){
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_mobj_hook(&hook, 0, hook_type, target))
 	{
 		LUA_PushUserdata(gL, target, META_MOBJ);
@@ -880,8 +890,8 @@ int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
 {
 	const char *skin = ((skin_t *)tails->skin)->name;
 
-	Hook_State hook = {};
-	BotAI_State botai = {};
+	Hook_State hook;
+	BotAI_State botai;
 
 	if (prepare_string_hook(&hook, false, STRING_HOOK(BotAI), skin))
 	{
@@ -901,7 +911,7 @@ int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
 
 void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_string_hook
 			(&hook, 0, STRING_HOOK(LinedefExecute), line->text))
 	{
@@ -914,7 +924,7 @@ void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
 
 int LUA_HookPlayerMsg(int source, int target, int flags, char *msg, int mute)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, false, HOOK(PlayerMsg)))
 	{
 		LUA_PushUserdata(gL, &players[source], META_PLAYER); // Source player
@@ -943,7 +953,7 @@ int LUA_HookPlayerMsg(int source, int target, int flags, char *msg, int mute)
 
 int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(HurtMsg), inflictor))
 	{
 		LUA_PushUserdata(gL, player, META_PLAYER);
@@ -957,7 +967,7 @@ int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source)
 void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save)
 {
 	const hook_t * map = &hookIds[HOOK(NetVars)];
-	Hook_State hook = {};
+	Hook_State hook;
 	/* this is a remarkable case where the stack isn't reset */
 	if (map->numHooks > 0)
 	{
@@ -987,7 +997,7 @@ void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save)
 
 void LUA_HookPlayerQuit(player_t *plr, int reason)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, HOOK(PlayerQuit)))
 	{
 		LUA_PushUserdata(gL, plr, META_PLAYER); // Player that quit
@@ -1050,7 +1060,7 @@ int LUA_HookMusicChange(const char *oldname, struct MusicChange *param)
 	const int type = HOOK(MusicChange);
 	const hook_t * map = &hookIds[type];
 
-	Hook_State hook = {};
+	Hook_State hook;
 
 	int k;
 
@@ -1086,7 +1096,7 @@ int LUA_HookMusicChange(const char *oldname, struct MusicChange *param)
 
 int LUA_HookMusicCredit(musicdef_t *musicdef)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, HOOK(MusicCredit)))
 	{
 		LUA_PushUserdata(gL, musicdef, META_MUSICDEF);
@@ -1104,7 +1114,7 @@ static int kartdamage_hook
 		int       hook_type,
 		Hook_Callback results_handler
 ){
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, hook_type))
 	{
 		LUA_PushUserdata(gL, player, META_PLAYER);
@@ -1153,7 +1163,7 @@ boolean LUA_HookPlayerExplode(player_t *player, mobj_t *inflictor, mobj_t *sourc
 
 void LUA_HookSetupVote(INT16 result[], INT16 maxresults, UINT8 gt, UINT8 secondgt)
 {
-	Hook_State hook = {};
+	Hook_State hook;
 	if (prepare_hook(&hook, 0, HOOK(SetupVote)))
 	{
 		// { 0, 0, 0, 0, }

src/lua_maplib.c

@@ -1506,6 +1506,7 @@ enum mapheaderinfo_e
 	mapheaderinfo_saveoverride,
 	mapheaderinfo_levelflags,
 	mapheaderinfo_menuflags,
+	//mapheaderinfo_automap,
 	mapheaderinfo_mobj_scale,
 };
 
@@ -1541,6 +1542,7 @@ static const char *const mapheaderinfo_opt[] = {
 	"saveoverride",
 	"levelflags",
 	"menuflags",
+	//"automap",
 	"mobj_scale",
 	NULL,
 };
@@ -1582,11 +1584,10 @@ static int mapheaderinfo_get(lua_State *L)
 		lua_pushinteger(L, header->muspos);
 		break;
 	case mapheaderinfo_musinterfadeout:
-		lua_pushinteger(L, 0); // unused
+		lua_pushinteger(L, header->musinterfadeout);
 		break;
 	case mapheaderinfo_musintername:
-		// uhh psure its fine to just push nil instead of empty string?
-		lua_pushstring(L, NULL);
+		lua_pushstring(L, header->musintername);
 		break;
 	case mapheaderinfo_forcecharacter:
 		lua_pushstring(L, header->forcecharacter);
@@ -1640,10 +1641,10 @@ static int mapheaderinfo_get(lua_State *L)
 		lua_pushinteger(L, header->levelselect);
 		break;
 	case mapheaderinfo_bonustype:
-		lua_pushinteger(L, 0); // unused
+		lua_pushinteger(L, header->bonustype);
 		break;
 	case mapheaderinfo_saveoverride:
-		lua_pushinteger(L, SAVE_DEFAULT); // unused
+		lua_pushinteger(L, header->saveoverride);
 		break;
 	case mapheaderinfo_levelflags:
 		lua_pushinteger(L, header->levelflags);
@@ -1651,9 +1652,13 @@ static int mapheaderinfo_get(lua_State *L)
 	case mapheaderinfo_menuflags:
 		lua_pushinteger(L, header->menuflags);
 		break;
+	/*case mapheaderinfo_automap:
+		lua_pushstring(L, header->selectheading);
+		break;*/
 	case mapheaderinfo_mobj_scale:
 		lua_pushfixed(L, header->mobj_scale);
 		break;
+	// TODO add support for reading numGradedMares and grades
 	default:
 	{
 		// Read custom vars now

src/lzf.h

@@ -13,10 +13,6 @@
 #define LZF_H
 #include <stdio.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /***********************************************************************
 **
 **	lzf -- an extremely fast/free compression/decompression-method
@@ -75,9 +71,5 @@ size_t
 lzf_decompress (const void *const in_data,  size_t in_len,
                 void             *out_data, size_t out_len);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif
 

src/m_anigif.c

@@ -556,7 +556,7 @@ static void GIF_framewrite(void)
 		}
 		else if (gif_dynamicdelay ==(UINT8) 1)
 		{
-			float delayf = ceilf(100.0f/NEWTICRATE);
+			float delayf = ceil(100.0f/NEWTICRATE);
 
 			delay = (UINT16)((I_GetPreciseTime() - gif_prevframetime)) / (I_GetPrecisePrecision() / 1000000) /10/1000;
 

src/m_cond.c

@@ -479,13 +479,32 @@ UINT8 M_CheckLevelEmblems(void)
 	// Update Score, Time, Rings emblems
 	for (i = 0; i < numemblems; ++i)
 	{
-		// Requires time on map <= x
-		if (emblemlocations[i].type != ET_TIME || emblemlocations[i].collected)
+		if (emblemlocations[i].type <= ET_SKIN || emblemlocations[i].collected)
 			continue;
 
 		levelnum = emblemlocations[i].level;
 		valToReach = emblemlocations[i].var;
-		res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
+
+		switch (emblemlocations[i].type)
+		{
+			/*case ET_SCORE: // Requires score on map >= x
+				res = (G_GetBestScore(levelnum) >= (unsigned)valToReach);
+				break;*/
+			case ET_TIME: // Requires time on map <= x
+				res = (G_GetBestTime(levelnum) <= (unsigned)valToReach);
+				break;
+			/*case ET_RINGS: // Requires rings on map >= x
+				res = (G_GetBestRings(levelnum) >= valToReach);
+				break;
+			case ET_NGRADE: // Requires NiGHTS grade on map >= x
+				res = (G_GetBestNightsGrade(levelnum, 0) >= valToReach);
+				break;
+			case ET_NTIME: // Requires NiGHTS time on map <= x
+				res = (G_GetBestNightsTime(levelnum, 0) <= (unsigned)valToReach);
+				break;*/
+			default: // unreachable but shuts the compiler up.
+				continue;
+		}
 
 		emblemlocations[i].collected = res;
 		if (res)

src/m_cond.h

@@ -27,11 +27,21 @@ typedef enum
 	UC_MATCHESPLAYED,   // SRB2Kart: MATCHESPLAYED [x played]
 	UC_GAMECLEAR,       // GAMECLEAR <x times>
 	UC_ALLEMERALDS,     // ALLEMERALDS <x times>
+	//UC_ULTIMATECLEAR,   // ULTIMATECLEAR <x times>
+	//UC_OVERALLSCORE,    // OVERALLSCORE [score to beat]
 	UC_OVERALLTIME,     // OVERALLTIME [time to beat, tics]
+	//UC_OVERALLRINGS,    // OVERALLRINGS [rings to beat]
 	UC_MAPVISITED,      // MAPVISITED [map number]
 	UC_MAPBEATEN,       // MAPBEATEN [map number]
 	UC_MAPALLEMERALDS,  // MAPALLEMERALDS [map number]
+	//UC_MAPULTIMATE,     // MAPULTIMATE [map number]
+	//UC_MAPPERFECT,      // MAPPERFECT [map number]
+	//UC_MAPSCORE,        // MAPSCORE [map number] [score to beat]
 	UC_MAPTIME,         // MAPTIME [map number] [time to beat, tics]
+	//UC_MAPRINGS,        // MAPRINGS [map number] [rings to beat]
+	//UC_NIGHTSSCORE,     // NIGHTSSCORE [map number] <mare, omit or "0" for overall> [score to beat]
+	//UC_NIGHTSTIME,      // NIGHTSTIME [map number] <mare, omit "0" overall> [time to beat, tics]
+	//UC_NIGHTSGRADE,     // NIGHTSGRADE [map number] <mare, omit "0" overall> [grade]
 	UC_TRIGGER,         // TRIGGER [trigger number]
 	UC_TOTALEMBLEMS,    // TOTALEMBLEMS [number of emblems]
 	UC_EMBLEM,          // EMBLEM [emblem number]

src/m_emotes.cpp

@@ -278,7 +278,7 @@ void M_DrawScaledEmote(fixed_t x, fixed_t y, fixed_t scale, emote_t *emote, INT3
 static void Command_ListEmotes_f(void)
 {
 	const int EMOTES_PER_PAGE = 24;
-	const int NUMPAGES = emotes.size()/EMOTES_PER_PAGE + (emotes.size() % EMOTES_PER_PAGE != 0 ? 1 : 0);
+	const int NUMPAGES = std::max<int>(emotes.size()/EMOTES_PER_PAGE, 1);
 	int page = 1;
 
 	if (COM_Argc() > 1)

src/m_menu.c

@@ -142,7 +142,7 @@ typedef enum
 } text_enum;
 
 #ifdef HAVE_THREADS
-I_mutex m_menu_mutex;
+I_Mutex m_menu_mutex;
 #endif
 
 M_waiting_mode_t m_waiting_mode = M_NOT_WAITING;
@@ -186,8 +186,8 @@ static INT16 itemOn = 1; // menu item skull is on, Hack by Tails 09-18-2002
 static INT16 skullAnimCounter = 10; // skull animation counter
 static boolean interpTimerHackAllow = 0;
 
-static UINT8 setupcontrolplayer;
-static INT32 (*setupcontrols)[2];  // pointer to the gamecontrols of the player being edited
+static  UINT8 setupcontrolplayer;
+static  INT32   (*setupcontrols)[2];  // pointer to the gamecontrols of the player being edited
 
 // shhh... what am I doing... nooooo!
 static INT32 vidm_testingmode = 0;
@@ -201,8 +201,8 @@ static char setupm_ip[64];
 static textinput_t setupm_input_ip;
 
 
-static fixed_t  multi_tics;
-static state_t *multi_state;
+static fixed_t    multi_tics;
+static state_t   *multi_state;
 
 // this is set before entering the MultiPlayer setup menu,
 // for either player 1 or 2
@@ -1024,9 +1024,9 @@ boolean M_Responder(event_t *ev)
 				//case KEY_JOY1 + 2:
 				ch = KEY_ENTER;
 				break;
-			/*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now.
-				ch = 'n';
-				break;*/
+				/*case KEY_JOY1 + 3: // Brake can function as 'n' for message boxes now.
+					ch = 'n';
+					break;*/
 			case KEY_MOUSE1 + 1:
 				//case KEY_JOY1 + 1:
 				ch = KEY_BACKSPACE;
@@ -1305,21 +1305,12 @@ boolean M_Responder(event_t *ev)
 	{
 		playback_last_menu_interaction_leveltime = leveltime;
 		// Flip left/right with up/down for the playback menu, since it's a horizontal icon row.
-
 		switch (ch)
 		{
-			case KEY_LEFTARROW:
-				ch = KEY_UPARROW;
-				break;
-			case KEY_UPARROW:
-				ch = KEY_RIGHTARROW;
-				break;
-			case KEY_RIGHTARROW:
-				ch = KEY_DOWNARROW;
-				break;
-			case KEY_DOWNARROW:
-				ch = KEY_LEFTARROW;
-				break;
+			case KEY_LEFTARROW: ch = KEY_UPARROW; break;
+			case KEY_UPARROW: ch = KEY_RIGHTARROW; break;
+			case KEY_RIGHTARROW: ch = KEY_DOWNARROW; break;
+			case KEY_DOWNARROW: ch = KEY_LEFTARROW; break;
 
 			// arbitrary keyboard shortcuts because fuck you
 
@@ -1370,8 +1361,7 @@ boolean M_Responder(event_t *ev)
 					G_AdjustView(4, 1, true);
 				break;
 
-			default:
-				break;
+			default: break;
 		}
 	}
 
@@ -1496,7 +1486,6 @@ boolean M_Responder(event_t *ev)
 			}
 
 			return false;
-			break;
 
 		default:
 			CON_Responder(ev);
@@ -1978,7 +1967,7 @@ void M_Ticker(void)
 	}
 
 #if defined (MASTERSERVER) && defined (HAVE_THREADS)
-	I_lock_mutex(&ms_ServerList_mutex);
+	I_LockMutex(&ms_ServerList_mutex);
 	{
 		if (ms_ServerList)
 		{
@@ -1987,7 +1976,7 @@ void M_Ticker(void)
 			ms_ServerList = NULL;
 		}
 	}
-	I_unlock_mutex(ms_ServerList_mutex);
+	I_UnlockMutex(ms_ServerList_mutex);
 #endif
 }
 
@@ -2075,6 +2064,7 @@ void M_Init(void)
 			OP_OpenGLOptionsMenu[op_gl_shader].status = IT_GRAYEDOUT;
 			OP_OpenGLOptionsMenu[op_gl_lightdither].status = IT_GRAYEDOUT;
 			OP_OpenGLOptionsMenu[op_gl_palrender].status = IT_GRAYEDOUT;
+			OP_OpenGLOptionsMenu[op_gl_flashpal].status = IT_GRAYEDOUT;
 
 			OP_ExpOptionsMenu[op_exp_paldepth].status = IT_GRAYEDOUT;
 		}
@@ -2946,7 +2936,7 @@ static void M_PrepareLevelSelect(void)
 boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt)
 {
 	// invalid mapnum
-	if (mapnum < -1 || mapnum >= NUMMAPS)
+	if (mapnum < -1)
 		return false;
 
 	// Random map!
@@ -4024,18 +4014,18 @@ size_t demolist_all_size = 0;
 boolean replaynamesloaded = false;
 
 #ifdef HAVE_THREADS
-I_mutex replayquerymutex;
+I_Mutex replayquerymutex;
 
-// I_In_Exiting_Signal_Handler is an evil hack
+// g_in_exiting_signal_handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_search_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&replayquerymutex); }
-#  define Unlock_search_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(replayquerymutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_search_state()    if (!g_in_exiting_signal_handler) { I_LockMutex(&replayquerymutex); }
+#  define Unlock_search_state()  if (!g_in_exiting_signal_handler) { I_UnlockMutex(replayquerymutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_search_state()
 #  define Unlock_search_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/
 
 
 #define MAXREPLAYQUERY 37
@@ -4098,7 +4088,10 @@ static void LoadReplayNames(void)
 	Unlock_search_state();
 
 #ifdef HAVE_THREADS
-	I_spawn_thread("replay-names-load", ReplayNamesLoadThread, replaydirpath);
+	if (!I_SpawnThread("replay-names-load", ReplayNamesLoadThread, replaydirpath))
+	{
+		free(replaydirpath);
+	}
 #else
 	ReplayNamesLoadThread(replaydirpath);
 #endif
@@ -4123,9 +4116,6 @@ static void AddCheckedReplay(void)
 // Check up to maxnum replays if they match with query
 static void M_HutCheckReplays(size_t maxnum)
 {
-	// Stripped of color codes
-	char demo_title[sizeof(demolist_all[0].title)];
-
 	if (!replaynamesloaded)
 		return;
 
@@ -4158,9 +4148,7 @@ static void M_HutCheckReplays(size_t maxnum)
 			case MD_NOTLOADED:
 			case MD_OUTDATED:
 			case MD_LOADED:
-				StripColors(demo_title, demolist_all[replayquerycheck].title, sizeof(demo_title));
-
-				if (demolist_all[replayquerycheck].title[0] && strcasestr(demo_title, replayqueryinput.buffer) != NULL)
+				if (demolist_all[replayquerycheck].title[0] && strcasestr(demolist_all[replayquerycheck].title, replayqueryinput.buffer) != NULL)
 					AddCheckedReplay(); // It matches, add it!
 				else
 					replayquerycheck++; // Doesn't match, moving on...
@@ -4920,7 +4908,6 @@ static void M_HutStartReplay(INT32 choice)
 	demo.loadfiles = (itemOn == 0);
 	demo.ignorefiles = (itemOn != 0);
 
-	CONS_Printf(M_GetText("Playing back demo '%s'.\n"), demolist[dir_on[menudepthleft]].filepath);
 	G_DoPlayDemo(demolist[dir_on[menudepthleft]].filepath);
 }
 
@@ -5538,6 +5525,7 @@ static void M_DrawChecklist(void)
 
 		if (conditionSets[unlockables[i].conditionset - 1].numconditions)
 		{
+			c = 0;
 			lastid = -1;
 
 			for (c = 0; c < conditionSets[unlockables[i].conditionset - 1].numconditions; c++)
@@ -5697,6 +5685,9 @@ static void M_DrawMusicTest(void)
 {
 	INT32 x, y, i;
 
+	x = 90<<FRACBITS;
+	y = (BASEVIDHEIGHT-32)<<FRACBITS;
+
 	y = (BASEVIDWIDTH-vid.scaledwidth)/2;
 
 	V_DrawFill(y-1, 20, vid.scaledwidth+1, 24, 239);
@@ -6482,7 +6473,7 @@ static void M_ChooseTimeAttack(INT32 choice)
 static void M_HandleStaffReplay(INT32 choice)
 {
 	boolean exitmenu = false; // exit to previous menu
-	lumpnum_t l = W_CheckNumForName(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
+	lumpnum_t l = W_CheckNumForName(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value));
 
 	switch (choice)
 	{
@@ -6512,7 +6503,7 @@ static void M_HandleStaffReplay(INT32 choice)
 			M_ClearMenus(true);
 			modeattacking = ATTACKING_RECORD;
 			demo.loadfiles = false; demo.ignorefiles = true; // Just assume that record attack replays have the files needed
-			G_DoPlayDemo(va("%sS%02u", G_BuildMapName(cv_nextmap.value), cv_dummystaff.value));
+			G_DoPlayDemo(va("%sS%02u",G_BuildMapName(cv_nextmap.value),cv_dummystaff.value));
 			break;
 		default:
 			break;
@@ -6696,11 +6687,11 @@ static void M_EndGame(INT32 choice)
 void M_SetWaitingMode(int mode)
 {
 #ifdef HAVE_THREADS
-	I_lock_mutex(&m_menu_mutex);
+	I_LockMutex(&m_menu_mutex);
 #endif
 	m_waiting_mode = mode;
 #ifdef HAVE_THREADS
-	I_unlock_mutex(m_menu_mutex);
+	I_UnlockMutex(m_menu_mutex);
 #endif
 }
 
@@ -6709,11 +6700,11 @@ int M_GetWaitingMode(void)
 	int mode;
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&m_menu_mutex);
+	I_LockMutex(&m_menu_mutex);
 #endif
 	mode = m_waiting_mode;
 #ifdef HAVE_THREADS
-	I_unlock_mutex(m_menu_mutex);
+	I_UnlockMutex(m_menu_mutex);
 #endif
 
 	return mode;
@@ -6725,20 +6716,23 @@ static void Spawn_masterserver_thread(const char *name, void (*thread)(int*))
 {
 	int *id = malloc(sizeof *id);
 
-	I_lock_mutex(&ms_QueryId_mutex);
+	I_LockMutex(&ms_QueryId_mutex);
 	*id = ms_QueryId;
-	I_unlock_mutex(ms_QueryId_mutex);
+	I_UnlockMutex(ms_QueryId_mutex);
 
-	I_spawn_thread(name, (I_thread_fn)thread, id);
+	if (!I_SpawnThread(name, (I_ThreadFn)thread, id))
+	{
+		free(id);
+	}
 }
 
 static int Same_instance(int id)
 {
 	int okay;
 
-	I_lock_mutex(&ms_QueryId_mutex);
+	I_LockMutex(&ms_QueryId_mutex);
 	okay = ( id == ms_QueryId );
-	I_unlock_mutex(ms_QueryId_mutex);
+	I_UnlockMutex(ms_QueryId_mutex);
 
 	return okay;
 }
@@ -6767,9 +6761,9 @@ static void Fetch_servers_thread(int *id)
 			M_SetWaitingMode(M_NOT_WAITING);
 
 #ifdef HAVE_THREADS
-			I_lock_mutex(&ms_ServerList_mutex);
+			I_LockMutex(&ms_ServerList_mutex);
 			ms_ServerList = server_list;
-			I_unlock_mutex(ms_ServerList_mutex);
+			I_UnlockMutex(ms_ServerList_mutex);
 #else
 			CL_QueryServerList(server_list);
 			free(server_list);
@@ -6802,7 +6796,7 @@ static void M_SearchServerList(void)
 	serverlistsearchedcount = 0;
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&ms_ServerList_mutex);
+	I_LockMutex(&ms_ServerList_mutex);
 #endif
 
 	for (UINT32 i = 0; i < serverlistcount; ++i)
@@ -6813,7 +6807,7 @@ static void M_SearchServerList(void)
 	}
 
 #ifdef HAVE_THREADS
-	I_unlock_mutex(ms_ServerList_mutex);
+	I_UnlockMutex(ms_ServerList_mutex);
 #endif
 
 	if (menuinput.length > 0)
@@ -7179,11 +7173,11 @@ static void M_CheckMODVersion(int id)
 	{
 		sprintf(updatestring, UPDATE_ALERT_STRING, VERSIONSTRING, updatecheck);
 #ifdef HAVE_THREADS
-		I_lock_mutex(&m_menu_mutex);
+		I_LockMutex(&m_menu_mutex);
 #endif
 		M_StartMessage(updatestring, NULL, MM_NOTHING);
 #ifdef HAVE_THREADS
-		I_unlock_mutex(m_menu_mutex);
+		I_UnlockMutex(m_menu_mutex);
 #endif
 	}
 }
@@ -7229,13 +7223,13 @@ static void M_ConnectMenu(INT32 choice)
 	itemOn = 0;
 
 #if defined (MASTERSERVER) && defined (HAVE_THREADS)
-	I_lock_mutex(&ms_QueryId_mutex);
+	I_LockMutex(&ms_QueryId_mutex);
 	{
 		ms_QueryId++;
 	}
-	I_unlock_mutex(ms_QueryId_mutex);
+	I_UnlockMutex(ms_QueryId_mutex);
 
-	I_lock_mutex(&ms_ServerList_mutex);
+	I_LockMutex(&ms_ServerList_mutex);
 	{
 		if (ms_ServerList)
 		{
@@ -7243,7 +7237,7 @@ static void M_ConnectMenu(INT32 choice)
 			ms_ServerList = NULL;
 		}
 	}
-	I_unlock_mutex(ms_ServerList_mutex);
+	I_UnlockMutex(ms_ServerList_mutex);
 
 #ifdef UPDATE_ALERT
 	Spawn_masterserver_thread("check-new-version", Check_new_version_thread);
@@ -7956,7 +7950,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	patch_t *statbg  = (patch_t *)W_CachePatchName("K_STATBG", PU_PATCH);
 	patch_t *statlr  = (patch_t *)W_CachePatchName("K_STATLR", PU_PATCH);
 	patch_t *statud  = (patch_t *)W_CachePatchName("K_STATUD", PU_PATCH);
-	patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0" , PU_PATCH);
+	patch_t *statdot = (patch_t *)W_CachePatchName("K_SDOT0", PU_PATCH);
 	patch_t *patch;
 	UINT8 frame;
 	UINT8 speed;
@@ -8012,9 +8006,14 @@ static void M_DrawSetupMultiPlayerMenu(void)
 #define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
 #define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
 
+			statoffset = 0;
 			tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0);
 			st = V_StringWidth(GETSELECTEDSKINNAME, 0);
 
+			INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
+			speed = skins[selectedskin].kartspeed;
+			weight = skins[selectedskin].kartweight;
+
 			V_DrawString((mx+(tw/2)) - (st/2), my + 37,
 				((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
 				GETSELECTEDSKINNAME);
@@ -10057,6 +10056,7 @@ static void M_DrawVideoMode(void)
 			va("Wait %d second%s", testtime, (testtime > 1) ? "s" : ""));
 		M_CentreText(OP_VideoModeDef.y + 158,
 			"or press ESC to return");
+
 	}
 	else
 	{

src/m_menu.h

@@ -215,7 +215,7 @@ void M_SetupNextMenu(menu_t *menudef);
 void M_ClearMenus(boolean callexitmenufunc);
 
 #ifdef HAVE_THREADS
-extern I_mutex m_menu_mutex;
+extern I_Mutex m_menu_mutex;
 #endif
 
 extern menu_t *currentMenu;

src/m_menudefs.c

@@ -986,7 +986,7 @@ static const char* OP_ExpTooltips[] =
 	"Skips rendering frames if game logic takes too long\npreventing gameplay issues during performance drops.", // idk im shit as describing things
 	"Different methods of scaling the votescreen backgrounds.",
 #ifdef HWRENDER
-	"Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!"
+	"Should the game do Screen Textures? Provides a good boost to frames\nat the cost of some visual effects not working when disabled.",
 #ifdef USE_FBO_OGL
 	"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.",
 #endif
@@ -1023,6 +1023,8 @@ static menuitem_t OP_OpenGLOptionsMenu[] =
 	{IT_STRING | IT_CVAR,	NULL, "Fallback Player 3D Model",	&cv_glfallbackplayermodel,	20},
 	{IT_STRING | IT_CVAR,	NULL, "Shaders",					&cv_glshaders,				25},
 	{IT_STRING | IT_CVAR,	NULL, "Palette Rendering",			&cv_glpaletterendering,		30},
+	{IT_STRING | IT_CVAR,   NULL, "Palette Rendering Flashpals",&cv_glflashpal,				35},
+	//{IT_STRING | IT_CVAR, 	NULL, "Min Shader Brightness", 		&cv_glsecbright,			40},
 
 	{IT_STRING | IT_CVAR,	NULL, "Texture Quality",			&cv_gltexturedepth,			45},
 	{IT_STRING | IT_CVAR,	NULL, "Texture Filter",				&cv_glfiltermode,			50},
@@ -1043,6 +1045,7 @@ static const char* OP_OpenGLTooltips[] =
 	"Fallback 3D model for characters that don't have any.",
 	"Graphical Shaders.",
 	"Recreates the look of software mode.",
+	"Flash palettes for palette rendering.",
 	"Bit-depth of textures.",
 	"Filter to use on textures.",
 	"Anisotropic filtering.",
@@ -1061,6 +1064,7 @@ enum
 	op_gl_falbckmdls,
 	op_gl_shader,
 	op_gl_palrender,
+	op_gl_flashpal,
 	op_gl_scrdepth,
 	op_gl_filter,
 	op_gl_anis,
@@ -1640,25 +1644,29 @@ static menuitem_t OP_AccessibilityMenu[] =
 
 	{IT_STRING|IT_CVAR,                NULL,   "Minimum Sector Brightness",      &cv_secbright,          45},
 
-	{IT_STRING|IT_CVAR,                NULL,   "Water Surface Ripples",          &cv_ripplewater,        50},
+#ifdef HWRENDER
+	{IT_STRING|IT_CVAR,                NULL,   "Screen Textures",                &cv_glscreentextures,   50},
+#endif
 
-	{IT_STRING|IT_CVAR,                NULL,   "Fade Players near Camera",       &cv_playerfade,         55},
+	{IT_STRING|IT_CVAR,                NULL,   "Water Surface Ripples",          &cv_ripplewater,        55},
 
-	{IT_STRING|IT_CVAR,                NULL,   "Quake Screenshakes",             &cv_screenquake,        60},
+	{IT_STRING|IT_CVAR,                NULL,   "Fade Players near Camera",       &cv_playerfade,         60},
 
-	{IT_CALL|IT_STRING,                NULL,   "Camera Options...",              M_CameraMenu,           65},
+	{IT_STRING|IT_CVAR,                NULL,   "Quake Screenshakes",             &cv_screenquake,        65},
 
-	{IT_HEADER, NULL, "Audio", NULL, 75},
+	{IT_CALL|IT_STRING,                NULL,   "Camera Options...",              M_CameraMenu,           70},
 
-	{IT_STRING|IT_CVAR,                NULL,   "Reverse L/R Channels",           &stereoreverse,         85},
-	{IT_STRING|IT_CVAR,                NULL,   "Same Sound Limit",               &cv_samesoundlimit,     90},
+	{IT_HEADER, NULL, "Audio", NULL, 80},
 
-	{IT_HEADER, NULL, "Controls", NULL, 100},
+	{IT_STRING|IT_CVAR,                NULL,   "Reverse L/R Channels",           &stereoreverse,         90},
+	{IT_STRING|IT_CVAR,                NULL,   "Same Sound Limit",               &cv_samesoundlimit,     95},
 
-	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P1)",    &cv_autoaccel[0],       110},
-	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P2)",    &cv_autoaccel[1],       115},
-	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P3)",    &cv_autoaccel[2],       120},
-	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P4)",    &cv_autoaccel[3],       125},
+	{IT_HEADER, NULL, "Controls", NULL, 105},
+
+	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P1)",    &cv_autoaccel[0],       115},
+	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P2)",    &cv_autoaccel[1],       120},
+	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P3)",    &cv_autoaccel[2],       125},
+	{IT_STRING|IT_CVAR,                NULL,   "Automatic Acceleration (P4)",    &cv_autoaccel[3],       130},
 };
 
 static const char* OP_AccessibilityTooltips[] =
@@ -1671,6 +1679,9 @@ static const char* OP_AccessibilityTooltips[] =
 	"Reduces or disables certain effects players might be sensitive to\nSuch as flashing, flickering, certain screen effects and more.",
 	"Disables the flicker effect on Midnight Channel.",
 	"Sets minimum sector brightness, useful for dark areas",
+#ifdef HWRENDER
+	"Disabling Screen Textures will disable the Underwater and Heat screen effects.",
+#endif
 	"Toggles the ripple effect on water surfaces",
 	"Fades other Players that are close to the camera in and out",
 	"Toggles the screen shake effect during Earthquakes",
@@ -2770,5 +2781,6 @@ void M_UpdateOGLMenu(void)
 	OP_OpenGLOptionsMenu[op_gl_lightdither].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
 
 	OP_OpenGLOptionsMenu[op_gl_palrender].status = (cv_glscreentextures.value != 2 || !HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
+	OP_OpenGLOptionsMenu[op_gl_flashpal].status = (!HWR_ShouldUsePaletteRendering()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
 }
 #endif

src/m_misc.c

@@ -788,10 +788,10 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	else
 		snprintf(locationtxt, 40, "Unknown");
 
-	memset(png_infotext, 0x00, sizeof(png_infotext));
+	memset(png_infotext,0x00,sizeof (png_infotext));
 
 	for (i = 0; i < SRB2PNGTXT; i++)
-		png_infotext[i].key = keytxt[i];
+		png_infotext[i].key  = keytxt[i];
 
 	png_infotext[0].text = titletxt;
 	if (movie)
@@ -804,15 +804,9 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
 	png_infotext[5].text = locationtxt;
 	png_infotext[6].text = interfacetxt;
 	png_infotext[7].text = rendermodetxt;
-	strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
-	ctrevision[sizeof(ctrevision)-1] = '\0';
-	png_infotext[8].text = ctrevision;
-	strncpy(ctdate, compdate, sizeof(ctdate)-1);
-	ctdate[sizeof(ctdate)-1] = '\0';
-	png_infotext[9].text = ctdate;
-	strncpy(cttime, comptime, sizeof(cttime)-1);
-	cttime[sizeof(cttime)-1] = '\0';
-	png_infotext[10].text = cttime;
+	png_infotext[8].text = strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
+	png_infotext[9].text = strncpy(ctdate, compdate, sizeof(ctdate)-1);
+	png_infotext[10].text = strncpy(cttime, comptime, sizeof(cttime)-1);
 
 	png_set_text(png_ptr, png_info_ptr, png_infotext, SRB2PNGTXT);
 #undef SRB2PNGTXT
@@ -1460,9 +1454,9 @@ INT32 axtoi(const char *hexStg)
 
 void CopyCaretColors(char *p, const char *s, int n)
 {
-	gconst char *t;
-	int          m;
-	int          c;
+	char *t;
+	int   m;
+	int   c;
 
 	if (!n)
 		return;
@@ -1570,7 +1564,6 @@ char *M_GetToken(const char *inputString)
 	{
 		startPos = endPos;
 	}
-
 	if (stringToUse == NULL)
 		return NULL;
 
@@ -1641,8 +1634,7 @@ char *M_GetToken(const char *inputString)
 	}
 
 	// If the end of the string is reached, no token is to be read
-	if (startPos == stringLength)
-	{
+	if (startPos == stringLength) {
 		endPos = stringLength;
 		return NULL;
 	}
@@ -1652,7 +1644,7 @@ char *M_GetToken(const char *inputString)
 			|| stringToUse[startPos] == '}')
 	{
 		endPos = startPos + 1;
-		texturesToken = (char *)Z_Malloc(2*sizeof(char), PU_STATIC, NULL);
+		texturesToken = (char *)Z_Malloc(2*sizeof(char),PU_STATIC,NULL);
 		texturesToken[0] = stringToUse[startPos];
 		texturesToken[1] = '\0';
 		return texturesToken;
@@ -1863,10 +1855,8 @@ int M_PathParts(const char *path)
 	int n;
 	const char *p;
 	const char *t;
-
 	if (path == NULL)
 		return 0;
-
 	for (n = 0, p = path ;; ++n)
 	{
 		t = p;
@@ -1879,7 +1869,6 @@ int M_PathParts(const char *path)
 			break;
 		}
 	}
-
 	return n;
 }
 
@@ -1922,9 +1911,7 @@ void M_MkdirEachUntil(const char *cpath, int start, int end, int mode)
 		if (!( p = strchr(p, PATHSEP[0]) ))
 			return;
 	}
-
 	p += strspn(p, PATHSEP);
-
 	for (;;)
 	{
 		if (end > 0 && !--end)
@@ -1969,22 +1956,6 @@ UINT32 FNV1a_Hash(const char *message, size_t size)
 	return hash;
 }
 
-// Behaves like the old quickncasehash
-// Stops either if it encounters null terminator
-// or reaches size
-UINT32 FNV1a_QuickCaseHash(const char *message, size_t size)
-{
-	UINT32 hash = FNV1A_OFFSET_BASIS;
-
-	for (size_t i = 0; i < size && message[i]; i++)
-	{
-		hash ^= tolower(message[i]);
-		hash *= FNV1A_PRIME;
-	}
-
-	return hash;
-}
-
 UINT32 FNV1a_HashString(const char *message)
 {
 	UINT32 hash = FNV1A_OFFSET_BASIS;

src/m_misc.h

@@ -123,7 +123,6 @@ FUNCMATH UINT8 M_CountBits(UINT32 num, UINT8 size);
 
 // Hashes some message using FNV-1a
 UINT32 FNV1a_Hash(const char *message, size_t size);
-UINT32 FNV1a_QuickCaseHash(const char *message, size_t size);
 UINT32 FNV1a_HashString(const char *message);
 UINT32 FNV1a_HashLowercaseString(const char *message);
 

src/m_textinput.c

@@ -256,7 +256,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
 		return true;
 	}
 
-	if (ctrldown && (cv_keyboardlayout.value != 3 || (cv_keyboardlayout.value == 3 && !altdown)))
+	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
 	{
 		if (key == 'x' || key == 'X')
 		{
@@ -392,7 +392,7 @@ static boolean M_TextInputHandleBase(textinput_t *input, INT32 key, boolean emot
 		key = '/';
 
 	// same capslock code as hu_stuff.c's HU_responder. Check there for details.
-	key = CON_ShiftChar(key);
+	key = cv_keyboardlayout.value == 3 ? CON_ShitAndAltGrChar(key) : CON_ShiftChar(key);
 
 	// enter a char into the command prompt
 	if (key < 32 || key > 127)

src/md5.h

@@ -16,10 +16,6 @@
 #ifndef _MD5_H
 #define _MD5_H 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include <stdio.h>
 
 #if defined (HAVE_LIMITS_H) || (defined (_LIBC) && _LIBC) || defined (_WIN32)
@@ -56,8 +52,4 @@ int md5_stream(FILE *stream, void *resblock) THROWFUNC;
 	digest.  */
 extern void *md5_buffer(const char *buffer, size_t len, void *resblock) THROWFUNC;
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif /* md5.h */

src/mserv.c

@@ -41,11 +41,11 @@ static time_t  MSLastPing;
 static char *MSRules;
 
 #ifdef HAVE_THREADS
-static I_mutex MSMutex;
-static I_cond  MSCond;
+static I_Mutex MSMutex;
+static I_Cond  MSCond;
 
-#  define Lock_state()   I_lock_mutex  (&MSMutex)
-#  define Unlock_state() I_unlock_mutex (MSMutex)
+#  define Lock_state()   I_LockMutex  (&MSMutex)
+#  define Unlock_state() I_UnlockMutex (MSMutex)
 #else/*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
@@ -90,10 +90,10 @@ consvar_t cv_masterserver_nagattempts = {"masterserver_nagattempts", "5", CV_SAV
 
 #if defined (MASTERSERVER) && defined (HAVE_THREADS)
 int           ms_QueryId = 0;
-I_mutex       ms_QueryId_mutex;
+I_Mutex       ms_QueryId_mutex;
 
 msg_server_t *ms_ServerList = NULL;
-I_mutex       ms_ServerList_mutex;
+I_Mutex       ms_ServerList_mutex;
 #endif
 
 UINT16 current_port = 0;
@@ -129,11 +129,11 @@ void AddMServCommands(void)
 static void WarnGUI (void)
 {
 #ifdef HAVE_THREADS
-	I_lock_mutex(&m_menu_mutex);
+	I_LockMutex(&m_menu_mutex);
 #endif
 	M_PopupMasterServerConnectError();
 #ifdef HAVE_THREADS
-	I_unlock_mutex(m_menu_mutex);
+	I_UnlockMutex(m_menu_mutex);
 #endif
 }
 
@@ -168,12 +168,12 @@ char *GetMODVersion(int id)
 	c = HMS_compare_mod_version(buffer, 16);
 
 #ifdef HAVE_THREADS
-	I_lock_mutex(&ms_QueryId_mutex);
+	I_LockMutex(&ms_QueryId_mutex);
 	{
 		if (id != ms_QueryId)
 			c = -1;
 	}
-	I_unlock_mutex(ms_QueryId_mutex);
+	I_UnlockMutex(ms_QueryId_mutex);
 #endif
 
 	if (c > 0)
@@ -262,7 +262,6 @@ Finish_registration (void)
 	{
 		CONS_Printf("\n");
 		CONS_Alert(CONS_NOTICE, "%s\n", rules);
-		free(rules);
 	}
 
 	if (registered)
@@ -342,7 +341,7 @@ Finish_unlist (void)
 		Unlock_state();
 
 #ifdef HAVE_THREADS
-		I_wake_all_cond(&MSCond);
+		I_WakeAllCond(&MSCond);
 #endif
 	}
 }
@@ -378,7 +377,7 @@ New_server_id (void)
 	Lock_state();
 	{
 		*id = ++MSId;
-		I_wake_all_cond(&MSCond);
+		I_WakeAllCond(&MSCond);
 	}
 	Unlock_state();
 	return id;
@@ -393,7 +392,7 @@ Register_server_thread (int *id)
 	{
 		/* wait for previous unlist to finish */
 		while (*id == MSId && MSRegistered)
-			I_hold_cond(&MSCond, MSMutex);
+			I_HoldCond(&MSCond, MSMutex);
 
 		same = ( *id == MSId );/* it could have been a while */
 	}
@@ -445,7 +444,7 @@ Change_masterserver_thread (char *api)
 	Lock_state();
 	{
 		while (MSRegistered)
-			I_hold_cond(&MSCond, MSMutex);
+			I_HoldCond(&MSCond, MSMutex);
 	}
 	Unlock_state();
 
@@ -465,9 +464,9 @@ void RegisterServer(void)
 {
 #ifdef MASTERSERVER
 #ifdef HAVE_THREADS
-	I_spawn_thread(
+	(void)!I_SpawnThread(
 			"register-server",
-			(I_thread_fn)Register_server_thread,
+			(I_ThreadFn)Register_server_thread,
 			New_server_id()
 	);
 #else
@@ -479,9 +478,9 @@ void RegisterServer(void)
 static void UpdateServer(void)
 {
 #ifdef HAVE_THREADS
-	I_spawn_thread(
+	(void)!I_SpawnThread(
 			"update-server",
-			(I_thread_fn)Update_server_thread,
+			(I_ThreadFn)Update_server_thread,
 			Server_id()
 	);
 #else
@@ -493,9 +492,9 @@ void UnregisterServer(void)
 {
 #ifdef MASTERSERVER
 #ifdef HAVE_THREADS
-	I_spawn_thread(
+	(void)!I_SpawnThread(
 			"unlist-server",
-			(I_thread_fn)Unlist_server_thread,
+			(I_ThreadFn)Unlist_server_thread,
 			Server_id()
 	);
 #else
@@ -558,14 +557,18 @@ void MasterClient_Ticker(void)
 static void
 Set_api (const char *api)
 {
+	char *dapi = strdup(api);
 #ifdef HAVE_THREADS
-	I_spawn_thread(
-			"change-masterserver",
-			(I_thread_fn)Change_masterserver_thread,
-			strdup(api)
-	);
+	if (!I_SpawnThread(
+		"change-masterserver",
+		(I_ThreadFn)Change_masterserver_thread,
+					   dapi
+	))
+	{
+		free(dapi);
+	}
 #else
-	Finish_masterserver_change(strdup(api));
+	Finish_masterserver_change(dapi);
 #endif
 }
 
@@ -573,9 +576,9 @@ void
 Get_rules (void)
 {
 #ifdef HAVE_THREADS
-	I_spawn_thread(
-		"get-masterserver-rules",
-		(I_thread_fn)Get_masterserver_rules_thread,
+	(void)!I_SpawnThread(
+			"get-masterserver-rules",
+			(I_ThreadFn)Get_masterserver_rules_thread,
 				   NULL
 	);
 #else

src/mserv.h

@@ -69,10 +69,10 @@ extern consvar_t cv_rendezvousserver;
 
 #ifdef HAVE_THREADS
 extern int           ms_QueryId;
-extern I_mutex       ms_QueryId_mutex;
+extern I_Mutex       ms_QueryId_mutex;
 
 extern msg_server_t *ms_ServerList;
-extern I_mutex       ms_ServerList_mutex;
+extern I_Mutex       ms_ServerList_mutex;
 #endif
 #ifdef MASTERSERVER
 void RegisterServer(void);

src/p_inter.c

@@ -831,7 +831,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 			{
 				S_StartSound(toucher, special->info->seesound);
 
-				if (UNLIKELY(player->pflags & PF_NIGHTSMODE))
+				if (player->pflags & PF_NIGHTSMODE)
 				{
 					player->bumpertime = TICRATE/2;
 					if (special->threshold > 0)
@@ -1131,7 +1131,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
 					S_StartSound(toucher, special->info->painsound);
 					return;
 				}
-				else if (UNLIKELY((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
+				else if (((player->pflags & PF_NIGHTSMODE) && (player->pflags & PF_DRILLING)) || (player->pflags & (PF_JUMPED|PF_SPINNING|PF_GLIDING))
 						|| player->powers[pw_invulnerability] || player->powers[pw_super]) // Do you possess the ability to subdue the object?
 				{
 					// Shatter the shield!
@@ -2420,6 +2420,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 			{
 				player->kartstuff[k_sneakertimer] = 0;
 				K_SpinPlayer(player, source, 1, inflictor, false);
+				damage = player->mo->health - 1;
 				P_RingDamage(player, inflictor, source);
 				P_PlayerRingBurst(player, 5);
 

src/p_local.h

@@ -30,6 +30,8 @@ extern "C" {
 
 #define FLOATSPEED (FRACUNIT*4)
 
+//#define VIEWHEIGHTS "41"
+
 // Maximum player score.
 #define MAXSCORE 999999990
 
@@ -237,10 +239,14 @@ void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move);
 boolean P_LookForEnemies(player_t *player);
 void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
 void P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
+//boolean P_SuperReady(player_t *player);
 boolean P_AnalogMove(player_t *player);
+/*boolean P_TransferToNextMare(player_t *player);
+UINT8 P_FindLowestMare(void);*/
 UINT8 P_FindLowestLap(void);
 UINT8 P_FindHighestLap(void);
 void P_FindEmerald(void);
+//void P_TransferToAxis(player_t *player, INT32 axisnum);
 boolean P_PlayerMoving(INT32 pnum);
 void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range);
 

src/p_mobj.c

@@ -122,6 +122,27 @@ static void P_CycleMobjState(mobj_t *mobj)
 	}
 }
 
+//
+// P_CycleMobjState for players.
+//
+static void P_CyclePlayerMobjState(mobj_t *mobj)
+{
+	// state animations
+	P_CycleStateAnimation(mobj);
+
+	// cycle through states,
+	// calling action functions at transitions
+	if (mobj->tics != -1)
+	{
+		mobj->tics--;
+
+		// you can cycle through multiple states in a tic
+		if (!mobj->tics && mobj->state)
+			if (!P_SetPlayerMobjState(mobj, mobj->state->nextstate))
+				return; // freed itself
+	}
+}
+
 #define MAX_RECURSION 20
 
 //
@@ -314,7 +335,7 @@ static boolean P_SetPrecipMobjState(precipmobj_t *mobj, statenum_t state)
 	mobj->tics = st->tics;
 	mobj->sprite = st->sprite;
 	mobj->frame = st->frame;
-	//mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
+	mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
 
 	return true;
 }
@@ -898,7 +919,12 @@ static void P_PlayerFlip(mobj_t *mo)
 	G_GhostAddFlip((INT32) (mo->player - players));
 	// Flip aiming to match!
 
-	if (mo->player->pflags & PF_FLIPCAM)
+	if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
+	{
+		if (mo->tracer)
+			mo->tracer->eflags ^= MFE_VERTICALFLIP;
+	}
+	else if (mo->player->pflags & PF_FLIPCAM)
 	{
 		UINT8 i;
 
@@ -920,11 +946,6 @@ static void P_PlayerFlip(mobj_t *mo)
 				camera[i].z += FixedMul(20*FRACUNIT, mo->scale);
 		}
 	}
-	else if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
-	{
-		if (mo->tracer)
-			mo->tracer->eflags ^= MFE_VERTICALFLIP;
-	}
 }
 
 //
@@ -1649,14 +1670,6 @@ void P_XYMovement(mobj_t *mo)
 	if (mo->flags & MF_NOCLIPHEIGHT)
 		return; // no frictions for objects that can pass through floors
 
-	//{ SRB2kart stuff
-	if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
-		return;
-
-	if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
-		return;
-	//}
-
 	if (mo->flags & MF_MISSILE || mo->flags2 & MF2_SKULLFLY || mo->type == MT_SHELL || mo->type == MT_VULTURE)
 		return; // no friction for missiles ever
 
@@ -1670,6 +1683,14 @@ void P_XYMovement(mobj_t *mo)
 			&& (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8)) // Special exception for tumbleweeds on slopes
 		return;
 
+	//{ SRB2kart stuff
+	if (mo->type == MT_ORBINAUT || mo->type == MT_JAWZ_DUD || mo->type == MT_JAWZ || mo->type == MT_BALLHOG) //(mo->type == MT_JAWZ && !mo->tracer))
+		return;
+
+	if (mo->player && (mo->player->kartstuff[k_spinouttimer] && !mo->player->kartstuff[k_wipeoutslow]) && mo->player->speed <= K_GetKartSpeed(mo->player, false)/2)
+		return;
+	//}
+
 	if (((!(mo->eflags & MFE_VERTICALFLIP) && mo->z > mo->floorz) || (mo->eflags & MFE_VERTICALFLIP && mo->z+mo->height < mo->ceilingz))
 		&& !(player && player->pflags & PF_SLIDING))
 		return; // no friction when airborne
@@ -3189,6 +3210,30 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
 	return false;
 }
 
+void P_DestroyRobots(void)
+{
+	// Search through all the thinkers for enemies.
+	mobj_t *mo;
+	thinker_t *think;
+
+	for (think = thinkercap.next; think != &thinkercap; think = think->next)
+	{
+		if (think->function != (actionf_p1)P_MobjThinker)
+			continue; // not a mobj thinker
+
+		mo = (mobj_t *)think;
+
+		if (mo->health <= 0 || !(mo->flags & MF_ENEMY || mo->flags & MF_BOSS))
+			continue; // not a valid enemy
+
+		if (mo->type == MT_PLAYER) // Don't chase after other players!
+			continue;
+
+		// Found a target enemy
+		P_KillMobj(mo, players[consoleplayer].mo, players[consoleplayer].mo);
+	}
+}
+
 // the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person
 void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
 {
@@ -3207,7 +3252,7 @@ void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
 		player_flipcam = cv_flipcam[pnum].value;
 	}
 
-	const boolean flipcam = (player_flipcam && player->mo->eflags & MFE_VERTICALFLIP && LIKELY(!(player->pflags & PF_NIGHTSMODE)));
+	const boolean flipcam = (player_flipcam && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
 	UINT8 postimgtype = 0;
 
 	if (encoremode)
@@ -3575,7 +3620,7 @@ boolean P_PrecipThinker(precipmobj_t *mobj)
 	mobj->lastThink = leveltime;
 
 	R_ResetPrecipitationMobjInterpolationState(mobj);
-	//P_CycleStateAnimation((mobj_t *)mobj); // if we ever want animated precip, readd a specific function which does not need casting
+	P_CycleStateAnimation((mobj_t *)mobj);
 
 	if (mobj->state == &states[S_RAINRETURN])
 	{
@@ -6941,7 +6986,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
 				fixed_t ns;
 				mobj_t *mo2;
 
-				i = P_RandomByte(); // grrrrrr
+				i = P_RandomByte();
 				z = mobj->subsector->sector->floorheight + ((P_RandomByte()&63)*FRACUNIT);
 
 				for (j = 0; j < 2; j++)
@@ -8508,7 +8553,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 				if (mobj->tracer && mobj->tracer->player)
 				{
-					if (LIKELY(!(mobj->tracer->player->pflags & PF_NIGHTSMODE)))
+					if (!(mobj->tracer->player->pflags & PF_NIGHTSMODE))
 					{
 						mobj->flags &= ~MF_NOGRAVITY;
 						mobj->flags2 &= ~MF2_DONTDRAW;
@@ -8532,7 +8577,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 						P_SetTarget(&mobj->target, NULL);
 					}
 
-					if (UNLIKELY(mobj->tracer->player->pflags & PF_NIGHTSMODE))
+					if (mobj->tracer->player->pflags & PF_NIGHTSMODE)
 					{
 						if (mobj->tracer->player->bonustime)
 						{
@@ -9176,7 +9221,10 @@ void P_MobjThinker(mobj_t *mobj)
 	}
 
 	// Can end up here if a player dies.
-	P_CycleMobjState(mobj);
+	if (mobj->player)
+		P_CyclePlayerMobjState(mobj);
+	else
+		P_CycleMobjState(mobj);
 
 	if (P_MobjWasRemoved(mobj))
 		return;
@@ -9986,7 +10034,7 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
 
 	mobj->x = x;
 	mobj->y = y;
-	//mobj->flags = info->flags;
+	mobj->flags = info->flags;
 
 	// do not set the state with P_SetMobjState,
 	// because action routines can not be called yet
@@ -9996,7 +10044,7 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
 	mobj->tics = st->tics;
 	mobj->sprite = st->sprite;
 	mobj->frame = st->frame; // FF_FRAMEMASK for frame, and other bits..
-	//mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
+	mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
 
 	// set subsector and/or block links
 	P_SetPrecipitationThingPosition(mobj);
@@ -11070,6 +11118,8 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	{
 		if (!cv_powerstones.value || !G_BattleGametype())
 			return;
+
+		runemeraldmanager = true;
 	}
 
 	if (!G_RaceGametype()) // No enemies in match or CTF modes

src/p_mobj.h

@@ -444,10 +444,12 @@ typedef struct precipmobj_s
 	// More drawing info: to determine current sprite.
 	spritenum_t sprite; // used to find patch_t and flip value
 	UINT32 frame; // frame number, plus bits see p_pspr.h
-	//UINT16 anim_duration; // for FF_ANIMATE states
+	UINT16 anim_duration; // for FF_ANIMATE states
 
 	INT16 lightlevel; // Add to sector lightlevel, -255 - 255
 
+	struct mprecipsecnode_s *touching_sectorlist; // a linked list of sectors where this object appears
+
 	struct subsector_s *subsector; // Subsector the mobj resides in.
 
 	// The closest interval over all contacted sectors (or things).
@@ -456,10 +458,11 @@ typedef struct precipmobj_s
 
 	// Momentums, used to update position.
 	fixed_t momx, momy, momz;
-	precipflag_t precipflags;
+	fixed_t precipflags; // fixed_t so it uses the same spot as "pmomz" even as we use precipflags_t for it
 
 	state_t *state;
 	INT32 tics; // state tic counter
+	UINT32 flags; // flags from mobjinfo tables
 	tic_t lastThink;
 } precipmobj_t;
 
@@ -499,6 +502,7 @@ void P_SpawnPrecipitation(void);
 void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter);
 boolean P_BossTargetPlayer(mobj_t *actor, boolean closest);
 boolean P_SupermanLook4Players(mobj_t *actor);
+void P_DestroyRobots(void);
 boolean P_PrecipThinker(precipmobj_t *mobj);
 void P_NullPrecipThinker(precipmobj_t *mobj);
 void P_FreePrecipMobj(precipmobj_t *mobj);
@@ -509,6 +513,7 @@ void P_EmeraldManager(void);
 #define MAXHUNTEMERALDS 64
 extern mapthing_t *huntemeralds[MAXHUNTEMERALDS];
 extern INT32 numhuntemeralds;
+extern boolean runemeraldmanager;
 extern INT32 numstarposts;
 
 #ifdef __cplusplus

src/p_setup.c

@@ -218,6 +218,8 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
 	mapheaderinfo[num]->musname[6] = 0;
 	mapheaderinfo[num]->mustrack = 0;
 	mapheaderinfo[num]->muspos = 0;
+	mapheaderinfo[num]->musinterfadeout = 0;
+	mapheaderinfo[num]->musintername[0] = '\0';
 	mapheaderinfo[num]->forcecharacter[0] = '\0';
 	mapheaderinfo[num]->weather = 0;
 	mapheaderinfo[num]->skynum = 1;
@@ -235,10 +237,16 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
 	mapheaderinfo[num]->numlaps = NUMLAPS_DEFAULT;
 	mapheaderinfo[num]->unlockrequired = -1;
 	mapheaderinfo[num]->levelselect = 0;
+	mapheaderinfo[num]->bonustype = 0;
+	mapheaderinfo[num]->saveoverride = SAVE_DEFAULT;
 	mapheaderinfo[num]->levelflags = 0;
 	mapheaderinfo[num]->menuflags = (mainwads ? 0 : LF2_EXISTSHACK); // see p_setup.c - prevents replacing maps in addons with easier versions
 
+	// TODO grades support for delfile (pfft yeah right)
+	P_DeleteGrades(num);
+
 	// SRB2Kart
+	//mapheaderinfo[num]->automap = false;
 	mapheaderinfo[num]->mobj_scale = FRACUNIT;
 
 	mapheaderinfo[num]->customopts = NULL;
@@ -258,11 +266,107 @@ void P_AllocMapHeader(INT16 i)
 	if (!mapheaderinfo[i])
 	{
 		mapheaderinfo[i] = Z_Malloc(sizeof(mapheader_t), PU_STATIC, NULL);
+		mapheaderinfo[i]->grades = NULL;
 	}
 
 	P_ClearSingleMapHeaderInfo(i + 1);
 }
 
+/** NiGHTS Grades are a special structure,
+  * we initialize them here.
+  *
+  * \param i Index of header to allocate grades for
+  * \param mare The mare we're adding grades for
+  * \param grades the string from DeHackEd, we work with it ourselves
+  */
+void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext)
+{
+	INT32 g;
+	char *spos = gtext;
+
+	CONS_Debug(DBG_SETUP, "Map %d Mare %d: ", i+1, (UINT16)mare+1);
+
+	if (mapheaderinfo[i]->numGradedMares < mare+1)
+	{
+		mapheaderinfo[i]->numGradedMares = mare+1;
+		mapheaderinfo[i]->grades = Z_Realloc(mapheaderinfo[i]->grades, sizeof(nightsgrades_t) * mapheaderinfo[i]->numGradedMares, PU_STATIC, NULL);
+	}
+
+	for (g = 0; g < 6; ++g)
+	{
+		// Allow "partial" grading systems
+		if (spos != NULL)
+		{
+			mapheaderinfo[i]->grades[mare].grade[g] = atoi(spos);
+			CONS_Debug(DBG_SETUP, "%u ", atoi(spos));
+			// Grab next comma
+			spos = strchr(spos, ',');
+			if (spos)
+				++spos;
+		}
+		else
+		{
+			// Grade not reachable
+			mapheaderinfo[i]->grades[mare].grade[g] = UINT32_MAX;
+		}
+	}
+
+	CONS_Debug(DBG_SETUP, "\n");
+}
+
+/** And this removes the grades safely.
+  *
+  * \param i The header to remove grades from
+  */
+void P_DeleteGrades(INT16 i)
+{
+	Z_Free(mapheaderinfo[i]->grades);
+	mapheaderinfo[i]->grades = NULL;
+	mapheaderinfo[i]->numGradedMares = 0;
+}
+
+/** And this fetches the grades
+  *
+  * \param pscore The player's score.
+  * \param map The game map.
+  * \param mare The mare to test.
+  */
+UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare)
+{
+	INT32 i;
+
+	// Determining the grade
+	if (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades && mapheaderinfo[map-1]->numGradedMares >= mare + 1)
+	{
+		INT32 pgrade = 0;
+		for (i = 0; i < 6; ++i)
+		{
+			if (pscore >= mapheaderinfo[map-1]->grades[mare].grade[i])
+				++pgrade;
+		}
+
+		return (UINT8)pgrade;
+	}
+
+	return 0;
+}
+
+UINT8 P_HasGrades(INT16 map, UINT8 mare)
+{
+	// Determining the grade
+	// Mare 0 is treated as overall and is true if ANY grades exist
+	return (mapheaderinfo[map-1] && mapheaderinfo[map-1]->grades
+	&& (mare == 0 || mapheaderinfo[map-1]->numGradedMares >= mare));
+}
+
+UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade)
+{
+	// Get the score for the grade... if it exists
+	if (grade == GRADE_F || grade > GRADE_S || !P_HasGrades(map, mare)) return 0;
+
+	return mapheaderinfo[map-1]->grades[mare].grade[grade-1];
+}
+
 // Loads the vertexes for a level.
 FUNCINLINE static ATTRINLINE void P_LoadVertices(UINT8 *data)
 {
@@ -310,7 +414,7 @@ void P_UpdateSegLightOffset(seg_t *li)
 		angle_t liAngle = R_PointToAngle2(0, 0, (li->v1->x - li->v2->x), (li->v1->y - li->v2->y)) - ANGLE_90;
 
 		light = FixedMul(FINECOSINE(liAngle >> ANGLETOFINESHIFT), FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
-			  + FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
+		+ FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
 		light = (light + FRACUNIT) / 2;
 	}
 	else
@@ -1810,7 +1914,7 @@ static void P_LoadMapBSP(const virtres_t* virt)
 	if (numsubsectors <= 0)
 		I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
 	if (numnodes <= 0)
-		I_Error("Level has no nodes (does your map have at least 2 sectors?)");
+		I_Error("Level has no nodes");
 	if (numsegs <= 0)
 		I_Error("Level has no segs");
 
@@ -1943,6 +2047,7 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
 
 	// special stage tokens, emeralds, and ring total
 	tokenbits = 0;
+	runemeraldmanager = false;
 	nummaprings = nummapboxes = numgotboxes = 0;
 
 	// emerald hunt
@@ -1972,10 +2077,10 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
 	stagefailed = false;
 
 	// earthquake camera
-	memset(&quake, 0, sizeof(struct quake));
+	memset(&quake,0,sizeof(struct quake));
 
 	// song credit init
-	memset(&cursongcredit, 0, sizeof(struct cursongcredit));
+	memset(&cursongcredit,0,sizeof(struct cursongcredit));
 	cursongcredit.trans = NUMTRANSMAPS;
 
 	for (i = 0; i < MAXPLAYERS; i++)
@@ -2069,14 +2174,14 @@ static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
 	memset(resblock, 0x00, 16);
 	return 1;
 #else
-	precise_t t = I_GetPreciseTime();
+	tic_t t = I_GetTime();
 
 	CONS_Debug(DBG_SETUP, "Making MD5\n");
 
 	if (md5_buffer(buffer, len, resblock) == NULL)
 		return 1;
 
-	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
+	CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
 
 	return 0;
 #endif
@@ -2098,10 +2203,10 @@ static void P_MakeMapMD5(virtres_t *virt, void *dest)
 	virtlump_t* virtmthings = vres_Find(virt, "THINGS");
 	virtlump_t* virtsides   = vres_Find(virt, "SIDEDEFS");
 
-	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size,   linemd5);
-	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size, sectormd5);
-	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size, thingmd5);
-	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size,   sidedefmd5);
+	P_MakeBufferMD5((char*)virtlines->data,   virtlines->size, linemd5);
+	P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size,  sectormd5);
+	P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size,   thingmd5);
+	P_MakeBufferMD5((char*)virtsides->data,   virtsides->size, sidedefmd5);
 
 	for (i = 0; i < 16; i++)
 		resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;

src/p_setup.h

@@ -114,6 +114,13 @@ size_t P_PrecacheLevelFlats(void);
 
 void P_AllocMapHeader(INT16 i);
 
+// Needed for NiGHTS
+void P_DeleteGrades(INT16 i);
+void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext);
+UINT8 P_GetGrade(UINT32 pscore, INT16 map, UINT8 mare);
+UINT8 P_HasGrades(INT16 map, UINT8 mare);
+UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/p_slopes.c

@@ -76,8 +76,8 @@ static void P_UpdateSlopeLightOffset(pslope_t *slope)
 		 */
 
 		light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
-			  + FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
-				light = (light + FRACUNIT) / 2;
+		+ FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
+		light = (light + FRACUNIT) / 2;
 	}
 	else
 	{

src/p_spec.c

@@ -1702,7 +1702,7 @@ void P_SwitchWeather(INT32 weathernum)
 
 			precipmobj->type = type; // proper set the type
 			precipmobj->info = &mobjinfo[type];
-			//precipmobj->flags = mobjinfo[type].flags;
+			precipmobj->flags = mobjinfo[type].flags;
 
 			st = &states[mobjinfo[type].spawnstate+z];
 
@@ -3161,6 +3161,11 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
 	INT32 section1, section2, section3, section4;
 	INT32 special;
 
+	section1 = GETSECSPECIAL(sector->special, 1);
+	section2 = GETSECSPECIAL(sector->special, 2);
+	section3 = GETSECSPECIAL(sector->special, 3);
+	section4 = GETSECSPECIAL(sector->special, 4);
+
 	// Ignore spectators
 	if (player->spectator)
 		return;
@@ -3171,11 +3176,6 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
 	if (player->playerstate == PST_DEAD)
 		return;
 
-	section1 = GETSECSPECIAL(sector->special, 1);
-	section2 = GETSECSPECIAL(sector->special, 2);
-	section3 = GETSECSPECIAL(sector->special, 3);
-	section4 = GETSECSPECIAL(sector->special, 4);
-
 	// Conveyor stuff
 	if (section3 == 2 || section3 == 4)
 		player->onconveyor = section3;
@@ -4381,6 +4381,8 @@ static void P_PlayerOnSpecial3DFloor(player_t *player, sector_t *sector)
 	}
 }
 
+#define VDOORSPEED (FRACUNIT*2)
+
 //
 // P_RunSpecialSectorCheck
 //
@@ -4399,7 +4401,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 
 	// The list of specials that activate without floor touch
 	// Check Section 1
-	switch (GETSECSPECIAL(sector->special, 1))
+	switch(GETSECSPECIAL(sector->special, 1))
 	{
 		//case 2: // Damage (water)
 		case 8: // Instant kill
@@ -4410,7 +4412,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 2
-	switch (GETSECSPECIAL(sector->special, 2))
+	switch(GETSECSPECIAL(sector->special, 2))
 	{
 		case 2: // Linedef executor (All players needed)
 		case 4: // Linedef executor
@@ -4421,7 +4423,7 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
 	}
 
 	// Check Section 4
-	switch (GETSECSPECIAL(sector->special, 4))
+	switch(GETSECSPECIAL(sector->special, 4))
 	{
 		case 2: // Level Exit / GOAL Sector / Flag Return
 		case 1: // Starpost activator
@@ -4510,7 +4512,9 @@ void P_UpdateSpecials(void)
 {
 	anim_t *anim;
 	INT32 i;
+	INT32 pic;
 	size_t j;
+
 	levelflat_t *foundflats; // for flat animation
 
 	// LEVEL TIMER
@@ -4528,11 +4532,9 @@ void P_UpdateSpecials(void)
 	{
 		for (i = 0; i < anim->numpics; i++)
 		{
+			pic = anim->basepic + ((leveltime/anim->speed + i) % anim->numpics);
 			if (anim->istexture)
-			{
-				texturetranslation[anim->basepic+i] = anim->basepic +
-					((leveltime/anim->speed + i) % anim->numpics);
-			}
+				texturetranslation[anim->basepic+i] = pic;
 		}
 	}
 
@@ -4627,8 +4629,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
 
 	if (sec2->numattached == 0)
 	{
-		sec2->attached = Z_Malloc(sizeof(*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
-		sec2->attachedsolid = Z_Malloc(sizeof(*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
+		sec2->attached = Z_Malloc(sizeof (*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
+		sec2->attachedsolid = Z_Malloc(sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
 		sec2->attached[0] = sec - sectors;
 		sec2->numattached = 1;
 		sec2->attachedsolid[0] = (flags & FF_SOLID);
@@ -4642,8 +4644,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
 		if (sec2->numattached >= sec2->maxattached)
 		{
 			sec2->maxattached *= 2;
-			sec2->attached = Z_Realloc(sec2->attached, sizeof(*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
-			sec2->attachedsolid = Z_Realloc(sec2->attachedsolid, sizeof(*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
+			sec2->attached = Z_Realloc(sec2->attached, sizeof (*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
+			sec2->attachedsolid = Z_Realloc(sec2->attachedsolid, sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
 		}
 		sec2->attached[sec2->numattached] = sec - sectors;
 		sec2->attachedsolid[sec2->numattached] = (flags & FF_SOLID);
@@ -4651,7 +4653,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
 	}
 
 	// Add the floor
-	ffloor = Z_Calloc(sizeof(*ffloor), PU_LEVEL, NULL);
+	ffloor = Z_Calloc(sizeof (*ffloor), PU_LEVEL, NULL);
 	ffloor->secnum = sec2 - sectors;
 	ffloor->target = sec;
 	ffloor->bottomheight = &sec2->floorheight;
@@ -5466,6 +5468,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 				break;
 
 			case 10: // Vertical culling plane for sprites and FOFs
+				sec = sides[*lines[i].sidenum].sector - sectors;
 				for (s = -1; (s = P_FindSectorFromLineTag(lines + i, s)) >= 0 ;)
 					sectors[s].cullheight = &lines[i]; // This allows it to change in realtime!
 				break;
@@ -5986,7 +5989,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
 					if (!virt)
 						virt = vres_GetMap(lastloadedmaplumpnum);
 
-					data = (UINT8*)vres_Find(virt, "SIDEDEFS")->data;
+					data = (UINT8*) vres_Find(virt, "SIDEDEFS")->data;
 
 					for (b = 0; b < (INT16)numsides; b++)
 					{

src/p_tick.c

@@ -728,12 +728,11 @@ void P_Ticker(boolean run)
 
 			if (cv_recordmultiplayerdemos.value)
 			{
+				const INT32 axis = JoyAxis(AXISLOOKBACK, 1);
+
 				if (demo.savemode == DSM_NOTSAVING || demo.savemode == DSM_WILLAUTOSAVE)
-				{
-					const INT32 axis = cv_usejoystick[0].value ? JoyAxis(AXISLOOKBACK, 1) : -1;
-					if (demo.savebutton && demo.savebutton + 3*TICRATE < leveltime && (InputDown(gc_lookback, 1) || (axis > 0)))
+					if (demo.savebutton && demo.savebutton + 3*TICRATE < leveltime && (InputDown(gc_lookback, 1) || (cv_usejoystick[0].value && axis > 0)))
 						demo.savemode = DSM_TITLEENTRY;
-				}
 
 				// if there are no players left at all, stop demo recording
 				// Demos that that dont have any players crash during playback, which can happen with dedicated servers

src/p_user.c

@@ -1822,6 +1822,7 @@ void P_DoJumpShield(player_t *player)
 
 	player->pflags &= ~PF_JUMPED;
 	//P_DoJump(player, false);
+	player->pflags &= ~PF_JUMPED;
 	player->secondjump = 0;
 	player->jumping = 0;
 	player->pflags |= PF_THOKKED;
@@ -1893,6 +1894,7 @@ static void P_3dMovement(player_t *player)
 	ticcmd_t *cmd;
 	angle_t movepushangle, movepushsideangle; // Analog
 	fixed_t movepushforward = 0, movepushside = 0;
+	angle_t dangle; // replaces old quadrants bits
 	boolean analogmove = false;
 	fixed_t oldMagnitude, newMagnitude;
 	vector3_t totalthrust;
@@ -1950,6 +1952,15 @@ static void P_3dMovement(player_t *player)
 	// Calculates player's speed based on distance-of-a-line formula
 	player->speed = R_PointToDist2(0, 0, player->rmomx, player->rmomy);
 
+	// Monster Iestyn - 04-11-13
+	// Quadrants are stupid, excessive and broken, let's do this a much simpler way!
+	// Get delta angle from rmom angle and player angle first
+	dangle = R_PointToAngle2(0,0, player->rmomx, player->rmomy) - player->mo->angle;
+	if (dangle > ANGLE_180) //flip to keep to one side
+	{
+		dangle = InvAngle(dangle);
+	}
+
 	// When sliding, don't allow forward/back
 	if (player->pflags & PF_SLIDING)
 		cmd->forwardmove = 0;
@@ -1992,23 +2003,20 @@ static void P_3dMovement(player_t *player)
 		K_MomentumToFacing(player);
 	}
 
-	const fixed_t kartspd = K_GetKartSpeed(player, true);
-
 	// Sideways movement
 	if (cmd->sidemove != 0 && !((player->exiting || mapreset) || player->kartstuff[k_spinouttimer]))
 	{
 		if (cmd->sidemove > 0)
-			movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, kartspd);
+			movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, K_GetKartSpeed(player, true));
 		else
-			movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, kartspd);
+			movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, K_GetKartSpeed(player, true));
 
 		totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside);
 		totalthrust.y += P_ReturnThrustY(player->mo, movepushsideangle, movepushside);
 	}
 
 	if ((totalthrust.x || totalthrust.y)
-		&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2)
-	{
+		&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2) {
 		// Factor thrust to slope, but only for the part pushing up it!
 		// The rest is unaffected.
 		angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-player->mo->standingslope->xydirection;
@@ -2044,11 +2052,11 @@ static void P_3dMovement(player_t *player)
 	// -Shadow Hog
 	newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
 
-	if (newMagnitude > kartspd) //topspeed)
+	if (newMagnitude > K_GetKartSpeed(player, true)) //topspeed)
 	{
 		fixed_t tempmomx, tempmomy;
 
-		if (oldMagnitude > kartspd && onground) // SRB2Kart: onground check for air speed cap
+		if (oldMagnitude > K_GetKartSpeed(player, true) && onground) // SRB2Kart: onground check for air speed cap
 		{
 			if (newMagnitude > oldMagnitude)
 			{
@@ -2061,8 +2069,8 @@ static void P_3dMovement(player_t *player)
 		}
 		else
 		{
-			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), kartspd); //topspeed)
-			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), kartspd); //topspeed)
+			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
+			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
 			player->mo->momx = tempmomx + player->cmomx;
 			player->mo->momy = tempmomy + player->cmomy;
 		}
@@ -2477,10 +2485,9 @@ static void P_MovePlayer(player_t *player)
 		const fixed_t runnyspeed = 20*FRACUNIT;
 
 		speed = R_PointToDist2(player->rmomx, player->rmomy, 0, 0);
-		const fixed_t kartspd = K_GetKartSpeed(player, false);
 
-		if (speed > kartspd-(5<<FRACBITS))
-			speed = kartspd-(5<<FRACBITS);
+		if (speed > K_GetKartSpeed(player, false)-(5<<FRACBITS))
+			speed = K_GetKartSpeed(player, false)-(5<<FRACBITS);
 
 		if (speed >= runnyspeed)
 			player->fovadd = speed-runnyspeed;
@@ -4113,7 +4120,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
 			angle -= (angle - thiscam->pitch)/2;
 	}
 
-	if (player->playerstate != PST_DEAD && LIKELY(!((player->pflags & PF_NIGHTSMODE) && player->exiting)))
+	if (player->playerstate != PST_DEAD && !((player->pflags & PF_NIGHTSMODE) && player->exiting))
 		angle += (focusaiming < ANGLE_180 ? focusaiming/2 : InvAngle(InvAngle(focusaiming)/2)); // overcomplicated version of '((signed)focusaiming)/2;'
 
 	if (!camstill && !timeover) // Keep the view still...
@@ -4457,7 +4464,7 @@ static INT32 Quaketilt(player_t *player)
 
 	lowb = FixedMul(lowb, player->mo->scale);
 	moma = FixedMul(FixedDiv(delta, ANGLE_90), tilt);
-	speed = abs(player->mo->momx + player->mo->momy);
+	speed = abs( player->mo->momx + player->mo->momy );
 
 	if (speed < lowb)
 	{
@@ -4588,7 +4595,7 @@ void P_PlayerThink(player_t *player)
 	}
 
 #ifdef SEENAMES
-	if (netgame && !splitscreen && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)))
+	if (netgame && player == &players[displayplayers[0]] && !(leveltime % (TICRATE/5)) && !splitscreen)
 	{
 		seenplayer = NULL;
 

src/r_data.c

@@ -622,7 +622,7 @@ Rloadtextures (INT32 i, INT32 w)
 
 		// Set texture properties.
 		memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
-		texture->hash = FNV1a_QuickCaseHash(texture->name, 8);
+		texture->hash = quickncasehash(texture->name, 8);
 
 		texture->width = SHORT(patchlump.width);
 		texture->height = SHORT(patchlump.height);
@@ -1066,7 +1066,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
 			// Allocate memory for a zero-patch texture. Obviously, we'll be adding patches momentarily.
 			resultTexture = (texture_t *)Z_Calloc(sizeof(texture_t), PU_STATIC, NULL);
 			memcpy(resultTexture->name, newTextureName, 8);
-			resultTexture->hash = FNV1a_QuickCaseHash(newTextureName, 8);
+			resultTexture->hash = quickncasehash(newTextureName, 8);
 			resultTexture->width = newTextureWidth;
 			resultTexture->height = newTextureHeight;
 			resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1755,7 +1755,7 @@ INT32 R_CheckTextureNumForName(const char *name)
 	if (name[0] == '-')
 		return 0;
 
-	hash = FNV1a_QuickCaseHash(name, 8);
+	hash = quickncasehash(name, 8);
 
 	for (i = 0; i < tidcachelen; i++)
 		if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))

src/r_draw.cpp

@@ -289,8 +289,14 @@ void R_GenerateBlendTables(void)
 	state->LocalPalette = static_cast<RGBA_t *>(memcpy(malloc(palsize), pLocalPalette, palsize));
 	state->gammaCorrectedPalette = static_cast<RGBA_t *>(memcpy(malloc(palsize), pGammaCorrectedPalette, palsize));
 
-	I_spawn_thread("blend-tables",
-			R_GenerateBlendTables_Thread, state);
+	if (!I_SpawnThread("blend-tables",
+			R_GenerateBlendTables_Thread, state))
+	{
+		free(state->gammaCorrectedPalette);
+		free(state->LocalPalette);
+		free(state);
+		I_Error("R_GenerateBlendTables: Failed to generate BlendTables\n"); // should we just retry on main thread instead?
+	}
 #else
 	struct GenerateBlendTables_State state = {pLocalPalette, pGammaCorrectedPalette};
 	R_GenerateBlendTables_Core(&state);
@@ -400,7 +406,7 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 			case TC_ALLWHITE:   skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
 			case TC_RAINBOW:    skintableindex = RAINBOW_TT_CACHE_INDEX; break;
 			case TC_BLINK:      skintableindex = BLINK_TT_CACHE_INDEX; break;
-			default:            skintableindex = skinnum; break;
+			default:       skintableindex = skinnum; break;
 		}
 	}
 
@@ -437,7 +443,8 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
 
 UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local)
 {
-	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
+	const INT32 skinnum = localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
+	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
 }
 
 patch_t* R_GetSkinFaceRank(player_t* ply)

src/r_main.cpp

@@ -280,22 +280,22 @@ static void Fov_OnChange(void)
 
 static void FlipCam_OnChange(void)
 {
-	SendWeaponPref(0);
+	SendWeaponPref();
 }
 
 static void FlipCam2_OnChange(void)
 {
-	SendWeaponPref(1);
+	SendWeaponPref2();
 }
 
 static void FlipCam3_OnChange(void)
 {
-	SendWeaponPref(2);
+	SendWeaponPref3();
 }
 
 static void FlipCam4_OnChange(void)
 {
-	SendWeaponPref(3);
+	SendWeaponPref4();
 }
 
 static void Precipstuff_OnChange(void)

src/r_segs.cpp

@@ -1222,15 +1222,6 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
 		if (yl < top)
 			yl = top;
 
-		// insanely shitty hack to fix flickering on some maps
-		// for god knows why, on secret slide the renderer assumes some double sided linedefs have insanely tall walls
-		// since such tall walls are effectively nonsense in any case
-		// just skip them
-		if (yl > FRACUNIT*3)
-		{
-			continue;
-		}
-
 		if (markceiling)
 		{
 			bottom = yl > floorclip[rw_x] ? floorclip[rw_x] : yl;

src/r_skins.h

@@ -92,7 +92,6 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local);
 // had to move those here Zzz...
 INT32 K_GetSkinNum(player_t *player);
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local);
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local);
 skin_t *K_GetPlayerSkin(player_t *player);
 skin_t *K_GetMobjSkin(const mobj_t *mobj);
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);

src/r_things.cpp

@@ -1662,7 +1662,7 @@ static void R_ProjectSprite(mobj_t *thing)
 
 	if (thing->frame & FF_ABSOLUTELIGHTLEVEL)
 	{
-		const UINT8 n = static_cast<UINT8>(R_ThingLightLevel(thing));
+		const UINT8 n = R_ThingLightLevel(thing);
 		// n = uint8 aka 0 - 255, so the shift will always be 0 - LIGHTLEVELS - 1
 		lights_array = scalelight[n >> LIGHTSEGSHIFT];
 	}
@@ -1855,6 +1855,9 @@ static void R_ProjectSprite(mobj_t *thing)
 
 	if (thing->subsector->sector->numlights)
 		R_SplitSprite(vis);
+
+	// Debug
+	++objectsdrawn;
 }
 
 static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
@@ -2960,24 +2963,21 @@ fixed_t R_DoPlayerFade(mobj_t *thing)
 	fixed_t fadealpha = FRACUNIT;
 	static constexpr tic_t countdownstarttime = (15 * TICRATE) / 4; // starttime - (3*TICRATE)
 
-	if (thing->player == viewplayer || viewplayer->exiting || viewplayer->spectator || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
+	if (thing->player == viewplayer || viewplayer->exiting || camera[R_GetViewNumber()].freecam || leveltime < countdownstarttime)
 		return fadealpha;
 
-	const INT32 otherplayerdist = (FixedMul((thing->x - viewx), viewcos) + FixedMul((thing->y - viewy), viewsin)) >> FRACBITS;
-	const INT32 viewplayerdist  = (FixedMul((viewplayer->mo->x - viewx), viewcos) + FixedMul((viewplayer->mo->y - viewy), viewsin)) >> FRACBITS;
+	const INT32 playerdist     = (FixedMul((thing->x - viewx), viewcos) + FixedMul((thing->y - viewy), viewsin)) >> FRACBITS;
+	const INT32 viewplayerdist = (FixedMul((viewplayer->mo->x - viewx), viewcos) + FixedMul((viewplayer->mo->y - viewy), viewsin)) >> FRACBITS;
 
-	if (viewplayerdist < 2)
-		return fadealpha; // avoid zero division
-
-	if (otherplayerdist < viewplayerdist)
+	if (playerdist < viewplayerdist)
 	{
-		if (otherplayerdist < viewplayerdist / 2) // stronger fade when very close
+		if (playerdist < viewplayerdist / 2) // stronger fade when very close
 		{
-			fadealpha = (otherplayerdist * FRACUNIT) / (viewplayerdist / 2) / 3;
+			fadealpha = (playerdist * FRACUNIT) / (viewplayerdist / 2) / 3;
 		}
 		else
 		{
-			fadealpha = (otherplayerdist * FRACUNIT) / viewplayerdist;
+			fadealpha = (playerdist * FRACUNIT) / viewplayerdist;
 		}
 	}
 

src/s_sound.c

@@ -116,7 +116,9 @@ consvar_t cv_skipintromusic = {"skipintromusic", "No", CV_SAVE, CV_YesNo, NULL,
 
 boolean keepmapmusic = false; // keep the current music on map restart
 boolean skipintromus = false; // skip the intro fanfare
+static boolean resumekeepmusic = false;
 static music_t keepmusic;
+static void S_SetKeepMusResume(void);
 
 #ifdef HAVE_OPENMPT
 openmpt_module *openmpt_mhandle = NULL;
@@ -471,12 +473,13 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
 		return;
 
 	memset(listener, 0, sizeof(listener));
-	memset(listenmobj, 0, sizeof(listenmobj));
 
 	for (i = 0; i <= splitscreen; i++)
 	{
 		player_t *player = &players[displayplayers[i]];
 
+		listenmobj[i] = NULL;
+
 		if (player->awayviewtics)
 		{
 			listenmobj[i] = player->awayviewmobj;
@@ -1299,7 +1302,7 @@ static boolean ReadMusicDefFields(UINT16 wadnum, int line, char *stoken, musicde
 
 				STRBUFCPY(def->name, value);
 				strlwr(def->name);
-				def->hash = FNV1a_QuickCaseHash(def->name, 6);
+				def->hash = quickncasehash (def->name, 6);
 			}
 
 			(*defp) = def;
@@ -1436,7 +1439,7 @@ void S_LoadMusicDefs(UINT16 wadnum)
 			stoken = strtok(stoken, " ");
 			if (stoken)
 			{
-				if (!ReadMusicDefFields(wadnum, line, stoken, &def))
+				if (! ReadMusicDefFields(wadnum, line, stoken, &def))
 					break;
 			}
 
@@ -1481,7 +1484,7 @@ void S_InitMusicDefs(void)
 //
 musicdef_t *S_FindMusicCredit(const char *musname)
 {
-	UINT32 hash = FNV1a_QuickCaseHash(musname, 6);
+	UINT32 hash = quickncasehash(musname, 6);
 	musicdef_t *def;
 
 	for (INT32 i = 0; i < nummusicdefs; ++i)
@@ -1846,6 +1849,8 @@ void S_StopMusic(void)
 
 	mapmusic.resume = (cv_resume.value && fasticmp(music.name, mapmusic.name)) ? I_GetSongPosition() : 0;
 
+	S_SetKeepMusResume();
+
 	if (I_SongPaused())
 		I_ResumeSong();
 
@@ -1972,6 +1977,17 @@ void S_ResetKeepAndSpecialMus(void)
 	keepmapmusic = skipintromus = false;
 }
 
+// saves the current song position everytime a song stops
+// so we can resume it in some cases
+static void S_SetKeepMusResume(void)
+{
+	keepmusic.resume = 0;
+
+	if (fasticmp(music.name, mapmusic.name))
+	{
+		keepmusic.resume = I_GetSongPosition();
+	}
+}
 
 // determine if we should keep the music on a map restart
 // this gets called BEFORE the level gets loaded in G_DoLoadLevel
@@ -1980,7 +1996,7 @@ void S_KeepMusic(void)
 	static INT16 oldmap = -1;
 	static boolean oldencore = false;
 
-	keepmapmusic = false;
+	keepmapmusic = resumekeepmusic = false;
 
 	if (!cv_keepmusic.value)
 	{
@@ -1994,7 +2010,9 @@ void S_KeepMusic(void)
 
 	if (oldmap == gamemap && oldencore == encoremode)
 	{
-		keepmapmusic = (S_CheckMusicException() == false);
+		const boolean musicchanged = S_CheckMusicException();
+		resumekeepmusic = (musicchanged && keepmusic.resume);
+		keepmapmusic = (!musicchanged || resumekeepmusic);
 	}
 
 	oldencore = encoremode;
@@ -2055,6 +2073,12 @@ void S_InitMapMusic(void)
 
 	if (keepmapmusic)
 	{
+		// this is kinda silly, but we can use it to fade back into the map song at the saved point, should the current music be different from the map music
+		if (resumekeepmusic)
+		{
+			S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, keepmusic.resume, 0, 500);
+		}
+
 		return;
 	}
 

src/sdl/CMakeLists.txt

@@ -35,7 +35,6 @@ set(SRB2_SDL2_SOURCES
 	i_system.cpp
 	i_ttf.c
 	i_video.c
-	i_threads.c
 	#IMG_xpm.c
 	ogl_sdl.c
 

src/sdl/i_system.cpp

@@ -1577,7 +1577,7 @@ static void write_backtrace(bt_crash_reason_t reason)
 static std::thread::id g_main_thread_id;
 #endif
 
-static volatile sig_atomic_t g_in_exiting_signal_handler = false;
+boolean g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg, char *signal_name)
 {
@@ -1712,11 +1712,6 @@ static void I_ReportSignal(int num, int coredumped)
 	I_ShowErrorBox(sigttl, sigmsg);
 }
 
-boolean I_In_Exiting_Signal_Handler(void)
-{
-	return g_in_exiting_signal_handler;
-}
-
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1746,17 +1741,21 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-static volatile sig_atomic_t interrupted = false;
-
-boolean I_Interrupted(void)
+FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
 {
-	return interrupted;
-}
+#ifdef HAVE_THREADS
+	if (g_main_thread_id != std::this_thread::get_id())
+	{
+		// Do not attempt any sort of recovery if this signal triggers off the main thread
+		signal(num, SIG_DFL);
+		raise(num);
+		exit(-2);
+	}
+#endif
 
-static void quit_handler(int num)
-{
-	(void)num;
-	interrupted = true;
+	signal(num, SIG_DFL); //default signal action
+	raise(num);
+	I_Quit();
 }
 
 static void I_RegisterSignals(void)
@@ -1842,15 +1841,18 @@ static void I_Fork(void)
 			I_RegisterChildSignals();
 			break;
 		default:
-#ifdef LOGMESSAGES
 			if (logstream)
 				fclose(logstream);/* the child has this */
-#endif
+
 			c = wait(&status);
+
 #ifdef LOGMESSAGES
 			/* By the way, exit closes files. */
 			logstream = fopen(logfilename, "at");
+#else
+			logstream = 0;
 #endif
+
 			if (c == -1)
 			{
 				kill(child, SIGKILL);
@@ -1886,9 +1888,6 @@ INT32 I_StartupSystem(void)
 	SDL_version SDLlinked;
 	SDL_VERSION(&SDLcompiled)
 	SDL_GetVersion(&SDLlinked);
-
-	W_Startup();
-
 	I_StartupConsole();
 #ifdef NEWSIGNALHANDLER
 	// This is useful when debugging. It lets GDB attach to
@@ -1897,8 +1896,8 @@ INT32 I_StartupSystem(void)
 		I_Fork();
 #endif
 #ifdef HAVE_THREADS
-	I_start_threads();
-	I_AddExitFunc(I_stop_threads);
+	I_StartThreads();
+	I_AddExitFunc(I_StopThreads);
 	I_ThreadPoolInit();
 	I_AddExitFunc(I_ThreadPoolShutdown);
 #endif

src/sdl/i_threads.c

@@ -1,360 +0,0 @@
-// SONIC ROBO BLAST 2 KART
-//-----------------------------------------------------------------------------
-// Copyright (C) 2020 by James R.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file  i_threads.c
-/// \brief Multithreading abstraction
-
-#ifdef HAVE_THREADS
-
-#include "../doomdef.h"
-#include "../i_threads.h"
-
-#include <SDL.h>
-
-typedef void * (*Create_fn)(void);
-
-struct Link;
-struct Thread;
-
-typedef struct Link   * Link;
-typedef struct Thread * Thread;
-
-struct Link
-{
-	void * data;
-	Link   next;
-	Link   prev;
-};
-
-struct Thread
-{
-	I_thread_fn   entry;
-	void        * userdata;
-
-	SDL_Thread  * thread;
-};
-
-static Link    i_thread_pool;
-static Link    i_mutex_pool;
-static Link    i_cond_pool;
-
-static I_mutex        i_thread_pool_mutex;
-static I_mutex        i_mutex_pool_mutex;
-static I_mutex        i_cond_pool_mutex;
-
-static SDL_atomic_t   i_threads_running = {1};
-
-static Link
-Insert_link (
-		Link * head,
-		Link   link
-){
-	link->prev = NULL;
-	link->next = (*head);
-	if ((*head))
-		(*head)->prev = link;
-	(*head)    = link;
-	return link;
-}
-
-static void
-Free_link (
-		Link * head,
-		Link   link
-){
-	if (link->prev)
-		link->prev->next = link->next;
-	else
-		(*head) = link->next;
-
-	if (link->next)
-		link->next->prev = link->prev;
-
-	free(link->data);
-	free(link);
-}
-
-static Link
-New_link (void *data)
-{
-	Link link;
-
-	link = malloc(sizeof *link);
-
-	if (! link)
-		abort();
-
-	link->data = data;
-
-	return link;
-}
-
-static void *
-Identity (
-		Link      *  pool_anchor,
-		I_mutex      pool_mutex,
-
-		void      ** anchor,
-
-		Create_fn    create_fn
-){
-	void * id;
-
-	id = SDL_AtomicGetPtr(anchor);
-
-	if (! id)
-	{
-		I_lock_mutex(&pool_mutex);
-		{
-			id = SDL_AtomicGetPtr(anchor);
-
-			if (! id)
-			{
-				id = (*create_fn)();
-
-				if (! id)
-					abort();
-
-				Insert_link(pool_anchor, New_link(id));
-
-				SDL_AtomicSetPtr(anchor, id);
-			}
-		}
-		I_unlock_mutex(pool_mutex);
-	}
-
-	return id;
-}
-
-static int
-Worker (
-		Link link
-){
-	Thread th;
-
-	th = link->data;
-
-	(*th->entry)(th->userdata);
-
-	if (SDL_AtomicGet(&i_threads_running))
-	{
-		I_lock_mutex(&i_thread_pool_mutex);
-		{
-			if (SDL_AtomicGet(&i_threads_running))
-			{
-				SDL_DetachThread(th->thread);
-				Free_link(&i_thread_pool, link);
-			}
-		}
-		I_unlock_mutex(i_thread_pool_mutex);
-	}
-
-	return 0;
-}
-
-void
-I_spawn_thread (
-		const char  * name,
-		I_thread_fn   entry,
-		void        * userdata
-){
-	Link   link;
-	Thread th;
-
-	th = malloc(sizeof *th);
-
-	if (! th)
-		abort();/* this is pretty GNU of me */
-
-	th->entry    = entry;
-	th->userdata = userdata;
-
-	I_lock_mutex(&i_thread_pool_mutex);
-	{
-		link = Insert_link(&i_thread_pool, New_link(th));
-
-		if (SDL_AtomicGet(&i_threads_running))
-		{
-			th->thread = SDL_CreateThread(
-					(SDL_ThreadFunction)Worker,
-					name,
-					link
-			);
-
-			if (! th->thread)
-				abort();
-		}
-	}
-	I_unlock_mutex(i_thread_pool_mutex);
-}
-
-int
-I_thread_is_stopped (void)
-{
-	return ( ! SDL_AtomicGet(&i_threads_running) );
-}
-
-void
-I_start_threads (void)
-{
-	i_thread_pool_mutex = SDL_CreateMutex();
-	i_mutex_pool_mutex  = SDL_CreateMutex();
-	i_cond_pool_mutex   = SDL_CreateMutex();
-
-	if (!(
-				i_thread_pool_mutex &&
-				i_mutex_pool_mutex  &&
-				i_cond_pool_mutex
-	)){
-		abort();
-	}
-}
-
-void
-I_stop_threads (void)
-{
-	Link        link;
-	Link        next;
-
-	Thread      th;
-	SDL_mutex * mutex;
-	SDL_cond  * cond;
-
-	if (i_threads_running.value)
-	{
-		/* rely on the good will of thread-san */
-		SDL_AtomicSet(&i_threads_running, 0);
-
-		I_lock_mutex(&i_thread_pool_mutex);
-		{
-			for (
-					link = i_thread_pool;
-					link;
-					link = next
-			){
-				next = link->next;
-				th   = link->data;
-
-				SDL_WaitThread(th->thread, NULL);
-
-				free(th);
-				free(link);
-			}
-		}
-		I_unlock_mutex(i_thread_pool_mutex);
-
-		for (
-				link = i_mutex_pool;
-				link;
-				link = next
-		){
-			next  = link->next;
-			mutex = link->data;
-
-			SDL_DestroyMutex(mutex);
-
-			free(link);
-		}
-
-		for (
-				link = i_cond_pool;
-				link;
-				link = next
-		){
-			next = link->next;
-			cond = link->data;
-
-			SDL_DestroyCond(cond);
-
-			free(link);
-		}
-
-		SDL_DestroyMutex(i_thread_pool_mutex);
-		SDL_DestroyMutex(i_mutex_pool_mutex);
-		SDL_DestroyMutex(i_cond_pool_mutex);
-	}
-}
-
-void
-I_lock_mutex (
-		I_mutex * anchor
-){
-	SDL_mutex * mutex;
-
-	mutex = Identity(
-			&i_mutex_pool,
-			i_mutex_pool_mutex,
-			anchor,
-			(Create_fn)SDL_CreateMutex
-	);
-
-	if (SDL_LockMutex(mutex) == -1)
-		abort();
-}
-
-void
-I_unlock_mutex (
-		I_mutex id
-){
-	if (SDL_UnlockMutex(id) == -1)
-		abort();
-}
-
-void
-I_hold_cond (
-		I_cond  * cond_anchor,
-		I_mutex   mutex_id
-){
-	SDL_cond * cond;
-
-	cond = Identity(
-			&i_cond_pool,
-			i_cond_pool_mutex,
-			cond_anchor,
-			(Create_fn)SDL_CreateCond
-	);
-
-	if (SDL_CondWait(cond, mutex_id) == -1)
-		abort();
-}
-
-void
-I_wake_one_cond (
-		I_cond * anchor
-){
-	SDL_cond * cond;
-
-	cond = Identity(
-			&i_cond_pool,
-			i_cond_pool_mutex,
-			anchor,
-			(Create_fn)SDL_CreateCond
-	);
-
-	if (SDL_CondSignal(cond) == -1)
-		abort();
-}
-
-void
-I_wake_all_cond (
-		I_cond * anchor
-){
-	SDL_cond * cond;
-
-	cond = Identity(
-			&i_cond_pool,
-			i_cond_pool_mutex,
-			anchor,
-			(Create_fn)SDL_CreateCond
-	);
-
-	if (SDL_CondBroadcast(cond) == -1)
-		abort();
-}
-
-#endif // HAVE_THREADS

src/sdl/i_video.c

@@ -1164,8 +1164,8 @@ void I_GetEvent(void)
 		SDL_GetWindowSize(window, &wwidth, &wheight);
 		event.type = ev_mouse;
 		event.data1 = 0;
-		event.data2 = (INT32)lroundf(mousemovex * ((float)wwidth / (float)realwidth));
-		event.data3 = (INT32)lroundf(mousemovey * ((float)wheight / (float)realheight));
+		event.data2 = (INT32)lround(mousemovex * ((float)wwidth / (float)realwidth));
+		event.data3 = (INT32)lround(mousemovey * ((float)wheight / (float)realheight));
 		D_PostEvent(&event);
 	}
 
@@ -2027,8 +2027,7 @@ void I_ShutdownGraphics(void)
 		SDL_DestroyWindow(window);
 	window = NULL;
 
-	if (SDL_WasInit(SDL_INIT_VIDEO) == SDL_INIT_VIDEO)
-		SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
 	framebuffer = SDL_FALSE;
 }
 

src/sdl/mixer_sound.c

@@ -216,13 +216,8 @@ void I_StartupSound(void)
 				SDLmixlinked->major, SDLmixlinked->minor, SDLmixlinked->patch);
 
 #ifdef HAVE_OPENMPT
-	const char *openmptstr;
-	openmptstr = openmpt_get_string("library_version");
-	I_OutputMsg("libopenmpt version: %s\n", openmptstr);
-	openmpt_free_string(openmptstr);
-	openmptstr = openmpt_get_string("build");
-	I_OutputMsg("libopenmpt build date: %s\n", openmptstr);
-	openmpt_free_string(openmptstr);
+	I_OutputMsg("libopenmpt version: %s\n", openmpt_get_string("library_version"));
+	I_OutputMsg("libopenmpt build date: %s\n", openmpt_get_string("build"));
 #endif
 
 	sound_started = true;
@@ -242,8 +237,7 @@ void I_ShutdownSound(void)
 	Mix_Quit();
 #endif
 
-	if (SDL_WasInit(SDL_INIT_AUDIO) == SDL_INIT_AUDIO)
-		SDL_QuitSubSystem(SDL_INIT_AUDIO);
+	SDL_QuitSubSystem(SDL_INIT_AUDIO);
 
 #ifdef HAVE_LIBGME
 	if (gme)

src/st_stuff.c

@@ -52,6 +52,8 @@
 
 #include "r_fps.h"
 
+UINT16 objectsdrawn = 0;
+
 // dumb fade thing for director toggle
 tic_t directortoggletimer = 0;
 
@@ -180,7 +182,7 @@ static void ST_doPaletteStuff(void)
 	INT32 palette = 0;
 
 #ifdef HWRENDER
-	if (rendermode == render_opengl && !HWR_ShouldUsePaletteRendering())
+	if (rendermode == render_opengl && !HWR_PalRenderFlashpal())
 		return;
 #endif
 

src/st_stuff.h

@@ -134,6 +134,8 @@ typedef enum
 
 extern hudinfo_t hudinfo[NUMHUDITEMS];
 
+extern UINT16 objectsdrawn;
+
 // variable to stop mayonaka static from flickering
 extern consvar_t cv_lessflicker;
 extern consvar_t cv_stagetitle;

src/strcasestr.c

@@ -23,26 +23,24 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef _GNU_SOURCE
-
 #include <string.h>
 #include <ctype.h>
 #include <stddef.h>
 
-static inline int trycmp(char **pp, char *cp, const char *q, size_t qn)
+static inline int
+trycmp (char **pp, char *cp,
+		const char *q, size_t qn)
 {
 	char *p;
 	p = (*pp);
-
 	if (strncasecmp(p, q, qn) == 0)
 		return 0;
-
 	(*pp) = strchr(&p[1], (*cp));
-
 	return 1;
 }
 
-static inline void swapp(char ***ppap, char ***ppbp, char **cpap, char **cpbp)
+static inline void
+swapp (char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 {
 	char **pp;
 	char  *p;
@@ -56,7 +54,8 @@ static inline void swapp(char ***ppap, char ***ppbp, char **cpap, char **cpbp)
 	*cpbp =   p;
 }
 
-char *nongnu_strcasestr(const char *s, const char *q)
+char *
+nongnu_strcasestr (const char *s, const char *q)
 {
 	size_t  qn;
 
@@ -114,5 +113,3 @@ char *nongnu_strcasestr(const char *s, const char *q)
 
 	return NULL;
 }
-
-#endif

src/v_paldeltas.h

@@ -1,525 +0,0 @@
-#ifndef H_PALDELTA
-#define H_PALDELTA
-
-// those are the differences in palette indices between the main srb2 playpal and its white and nuke subpalettes
-// this is probably not the best way of doing any of this, but it works lol
-
-static const INT16 pPaletteDeltaFlash[256][3] = {
-    {   6,   6,   6},
-    {  12,  12,  12},
-    {  18,  18,  18},
-    {  24,  24,  24},
-    {  30,  30,  30},
-    {  36,  36,  36},
-    {  42,  42,  42},
-    {  48,  48,  48},
-    {  54,  54,  54},
-    {  60,  60,  60},
-    {  66,  66,  66},
-    {  72,  72,  72},
-    {  78,  78,  78},
-    {  84,  84,  84},
-    {  90,  90,  90},
-    {  95,  95,  95},
-    { 101, 101, 101},
-    { 107, 107, 107},
-    { 113, 113, 113},
-    { 119, 119, 119},
-    { 125, 125, 125},
-    { 131, 131, 131},
-    { 137, 137, 137},
-    { 143, 143, 143},
-    { 149, 149, 149},
-    { 155, 155, 155},
-    { 161, 161, 161},
-    { 167, 167, 167},
-    { 173, 173, 173},
-    { 179, 179, 179},
-    { 185, 185, 185},
-    { 191, 191, 191},
-    {  48,  66,  84},
-    {  54,  71,  89},
-    {  60,  77,  95},
-    {  66,  83, 100},
-    {  72,  88, 105},
-    {  79,  94, 111},
-    {  85,  99, 117},
-    {  91, 105, 123},
-    {  96, 111, 129},
-    { 102, 117, 135},
-    { 108, 123, 141},
-    { 114, 128, 146},
-    { 120, 134, 152},
-    { 127, 140, 158},
-    { 133, 145, 163},
-    { 140, 152, 170},
-    {  48,  98, 134},
-    {  57, 104, 137},
-    {  63, 107, 140},
-    {  69, 110, 143},
-    {  75, 116, 146},
-    {  84, 119, 149},
-    {  90, 125, 152},
-    {  95, 128, 155},
-    { 101, 131, 158},
-    { 110, 137, 161},
-    { 119, 140, 164},
-    { 128, 143, 167},
-    { 134, 149, 170},
-    { 143, 155, 173},
-    { 152, 158, 176},
-    { 158, 164, 179},
-    {   0,  15,  24},
-    {   0,  21,  33},
-    {   0,  27,  42},
-    {   0,  33,  51},
-    {   0,  36,  57},
-    {   0,  42,  66},
-    {   0,  48,  75},
-    {   0,  51,  81},
-    {   0,  57,  93},
-    {   6,  63,  98},
-    {  12,  69, 104},
-    {  18,  75, 110},
-    {  24,  81, 116},
-    {  30,  87, 122},
-    {  36,  93, 128},
-    {  39,  95, 131},
-    {   0,  12,  26},
-    {   0,  26,  52},
-    {   0,  39,  78},
-    {   0,  52, 102},
-    {   0,  65, 127},
-    {   0,  78, 150},
-    {   0,  91, 172},
-    {   0, 102, 191},
-    {   9, 108, 191},
-    {  19, 114, 191},
-    {  29, 120, 191},
-    {  39, 127, 191},
-    {  48, 133, 191},
-    {  58, 139, 191},
-    {  68, 145, 191},
-    {  78, 150, 191},
-    {   0,   0,  12},
-    {   0,   0,  36},
-    {   0,   0,  60},
-    {   0,   0,  84},
-    {   0,   0, 107},
-    {   0,   0, 131},
-    {   0,   0, 155},
-    {   0,   0, 179},
-    {   0,   0, 191},
-    {  36,  36, 191},
-    {  60,  60, 191},
-    {  84,  84, 191},
-    { 107, 107, 191},
-    { 131, 131, 191},
-    { 155, 155, 191},
-    { 179, 179, 191},
-    {   0,   0, 104},
-    {  15,  27, 125},
-    {  30,  51, 140},
-    {  45,  75, 155},
-    {  60,  98, 167},
-    {  75, 122, 176},
-    {  90, 140, 185},
-    { 104, 158, 191},
-    {   0,   0,   0},
-    {   0,  24,  24},
-    {   0,  48,  48},
-    {   0,  72,  72},
-    {   0,  95,  95},
-    {   0, 119, 119},
-    {   0, 143, 143},
-    {   0, 167, 167},
-    {   0, 191, 191},
-    {  12, 191, 191},
-    {  24, 191, 191},
-    {  36, 191, 191},
-    {  48, 191, 191},
-    {  60, 191, 191},
-    {  72, 191, 191},
-    {  84, 191, 191},
-    {  95, 191, 191},
-    { 107, 191, 191},
-    { 119, 191, 191},
-    { 131, 191, 191},
-    { 143, 191, 191},
-    { 155, 191, 191},
-    { 167, 191, 191},
-    { 179, 191, 191},
-    {   0,  54,  54},
-    {   9,  69,  69},
-    {  18,  84,  84},
-    {  27,  98,  98},
-    {  39, 110, 110},
-    {  48, 122, 122},
-    {  57, 131, 131},
-    {  66, 143, 143},
-    {  85, 156, 191},
-    {  91, 161, 191},
-    {  96, 166, 191},
-    { 102, 172, 191},
-    { 108, 177, 191},
-    { 114, 182, 191},
-    { 120, 187, 191},
-    { 127, 191, 191},
-    { 101,   0, 131},
-    { 106,  11, 134},
-    { 111,  23, 138},
-    { 117,  35, 142},
-    { 123,  47, 145},
-    { 129,  59, 149},
-    { 134,  71, 153},
-    { 140,  83, 157},
-    { 145,  95, 160},
-    { 151, 106, 164},
-    { 157, 118, 168},
-    { 162, 130, 172},
-    { 168, 142, 175},
-    { 173, 154, 179},
-    { 179, 166, 183},
-    { 185, 179, 187},
-    {  24,   0,  65},
-    {  42,  20,  80},
-    {  61,  41,  95},
-    {  79,  61, 110},
-    {  97,  82, 124},
-    { 115, 101, 139},
-    { 135, 123, 154},
-    { 153, 143, 169},
-    { 191,   0, 191},
-    { 191,  24, 191},
-    { 191,  48, 191},
-    { 191,  72, 191},
-    { 191,  95, 191},
-    { 191, 119, 191},
-    { 191, 143, 191},
-    { 191, 167, 191},
-    {   0, 107,   0},
-    {   0, 191,   0},
-    {  24, 191,  24},
-    {  48, 191,  48},
-    {  72, 191,  72},
-    {  95, 191,  95},
-    { 119, 191, 119},
-    { 143, 191, 143},
-    {  16,  16,   9},
-    {  44,  44,  22},
-    {  73,  73,  36},
-    { 101, 101,  51},
-    { 127, 127,  66},
-    { 142, 142,  93},
-    { 156, 156, 121},
-    { 170, 170, 151},
-    {  31,  10,   0},
-    {  48,  15,   0},
-    {  64,  21,   0},
-    {  79,  25,   0},
-    {  95,  30,   0},
-    { 111,  36,   0},
-    { 127,  41,   0},
-    { 143,  48,   0},
-    { 149,  73,  24},
-    { 155,  84,  48},
-    { 161, 101,  72},
-    { 167, 119,  95},
-    { 191,  48,  48},
-    { 191,  95,  95},
-    { 191, 119, 119},
-    { 191, 143, 143},
-    {  18,  18,   0},
-    {  42,  42,   0},
-    {  61,  61,   0},
-    {  86,  86,   0},
-    { 104, 104,   0},
-    { 129, 129,   0},
-    { 154, 154,   0},
-    { 172, 172,   0},
-    { 191, 191,   0},
-    { 191, 191,  18},
-    { 191, 191,  36},
-    { 191, 191,  55},
-    { 191, 191,  74},
-    { 191, 191,  92},
-    { 191, 191, 110},
-    { 191, 191, 129},
-    { 191, 191, 131},
-    { 191, 191, 143},
-    { 191, 191, 149},
-    { 191, 191, 161},
-    { 191, 191, 167},
-    { 191, 191, 179},
-    { 191, 191, 185},
-    { 191,   0,   0},
-    {  36,  95,  36},
-    {  54, 107,  54},
-    {  72, 119,  72},
-    {  90, 131,  90},
-    { 107, 143, 107},
-    { 125, 155, 125},
-    { 143, 167, 143},
-    { 161, 179, 161}
-};
-
-static const INT16 pPaletteDeltaNuke[256][3] = {
-    {   6,-133,-133},
-    {  12,-125,-125},
-    {  18,-117,-117},
-    {  24,-109,-109},
-    {  30,-101,-101},
-    {  36, -93, -93},
-    {  42, -85, -85},
-    {  48, -77, -77},
-    {  54, -69, -69},
-    {  60, -61, -61},
-    {  66, -53, -53},
-    {  72, -45, -45},
-    {  78, -37, -37},
-    {  84, -29, -29},
-    {  90, -21, -21},
-    {  95, -14, -14},
-    { 101,  -6,  -6},
-    { 107,   2,   2},
-    { 113,  10,  10},
-    { 119,  18,  18},
-    { 125,  26,  26},
-    { 131,  34,  34},
-    { 137,  42,  42},
-    { 143,  50,  50},
-    { 149,  58,  58},
-    { 155,  66,  66},
-    { 161,  74,  74},
-    { 167,  82,  82},
-    { 173,  90,  90},
-    { 179,  98,  98},
-    { 185, 106, 106},
-    { 191, 113, 113},
-    {  48, -53, -29},
-    {  54, -46, -22},
-    {  60, -38, -14},
-    {  66, -30,  -7},
-    {  72, -23,   0},
-    {  79, -15,   8},
-    {  85,  -8,  16},
-    {  91,  -1,  23},
-    {  96,   7,  31},
-    { 102,  15,  39},
-    { 108,  23,  47},
-    { 114,  30,  54},
-    { 120,  38,  62},
-    { 127,  46,  70},
-    { 133,  53,  77},
-    { 140,  62,  86},
-    {  48, -10,  38},
-    {  57,  -2,  42},
-    {  63,   2,  46},
-    {  69,   6,  50},
-    {  75,  14,  54},
-    {  84,  18,  58},
-    {  90,  26,  62},
-    {  95,  30,  66},
-    { 101,  34,  70},
-    { 110,  42,  74},
-    { 119,  46,  78},
-    { 128,  50,  82},
-    { 134,  58,  86},
-    { 143,  66,  90},
-    { 152,  70,  94},
-    { 158,  78,  98},
-    {   0,-121,-109},
-    {   0,-113, -97},
-    {   0,-105, -85},
-    {   0, -97, -73},
-    {   0, -93, -65},
-    {   0, -85, -53},
-    {   0, -77, -41},
-    {   0, -73, -33},
-    {   0, -65, -17},
-    {   6, -57, -10},
-    {  12, -49,  -2},
-    {  18, -41,   6},
-    {  24, -33,  14},
-    {  30, -25,  22},
-    {  36, -17,  30},
-    {  39, -14,  34},
-    {   0,-124,-106},
-    {   0,-106, -71},
-    {   0, -89, -37},
-    {   0, -71,  -4},
-    {   0, -54,  28},
-    {   0, -37,  59},
-    {   0, -20,  88},
-    {   0,  -4, 113},
-    {   9,   4, 113},
-    {  19,  12, 113},
-    {  29,  20, 113},
-    {  39,  28, 113},
-    {  48,  36, 113},
-    {  58,  44, 113},
-    {  68,  52, 113},
-    {  78,  59, 113},
-    {   0,-141,-125},
-    {   0,-141, -93},
-    {   0,-141, -61},
-    {   0,-141, -29},
-    {   0,-141,   2},
-    {   0,-141,  34},
-    {   0,-141,  66},
-    {   0,-141,  98},
-    {   0,-141, 113},
-    {  36, -93, 113},
-    {  60, -61, 113},
-    {  84, -29, 113},
-    { 107,   2, 113},
-    { 131,  34, 113},
-    { 155,  66, 113},
-    { 179,  98, 113},
-    {   0,-141,  -2},
-    {  15,-105,  26},
-    {  30, -73,  46},
-    {  45, -41,  66},
-    {  60, -10,  82},
-    {  75,  22,  94},
-    {  90,  46, 106},
-    { 104,  70, 113},
-    {   0,-141,-141},
-    {   0,-109,-109},
-    {   0, -77, -77},
-    {   0, -45, -45},
-    {   0, -14, -14},
-    {   0,  18,  18},
-    {   0,  50,  50},
-    {   0,  82,  82},
-    {   0, 113, 113},
-    {  12, 113, 113},
-    {  24, 113, 113},
-    {  36, 113, 113},
-    {  48, 113, 113},
-    {  60, 113, 113},
-    {  72, 113, 113},
-    {  84, 113, 113},
-    {  95, 113, 113},
-    { 107, 113, 113},
-    { 119, 113, 113},
-    { 131, 113, 113},
-    { 143, 113, 113},
-    { 155, 113, 113},
-    { 167, 113, 113},
-    { 179, 113, 113},
-    {   0, -69, -69},
-    {   9, -49, -49},
-    {  18, -29, -29},
-    {  27, -10, -10},
-    {  39,   6,   6},
-    {  48,  22,  22},
-    {  57,  34,  34},
-    {  66,  50,  50},
-    {  85,  67, 113},
-    {  91,  74, 113},
-    {  96,  81, 113},
-    { 102,  88, 113},
-    { 108,  95, 113},
-    { 114, 102, 113},
-    { 120, 108, 113},
-    { 127, 113, 113},
-    { 101,-141,  34},
-    { 106,-126,  38},
-    { 111,-110,  43},
-    { 117, -94,  48},
-    { 123, -78,  53},
-    { 129, -62,  58},
-    { 134, -46,  63},
-    { 140, -30,  68},
-    { 145, -14,  73},
-    { 151,   1,  78},
-    { 157,  17,  83},
-    { 162,  33,  88},
-    { 168,  49,  93},
-    { 173,  65,  98},
-    { 179,  81, 103},
-    { 185,  98, 109},
-    {  24,-141, -54},
-    {  42,-114, -34},
-    {  61, -86, -14},
-    {  79, -59,   6},
-    {  97, -32,  25},
-    { 115,  -6,  45},
-    { 135,  23,  65},
-    { 153,  50,  84},
-    { 191,-141, 113},
-    { 191,-109, 113},
-    { 191, -77, 113},
-    { 191, -45, 113},
-    { 191, -14, 113},
-    { 191,  18, 113},
-    { 191,  50, 113},
-    { 191,  82, 113},
-    {   0,   2,-141},
-    {   0, 113,-141},
-    {  24, 113,-109},
-    {  48, 113, -77},
-    {  72, 113, -45},
-    {  95, 113, -14},
-    { 119, 113,  18},
-    { 143, 113,  50},
-    {  16,-119,-129},
-    {  44, -82,-111},
-    {  73, -43, -92},
-    { 101,  -6, -73},
-    { 127,  29, -53},
-    { 142,  48, -17},
-    { 156,  67,  21},
-    { 170,  86,  61},
-    {  31,-127,-141},
-    {  48,-121,-141},
-    {  64,-113,-141},
-    {  79,-107,-141},
-    {  95,-100,-141},
-    { 111, -93,-141},
-    { 127, -86,-141},
-    { 143, -77,-141},
-    { 149, -43,-109},
-    { 155, -29, -77},
-    { 161,  -6, -45},
-    { 167,  18, -14},
-    { 191, -77, -77},
-    { 191, -14, -14},
-    { 191,  18,  18},
-    { 191,  50,  50},
-    {  18,-117,-141},
-    {  42, -84,-141},
-    {  61, -59,-141},
-    {  86, -26,-141},
-    { 104,  -2,-141},
-    { 129,  31,-141},
-    { 154,  64,-141},
-    { 172,  89,-141},
-    { 191, 113,-141},
-    { 191, 113,-117},
-    { 191, 113, -92},
-    { 191, 113, -67},
-    { 191, 113, -42},
-    { 191, 113, -18},
-    { 191, 113,   6},
-    { 191, 113,  31},
-    { 191, 113,  34},
-    { 191, 113,  50},
-    { 191, 113,  58},
-    { 191, 113,  74},
-    { 191, 113,  82},
-    { 191, 113,  98},
-    { 191, 113, 106},
-    { 191,-141,-141},
-    {  36, -14, -93},
-    {  54,   2, -69},
-    {  72,  18, -45},
-    {  90,  34, -21},
-    { 107,  50,   2},
-    { 125,  66,  26},
-    { 143,  82,  50},
-    { 161,  98,  74}
-};
-
-#endif

src/v_video.c

@@ -91,7 +91,6 @@ consvar_t cv_menucaps = {"menucaps", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NUL
 // local copy of the palette for V_GetColor()
 RGBA_t *pLocalPalette = NULL;
 RGBA_t *pGammaCorrectedPalette = NULL;
-static RGBA_t *pFallbackFlashPal = NULL;
 
 static size_t currentPaletteSize;
 
@@ -410,58 +409,6 @@ UINT32 V_GammaCorrect(UINT32 input, double power)
 	return result.rgba;
 }
 
-#include "v_paldeltas.h"
-// remaps a palette with given "deltas"
-// this is used with premade deltas between the srb2 palette and its both flashpals
-// so we may approximate generate our own, should the current palette miss them
-static void ApplyPaletteDelta(const RGBA_t *pal_in, RGBA_t *pal_out, const INT16 pal_delta[][3])
-{
-	size_t i;
-
-	for (i = 0; i < 256; i++)
-	{
-		INT16 r = (INT16)pal_in[i].s.red   + pal_delta[i][0];
-		INT16 g = (INT16)pal_in[i].s.green + pal_delta[i][1];
-		INT16 b = (INT16)pal_in[i].s.blue  + pal_delta[i][2];
-		pal_out[i].s.red   = (UINT8)CLAMP(r, 0 , 255);
-		pal_out[i].s.green = (UINT8)CLAMP(g, 0 , 255);
-		pal_out[i].s.blue  = (UINT8)CLAMP(b, 0 , 255);
-		pal_out[i].s.alpha = 0xFF; // pal_in[i].s.alpha
-	}
-}
-
-static void GenerateFlashPalettes(void)
-{
-	size_t i, palsize;
-	RGBA_t *pFlashPalGammaCorrectedPalette = NULL;
-
-	// generate flashpalettes if the current palette does not provide any subpalettes
-	if (currentPaletteSize >= (14 * (256 * 3))) // 14 palettes are in playpal
-		return;
-
-	palsize = (2*256);
-
-	pFallbackFlashPal = Z_Malloc(sizeof(*pFallbackFlashPal)*palsize, PU_STATIC, NULL);
-	pFlashPalGammaCorrectedPalette = Z_Malloc(sizeof (*pFlashPalGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
-
-	// apply our deltas to the palettes to get the white and red "flashes"
-	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal, pPaletteDeltaFlash);
-	ApplyPaletteDelta(pLocalPalette, pFallbackFlashPal+256, pPaletteDeltaNuke);
-
-	// apply colour and gamma correction if needed
-	if (Cubeapply)
-	{
-		for (i = 0; i < palsize; i++)
-		{
-			pFlashPalGammaCorrectedPalette[i].rgba = V_GammaDecode(pFallbackFlashPal[i].rgba);
-			V_CubeApply(&pFlashPalGammaCorrectedPalette[i]);
-			pFallbackFlashPal[i].rgba = V_GammaEncode(pFlashPalGammaCorrectedPalette[i].rgba);
-		}
-	}
-
-	Z_Free(pFlashPalGammaCorrectedPalette);
-}
-
 // keep a copy of the palette so that we can get the RGB value for a color index at any time.
 static void LoadPalette(const char *lumpname)
 {
@@ -481,8 +428,6 @@ static void LoadPalette(const char *lumpname)
 
 	Z_Free(pLocalPalette);
 	Z_Free(pGammaCorrectedPalette);
-	Z_Free(pFallbackFlashPal);
-	pFallbackFlashPal = NULL;
 
 	pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
 	pGammaCorrectedPalette = Z_Malloc(sizeof (*pGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
@@ -502,19 +447,12 @@ static void LoadPalette(const char *lumpname)
 		pLocalPalette[i].s.alpha = 0xFF;
 
 		pGammaCorrectedPalette[i].rgba = V_GammaDecode(pLocalPalette[i].rgba);
-	}
 
-	GenerateFlashPalettes();
+		if (!Cubeapply)
+			continue;
 
-	// gotta apply any colour and gamma adjustments afterwards
-	// so we dont double apply it to the generated flashpals
-	if (Cubeapply)
-	{
-		for (i = 0; i < palsize; i++)
-		{
-			V_CubeApply(&pGammaCorrectedPalette[i]);
-			pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
-		}
+		V_CubeApply(&pGammaCorrectedPalette[i]);
+		pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
 	}
 }
 
@@ -605,7 +543,6 @@ void V_ReloadPalette(void)
 // -------------+
 void V_SetPalette(INT32 palettenum)
 {
-	RGBA_t *pal = NULL;
 	if (!pLocalPalette)
 		V_ReloadPalette();
 
@@ -617,47 +554,24 @@ void V_SetPalette(INT32 palettenum)
 		if (palettenum == 0)
 		{
 			palettenum = cv_palettenum.value;
-		}
-	}
 
-	// in many cases custom palettes do not provide the needed subpalettes for flashpals to work
-	// before this would mean the renderer gets passed random data out of allocated memory bounds
-	// which was not very cool :chonkbuncle:
-	// gladly 2.1 only actually has 2 different subpalettes
-	// one for "white flash" and one red/pinkish one for nuke
-	// since we checked the palette earlier we should have generated those ourselves
-	if (((size_t)palettenum >= currentPaletteSize / (256 * 3)))
-	{
-		CONS_Debug(DBG_RENDER, "palettenum %d out of range\n", palettenum);
-
-		// if for some reason we did not generate flashpals
-		// just fall back to the main palette i guess?
-		if (pFallbackFlashPal != NULL)
-		{
-			if (palettenum == PAL_NUKE)
-				pal = &pFallbackFlashPal[256];
-			else
-				pal = pFallbackFlashPal;
+			if (palettenum * 256U > currentPaletteSize - 256)
+			{
+				CONS_Alert(CONS_WARNING, "cv_palettenum %d out of range\n", palettenum);
+				palettenum = 0;
+			}
 		}
-		else
-		{
-			pal = pLocalPalette;
-		}
-	}
-	else
-	{
-		pal = &pLocalPalette[palettenum*256];
 	}
 
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_SetPalette(pal);
+		HWR_SetPalette(&pLocalPalette[palettenum*256]);
 #if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
 	else
 #endif
 #endif
 	if (rendermode != render_none)
-		I_SetPalette(pal);
+		I_SetPalette(&pLocalPalette[palettenum*256]);
 }
 
 void V_SetPaletteLump(const char *pal)
@@ -3395,6 +3309,167 @@ INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option)
 	return max(i-1, 0);
 }
 
+char V_GetSkincolorChar(INT32 color)
+{
+	char cstart = 0x80;
+
+	switch (color)
+	{
+		case SKINCOLOR_WHITE:
+		case SKINCOLOR_SILVER:
+		case SKINCOLOR_SLATE:
+			cstart = 0x80; // White
+			break;
+
+		case SKINCOLOR_GREY:
+		case SKINCOLOR_NICKEL:
+		case SKINCOLOR_BLACK:
+		case SKINCOLOR_SKUNK:
+		case SKINCOLOR_JET:
+			cstart = 0x86; // V_GRAYMAP
+			break;
+
+		case SKINCOLOR_SEPIA:
+		case SKINCOLOR_BEIGE:
+		case SKINCOLOR_WALNUT:
+		case SKINCOLOR_BROWN:
+		case SKINCOLOR_LEATHER:
+		case SKINCOLOR_RUST:
+		case SKINCOLOR_WRISTWATCH:
+			cstart = 0x8e; // V_BROWNMAP
+			break;
+
+		case SKINCOLOR_FAIRY:
+		case SKINCOLOR_SALMON:
+		case SKINCOLOR_PINK:
+		case SKINCOLOR_ROSE:
+		case SKINCOLOR_BRICK:
+		case SKINCOLOR_LEMONADE:
+		case SKINCOLOR_BUBBLEGUM:
+		case SKINCOLOR_LILAC:
+			cstart = 0x8d; // V_PINKMAP
+			break;
+
+		case SKINCOLOR_CINNAMON:
+		case SKINCOLOR_RUBY:
+		case SKINCOLOR_RASPBERRY:
+		case SKINCOLOR_CHERRY:
+		case SKINCOLOR_RED:
+		case SKINCOLOR_CRIMSON:
+		case SKINCOLOR_MAROON:
+		case SKINCOLOR_FLAME:
+		case SKINCOLOR_SCARLET:
+		case SKINCOLOR_KETCHUP:
+			cstart = 0x85; // V_REDMAP
+			break;
+
+		case SKINCOLOR_DAWN:
+		case SKINCOLOR_SUNSET:
+		case SKINCOLOR_CREAMSICLE:
+		case SKINCOLOR_ORANGE:
+		case SKINCOLOR_PUMPKIN:
+		case SKINCOLOR_ROSEWOOD:
+		case SKINCOLOR_BURGUNDY:
+		case SKINCOLOR_TANGERINE:
+			cstart = 0x87; // V_ORANGEMAP
+			break;
+
+		case SKINCOLOR_PEACH:
+		case SKINCOLOR_CARAMEL:
+		case SKINCOLOR_CREAM:
+			cstart = 0x8f; // V_PEACHMAP
+			break;
+
+		case SKINCOLOR_GOLD:
+		case SKINCOLOR_ROYAL:
+		case SKINCOLOR_BRONZE:
+		case SKINCOLOR_COPPER:
+		case SKINCOLOR_THUNDER:
+			cstart = 0x8a; // V_GOLDMAP
+			break;
+
+		case SKINCOLOR_POPCORN:
+		case SKINCOLOR_QUARRY:
+		case SKINCOLOR_YELLOW:
+		case SKINCOLOR_MUSTARD:
+		case SKINCOLOR_CROCODILE:
+		case SKINCOLOR_OLIVE:
+			cstart = 0x82; // V_YELLOWMAP
+			break;
+
+		case SKINCOLOR_ARTICHOKE:
+		case SKINCOLOR_VOMIT:
+		case SKINCOLOR_GARDEN:
+		case SKINCOLOR_TEA:
+		case SKINCOLOR_PISTACHIO:
+			cstart = 0x8b; // V_TEAMAP
+			break;
+
+		case SKINCOLOR_LIME:
+		case SKINCOLOR_HANDHELD:
+		case SKINCOLOR_MOSS:
+		case SKINCOLOR_CAMOUFLAGE:
+		case SKINCOLOR_ROBOHOOD:
+		case SKINCOLOR_MINT:
+		case SKINCOLOR_GREEN:
+		case SKINCOLOR_PINETREE:
+		case SKINCOLOR_EMERALD:
+		case SKINCOLOR_SWAMP:
+		case SKINCOLOR_DREAM:
+		case SKINCOLOR_PLAGUE:
+		case SKINCOLOR_ALGAE:
+			cstart = 0x83; // V_GREENMAP
+			break;
+
+		case SKINCOLOR_CARIBBEAN:
+		case SKINCOLOR_AZURE:
+		case SKINCOLOR_AQUA:
+		case SKINCOLOR_TEAL:
+		case SKINCOLOR_CYAN:
+		case SKINCOLOR_JAWZ:
+		case SKINCOLOR_CERULEAN:
+		case SKINCOLOR_NAVY:
+		case SKINCOLOR_SAPPHIRE:
+			cstart = 0x88; // V_SKYMAP
+			break;
+
+		case SKINCOLOR_PIGEON:
+		case SKINCOLOR_PLATINUM:
+		case SKINCOLOR_STEEL:
+			cstart = 0x8c; // V_STEELMAP
+			break;
+
+		case SKINCOLOR_PERIWINKLE:
+		case SKINCOLOR_BLUE:
+		case SKINCOLOR_BLUEBERRY:
+		case SKINCOLOR_NOVA:
+			cstart = 0x84; // V_BLUEMAP
+			break;
+
+		case SKINCOLOR_ULTRAVIOLET:
+		case SKINCOLOR_PURPLE:
+		case SKINCOLOR_FUCHSIA:
+			cstart = 0x81; // V_PURPLEMAP
+			break;
+
+		case SKINCOLOR_PASTEL:
+		case SKINCOLOR_MOONSLAM:
+		case SKINCOLOR_DUSK:
+		case SKINCOLOR_TOXIC:
+		case SKINCOLOR_MAUVE:
+		case SKINCOLOR_LAVENDER:
+		case SKINCOLOR_BYZANTIUM:
+		case SKINCOLOR_POMEGRANATE:
+			cstart = 0x89; // V_LAVENDERMAP
+			break;
+
+		default:
+			break;
+	}
+
+	return cstart;
+}
+
 INT32 V_SkinColorToHighlightcolor(skincolors_t color)
 {
 	switch (color)

src/v_video.h

@@ -287,6 +287,8 @@ INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 option);
 // Find maximum length for substring taken from current string to fit into given width
 INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option);
 
+char V_GetSkincolorChar(INT32 color);
+
 INT32 V_SkinColorToHighlightcolor(skincolors_t color);
 
 // this is pretty dumb, but has to be done like this, otherwise the fps counter just disappears sometimes for no reason lol

src/w_wad.c

@@ -87,32 +87,18 @@ typedef struct
 } lumpchecklist_t;
 
 // Must be a power of two
-#define LUMPNUMCACHESIZE 2048 // should be reasonable ig
+#define LUMPNUMCACHESIZE 64
 #define LUMPNUMCACHENAME 32
 
-#define NAME      lumpnum_map
-#define KEY_TY    char *
-#define KEY_GET_CONST
-#define VAL_TY    lumpnum_t
-#define HASH_FN   vt_hash_string
-#define CMPR_FN   vt_cmpr_string
-#define KEY_DTOR_FN free
-#include "verstable.h"
+typedef struct lumpnum_cache_s
+{
+	char lumpname[LUMPNUMCACHENAME];
+	lumpnum_t lumpnum;
+	UINT32 hash;
+} lumpnum_cache_t;
 
-#define NAME      folder_map
-#define KEY_TY    char *
-#define KEY_GET_CONST
-#define VAL_TY    UINT16
-#define HASH_FN   vt_hash_string
-#define CMPR_FN   vt_cmpr_string
-#define KEY_DTOR_FN free
-#include "verstable.h"
-
-static lumpnum_map lumpnumcache;
-
-typedef struct FolderCache {
-	folder_map map;
-} FolderCache;
+static lumpnum_cache_t lumpnumcache[LUMPNUMCACHESIZE];
+static UINT16 lumpnumcacheindex = 0;
 
 static const char pat_central[] = {0x50, 0x4b, 0x01, 0x02, 0x00};
 static const char pat_end[] = {0x50, 0x4b, 0x05, 0x06, 0x00};
@@ -130,8 +116,6 @@ wadfile_t *wadfiles[MAX_WADFILES] = {}; // 0 to numwadfiles-1 are valid
 // being ejected
 void W_Shutdown(void)
 {
-	lumpnum_map_cleanup(&lumpnumcache);
-
 	while (numwadfiles--)
 	{
 		wadfile_t *wad = wadfiles[numwadfiles];
@@ -143,28 +127,18 @@ void W_Shutdown(void)
 
 		while (wad->numlumps--)
 		{
-			//Z_Free(wad->lumpinfo[wad->numlumps].longname);
+			Z_Free(wad->lumpinfo[wad->numlumps].longname);
 			Z_Free(wad->lumpinfo[wad->numlumps].fullname);
 		}
 
-		folder_map_cleanup(&wad->startfolders->map);
-		free(wad->startfolders);
-		folder_map_cleanup(&wad->endfolders->map);
-		free(wad->endfolders);
+		M_AATreeFree(wad->startfolders);
+		M_AATreeFree(wad->endfolders);
 
 		Z_Free(wad->lumpinfo);
 		Z_Free(wad);
 	}
 }
 
-// the lumpnum cache needs to be initialized before use
-// call this as early as possible!
-void W_Startup(void)
-{
-	lumpnum_map_init(&lumpnumcache);
-	lumpnum_map_reserve(&lumpnumcache, LUMPNUMCACHESIZE);
-}
-
 //===========================================================================
 //                                                        LUMP BASED ROUTINES
 //===========================================================================
@@ -285,7 +259,7 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum)
 			lumpinfo_t *lump_p = &wadfiles[wadnum]->lumpinfo[posStart];
 
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = (char *)(malloc(length + 1));
+			char *name = malloc(length + 1);
 
 			if (!name)
 				I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n");
@@ -321,7 +295,7 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum)
 		if (memcmp(lump_p->name, "SOC_", 4) == 0) // Check for generic SOC lump
 		{   // shameless copy+paste of code from LUA_LoadLump
 			size_t length = len + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
-			char *name = (char *)(malloc(length + 1));
+			char *name = malloc(length + 1);
 
 			if (!name)
 				I_Error("W_LoadDehackedLumps: Out of memory!\n");
@@ -365,7 +339,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 
 	if ((fhandle = fopen(filename, "rb")) != NULL)
 	{
-		precise_t t = I_GetPreciseTime();
+		tic_t t = I_GetTime();
 
 		CONS_Debug(DBG_SETUP, "Making MD5 for %s\n",filename);
 
@@ -376,7 +350,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 		}
 
 		CONS_Debug(DBG_SETUP, "MD5 calc for %s took %f seconds\n",
-			filename, (float)(I_GetPreciseTime() - t)/I_GetPrecisePrecision());
+			filename, (float)(I_GetTime() - t)/NEWTICRATE);
 
 		fclose(fhandle);
 		return 0;
@@ -386,12 +360,12 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
 }
 
 // Invalidates the cache of lump numbers. Call this whenever a wad is added.
-FUNCINLINE static ATTRINLINE void W_InvalidateLumpnumCache(void)
+static void W_InvalidateLumpnumCache(void)
 {
-	lumpnum_map_clear(&lumpnumcache);
+	memset(lumpnumcache, 0, sizeof(lumpnumcache));
 }
 
-FUNCINLINE static ATTRINLINE UINT32 W_HashLumpName(const char *name)
+UINT32 W_HashLumpName(const char *name)
 {
 	return FNV1a_HashLowercaseString(name);
 }
@@ -417,28 +391,28 @@ static restype_t ResourceFileDetect(const char* filename)
  */
 static lumpinfo_t* ResGetLumpsStandalone(FILE* handle, UINT16* numlumps, const char* lumpname)
 {
-	lumpinfo_t* lumpinfo = (lumpinfo_t *)(Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL));
+	lumpinfo_t* lumpinfo = Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL);
 	lumpinfo->position = 0;
 	fseek(handle, 0, SEEK_END);
-	lumpinfo->size = (size_t)(ftell(handle));
+	lumpinfo->size = ftell(handle);
 	fseek(handle, 0, SEEK_SET);
 	strlcpy(lumpinfo->name, lumpname, sizeof(lumpinfo->name));
 	lumpinfo->namelength = strlen(lumpinfo->name);
 	lumpinfo->hash.name = W_HashLumpName(lumpname);
 
 	// Allocate the lump's long name.
-	/*lumpinfo->longname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
+	lumpinfo->longname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
 	strcpy(lumpinfo->longname, lumpname);
 	lumpinfo->longname[lumpinfo->namelength] = '\0';
 	lumpinfo->longnamelength = lumpinfo->namelength;
-	lumpinfo->hash.longname = lumpinfo->hash.name;*/
+	lumpinfo->hash.longname = lumpinfo->hash.name;
 
 	// Allocate the lump's full name.
-	lumpinfo->fullname = (char *)(Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL));
+	lumpinfo->fullname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
 	strcpy(lumpinfo->fullname, lumpname);
 	lumpinfo->fullname[lumpinfo->namelength] = '\0';
 	lumpinfo->fullnamelength = lumpinfo->namelength;
-	//lumpinfo->hash.fullname = lumpinfo->hash.name;
+	lumpinfo->hash.fullname = lumpinfo->hash.name;
 
 	*numlumps = 1;
 	return lumpinfo;
@@ -481,8 +455,8 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 	header.infotableofs = LONG(header.infotableofs);
 
 	// read wad file directory
-	i = header.numlumps * sizeof(*fileinfo);
-	fileinfov = fileinfo = (filelump_t *)(malloc(i));
+	i = header.numlumps * sizeof (*fileinfo);
+	fileinfov = fileinfo = malloc(i);
 
 	if (fseek(handle, header.infotableofs, SEEK_SET) == -1
 	 || fread(fileinfo, 1, i, handle) < i)
@@ -494,7 +468,7 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 	numlumps = header.numlumps;
 
 	// fill in lumpinfo for this wad
-	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
+	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
 
 	for (i = 0; i < numlumps; i++, lump_p++, fileinfo++)
 	{
@@ -538,18 +512,18 @@ static lumpinfo_t* ResGetLumpsWad(FILE* handle, UINT16* nlmp, const char* filena
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
 		// Allocate the lump's long name.
-		/*lump_p->longname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
+		lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
 		strncpy(lump_p->longname, fileinfo->name, 8);
 		lump_p->longname[8] = '\0';
 		lump_p->longnamelength = lump_p->namelength;
-		lump_p->hash.longname = lump_p->hash.name;*/
+		lump_p->hash.longname = lump_p->hash.name;
 
 		// Allocate the lump's full name.
-		lump_p->fullname = (char *)(Z_Malloc(9 * sizeof(char), PU_STATIC, NULL));
+		lump_p->fullname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
 		strncpy(lump_p->fullname, fileinfo->name, 8);
 		lump_p->fullname[8] = '\0';
 		lump_p->fullnamelength = lump_p->namelength;
-		//lump_p->hash.fullname = lump_p->hash.name;
+		lump_p->hash.fullname = lump_p->hash.name;
 	}
 
 	*nlmp = numlumps;
@@ -566,24 +540,24 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 	int c;
 
 	fseek(handle, 0, SEEK_END);
-	size_t len = (size_t)(ftell(handle));
+	size_t len = ftell(handle);
 
 	fseek(handle, startpos, SEEK_SET);
-	size_t remaining = (size_t)(len - startpos);
-	size_t chunkpos = (size_t)(startpos);
+	size_t remaining = len - startpos;
+	size_t chunkpos = startpos;
 
 	s = endPat;
 
 	//128k buffers
 	size_t buffer_size = min(128 * 1024 * sizeof(char), remaining);
-	CLEANUP(pfree) char* buffer = (char *)(malloc(buffer_size));
+	CLEANUP(pfree) char* buffer = (char*)(malloc(buffer_size));
 
 	size_t bytes_read = 0;
 	while ((bytes_read = fread(buffer, 1, buffer_size, handle)) > 0)
 	{
 		for (size_t i = 0; i < bytes_read; i++)
 		{
-			c = (int)(buffer[i]);
+			c = (int)buffer[i];
 
 			if (*s != c && s > endPat) // No match?
 				s = endPat; // We "reset" the counter by sending the s pointer back to the start of the array.
@@ -595,7 +569,7 @@ static boolean ResFindSignature(FILE* handle, const char endPat[], UINT32 startp
 				if (*s == 0x00) // The array pointer has reached the key char which marks the end. It means we have matched the signature.
 				{
 					//the original function would leave the FILE* seeked to the end of the match
-					size_t foundpos = (size_t)(chunkpos + i + 1);
+					size_t foundpos = chunkpos + i + 1;
 					fseek(handle, foundpos, SEEK_SET);
 					return true;
 				}
@@ -672,7 +646,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 	// Contains entry number (number of lumps), and central directory start offset.
 	fseek(handle, 0, SEEK_END);
 
-	const long startpos = ftell(handle) - (22 + 65536);
+	const long startpos = (ftell(handle) - (22 + 65536));
 	if (!ResFindSignature(handle, pat_end, max(0l, startpos)))
 	{
 		CONS_Alert(CONS_ERROR, "Missing central directory\n");
@@ -688,11 +662,11 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	numlumps = SHORT(zend.entries);
 
-	lump_p = lumpinfo = (lumpinfo_t *)(Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL));
+	lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL);
 
 	fseek(handle, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(Z_Pfree) char *cdir = (char *)(Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir));
+	CLEANUP(Z_Pfree) char *cdir = Z_Malloc(LONG(zend.cdirsize), PU_STATIC, &cdir);
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), handle) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -705,7 +679,7 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 
 	for (i = 0; i < numlumps; i++, lump_p++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -721,9 +695,8 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->disksize = LONG(zentry->compsize);
 		lump_p->size = LONG(zentry->size);
 
-		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-		fullname[zentry->namelen] = 0;
+		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -739,15 +712,15 @@ static lumpinfo_t* ResGetLumpsZip(FILE* handle, UINT16* nlmp)
 		lump_p->namelength = strlen(lump_p->name);
 		lump_p->hash.name = W_HashLumpName(lump_p->name);
 
-		/*lump_p->longname = (char *)(Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL));
+		lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL);
 		strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
 		lump_p->longnamelength = strlen(lump_p->longname);
-		lump_p->hash.longname = W_HashLumpName(lump_p->longname);*/
+		lump_p->hash.longname = W_HashLumpName(lump_p->longname);
 
-		lump_p->fullname = (char *)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
+		lump_p->fullname = (char*)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
 		strncpy(lump_p->fullname, fullname, SHORT(zentry->namelen));
 		lump_p->fullnamelength = zentry->namelen;
-		//lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
+		lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
 
 		switch(SHORT(zentry->compression))
 		{
@@ -922,19 +895,17 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 	//
 	// link wad file to search files
 	//
-	wadfile = (wadfile_t *)(Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL));
+	wadfile = Z_Calloc(sizeof (*wadfile), PU_STATIC, NULL);
 	wadfile->filename = Z_StrDup(filename);
 	wadfile->handle = handle;
-	wadfile->numlumps = (UINT16)(numlumps);
+	wadfile->numlumps = (UINT16)numlumps;
 	wadfile->lumpinfo = lumpinfo;
 	wadfile->important = important;
 	fseek(handle, 0, SEEK_END);
-	wadfile->filesize = (unsigned)(ftell(handle));
+	wadfile->filesize = (unsigned)ftell(handle);
 	wadfile->type = type;
-	wadfile->startfolders = (FolderCache *)malloc(sizeof(FolderCache));
-	folder_map_init(&wadfile->startfolders->map);
-	wadfile->endfolders = (FolderCache *)malloc(sizeof(FolderCache));
-	folder_map_init(&wadfile->endfolders->map);
+	wadfile->startfolders = M_AATreeAlloc(AATREE_STRING);
+	wadfile->endfolders = M_AATreeAlloc(AATREE_STRING);
 
 	// already generated, just copy it over
 	memcpy(&wadfile->md5sum, &md5sum, 16);
@@ -959,7 +930,7 @@ UINT16 W_InitFile(const char *filename, boolean local, boolean startup)
 #ifdef HWRENDER
 	// Read shaders from file
 	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
-		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (boolean)(type == RET_PK3));
+		HWR_LoadCustomShadersFromFile(numwadfiles - 1, (type == RET_PK3));
 #endif
 
 	// TODO: HACK ALERT - Load Lua & SOC stuff right here. I feel like this should be out of this place, but... Let's stick with this for now.
@@ -1059,7 +1030,7 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames)
 /** Make sure a lump number is valid.
   * Compiles away to nothing if PARANOIA is not defined.
   */
-static inline boolean TestValidLump(UINT16 wad, UINT16 lump)
+static boolean TestValidLump(UINT16 wad, UINT16 lump)
 {
 	I_Assert(wad < MAX_WADFILES);
 	if (!wadfiles[wad]) // make sure the wad file exists
@@ -1082,7 +1053,7 @@ const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump)
 
 const char *W_CheckNameForNum(lumpnum_t lumpnum)
 {
-	return W_CheckNameForNumPwad(WADFILENUM(lumpnum), LUMPNUM(lumpnum));
+	return W_CheckNameForNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum));
 }
 
 //
@@ -1136,7 +1107,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
+UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 i;
 	UINT32 hash;
@@ -1168,46 +1139,43 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
 
 	// not found.
 	return INT16_MAX;
-}*/
+}
 
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump)
 {
 	UINT16 marker;
-
 	marker = W_CheckNumForNamePwad(name, wad, startlump);
 	if (marker != INT16_MAX)
 		marker++; // Do not count the first marker
-
 	return marker;
 }
 
 // Look for the first lump from a folder.
 UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	size_t name_length;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
+	name_length = strlen(name);
 
-	folder_map_itr it = folder_map_get(&wadfiles[wad]->startfolders->map, name);
-	if (!folder_map_is_end(it))
-		return it.data->val;
-
-	namelen = strlen(name);
+	void *val = M_AATreeGetString(wadfiles[wad]->startfolders, name);
+	if (val != NULL)
+		return (uintptr_t)val;
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, namelen) == 0)
+		if (strnicmp(name, lump_p->fullname, name_length) == 0)
 		{
 			/* SLADE is special and puts a single directory entry. Skip that. */
-			if (lump_p->fullnamelength == namelen)
+			if (strlen(lump_p->fullname) == name_length)
 				i++;
 
-			folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), i);
+			M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)(uintptr_t)i);
 			return i;
 		}
 	}
 
-	folder_map_insert(&wadfiles[wad]->startfolders->map, strdup(name), INT16_MAX);
+	M_AATreeSetString(wadfiles[wad]->startfolders, name, (void *)INT16_MAX);
 	return INT16_MAX;
 }
 
@@ -1216,23 +1184,21 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 // Returns the position of the lumpinfo entry.
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
+	size_t name_length = strlen(name);
 
-	folder_map_itr it = folder_map_get(&wadfiles[wad]->endfolders->map, name);
-	if (!folder_map_is_end(it))
-		return it.data->val;
-
-	namelen = strlen(name);
+	void *val = M_AATreeGetString(wadfiles[wad]->endfolders, name);
+	if (val != NULL)
+		return (uintptr_t)val;
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (strnicmp(name, lump_p->fullname, namelen))
+		if (strnicmp(name, lump_p->fullname, name_length))
 			break;
 	}
 
-	folder_map_insert(&wadfiles[wad]->endfolders->map, strdup(name), i);
+	M_AATreeSetString(wadfiles[wad]->endfolders, name, (void *)(uintptr_t)i);
 	return i;
 }
 
@@ -1240,15 +1206,13 @@ UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
 // Returns lump position in PK3's lumpinfo, or INT16_MAX if not found.
 UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 {
-	UINT16 i;
-	size_t namelen;
+	INT32 i;
 	lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
-
-	namelen = strlen(name);
+	size_t name_length = strlen(name);
 
 	for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
 	{
-		if (!strnicmp(name, lump_p->fullname, namelen))
+		if (!strnicmp(name, lump_p->fullname, name_length))
 		{
 			return i;
 		}
@@ -1258,19 +1222,61 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
 	return INT16_MAX;
 }
 
-FUNCINLINE static ATTRINLINE lumpnum_t CheckLumpInCache(const char *name)
+static lumpnum_t CheckLumpInCache(const char *name, boolean longname)
 {
-	lumpnum_map_itr it = lumpnum_map_get(&lumpnumcache, name);
-	if (!lumpnum_map_is_end(it))
-		return it.data->val;
+	if (longname)
+	{
+		UINT32 hash = quickncasehash(name, 32);
+
+		// Loop backwards so that we check most recent entries first
+		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+		{
+			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+				&& fasticmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name))
+			{
+				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+				return lumpnumcache[lumpnumcacheindex].lumpnum;
+			}
+		}
+	}
+	else
+	{
+		UINT32 hash = quickncasehash(name, 8);
+
+		// Loop backwards so that we check most recent entries first
+		for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+		{
+			if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+				&& lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8] == '\0'
+				&& strnicmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0)
+			{
+				lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+				return lumpnumcache[lumpnumcacheindex].lumpnum;
+			}
+		}
+	}
 
 	return LUMPERROR;
 }
 
-FUNCINLINE static ATTRINLINE void AddLumpToCache(lumpnum_t lumpnum, const char *name)
+static void AddLumpToCache(lumpnum_t lumpnum, const char *name, boolean longname)
 {
-	I_Assert(strlen(name) <= 8); // we dont have longnames, so assume this is a non terminated string
-	lumpnum_map_insert(&lumpnumcache, strdup(name), lumpnum);
+	if (longname && strlen(name) >= LUMPNUMCACHENAME)
+		return;
+
+	lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
+	memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', LUMPNUMCACHENAME);
+	if (longname)
+	{
+		strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, LUMPNUMCACHENAME);
+		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, LUMPNUMCACHENAME);
+	}
+	else
+	{
+		strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8);
+		lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, 8);
+	}
+	lumpnumcache[lumpnumcacheindex].lumpnum = lumpnum;
 }
 
 //
@@ -1286,14 +1292,14 @@ lumpnum_t W_CheckNumForName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
+	lumpnum_t cachenum = CheckLumpInCache(name, false);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForNamePwad(name, (UINT16)(i), 0);
+		check = W_CheckNumForNamePwad(name, (UINT16)i, 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1307,7 +1313,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name);
+		AddLumpToCache(lumpnum, name, false);
 
 		return lumpnum;
 	}
@@ -1319,7 +1325,7 @@ lumpnum_t W_CheckNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*lumpnum_t W_CheckNumForLongName(const char *name)
+lumpnum_t W_CheckNumForLongName(const char *name)
 {
 	INT32 i;
 	lumpnum_t check = INT16_MAX;
@@ -1328,14 +1334,14 @@ lumpnum_t W_CheckNumForName(const char *name)
 		return LUMPERROR;
 
 	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
+	lumpnum_t cachenum = CheckLumpInCache(name, true);
 	if (cachenum != LUMPERROR)
 		return cachenum;
 
 	// scan wad files backwards so patch lump files take precedence
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
-		check = W_CheckNumForLongNamePwad(name, (UINT16)(i), 0);
+		check = W_CheckNumForLongNamePwad(name, (UINT16)i, 0);
 
 		if (check != INT16_MAX)
 			break; //found it
@@ -1349,11 +1355,11 @@ lumpnum_t W_CheckNumForName(const char *name)
 	{
 		// Update the cache.
 		lumpnum_t lumpnum = (i << 16) | check;
-		AddLumpToCache(lumpnum, name);
+		AddLumpToCache(lumpnum, name, true);
 
 		return lumpnum;
 	}
-}*/
+}
 
 //
 // W_GetNumForName
@@ -1378,7 +1384,7 @@ lumpnum_t W_GetNumForName(const char *name)
 // Should be the only version, but that's not possible until we fix
 // all the instances of non null-terminated strings in the codebase...
 //
-/*lumpnum_t W_GetNumForLongName(const char *name)
+lumpnum_t W_GetNumForLongName(const char *name)
 {
 	lumpnum_t i;
 
@@ -1388,7 +1394,7 @@ lumpnum_t W_GetNumForName(const char *name)
 		I_Error("W_GetNumForLongName: %s not found!\n", name);
 
 	return i;
-}*/
+}
 
 //
 // W_CheckNumForNameInBlock
@@ -1405,49 +1411,32 @@ lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, con
 	{
 		if (wadfiles[i]->type == RET_WAD)
 		{
-			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)(i), 0);
+			bsid = W_CheckNumForNamePwad(blockstart, (UINT16)i, 0);
 			if (bsid == INT16_MAX)
 				continue; // Start block doesn't exist?
-			beid = W_CheckNumForNamePwad(blockend, (UINT16)(i), 0);
+			beid = W_CheckNumForNamePwad(blockend, (UINT16)i, 0);
 			if (beid == INT16_MAX)
 				continue; // End block doesn't exist?
 
-			check = W_CheckNumForNamePwad(name, (UINT16)(i), bsid);
+			check = W_CheckNumForNamePwad(name, (UINT16)i, bsid);
 			if (check < beid)
-				return (i << 16)+check; // found it, in our constraints
+				return (i<<16)+check; // found it, in our constraints
 		}
 	}
-
 	return LUMPERROR;
 }
 
 // Used by Lua. Case sensitive lump checking, quickly...
 UINT8 W_LumpExists(const char *name)
 {
-	INT32 i, j;
-	UINT32 hash;
-	size_t namelen;
-
-	// Check the lumpnumcache first.
-	lumpnum_t cachenum = CheckLumpInCache(name);
-	if (cachenum != LUMPERROR)
-		return true;
-
-	namelen = strlen(name);
-	hash = W_HashLumpName(name);
-
+	INT32 i,j;
 	for (i = numwadfiles - 1; i >= 0; i--)
 	{
 		lumpinfo_t *lump_p = wadfiles[i]->lumpinfo;
 		for (j = 0; j < wadfiles[i]->numlumps; ++j, ++lump_p)
-		{
-			if (lump_p->namelength == namelen
-			 && lump_p->hash.name == hash
-			 && fastcmp(lump_p->name, name))
+			if (fastcmp(lump_p->name, name))
 				return true;
-		}
 	}
-
 	return false;
 }
 
@@ -1607,13 +1596,13 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 	fseek(handle, (long)(l->position + offset), SEEK_SET);
 
 	// But let's not copy it yet. We support different compression formats on lumps, so we need to take that into account.
-	switch (wadfiles[wad]->lumpinfo[lump].compression)
+	switch(wadfiles[wad]->lumpinfo[lump].compression)
 	{
 	case CM_NOCOMPRESSION:		// If it's uncompressed, we directly write the data into our destination, and return the bytes read.
 #ifdef NO_PNG_LUMPS
 		{
 			size_t bytesread = fread(dest, 1, size, handle);
-			ErrorIfPNG((UINT8 *)(dest), bytesread, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, bytesread, wadfiles[wad]->filename, l->fullname);
 			return bytesread;
 		}
 #else
@@ -1626,8 +1615,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			char *decData; // Lump's decompressed real data.
 			size_t retval; // Helper var, lzf_decompress returns 0 when an error occurs.
 
-			rawData = (char *)(Z_Malloc(l->disksize, PU_STATIC, NULL));
-			decData = (char *)(Z_Malloc(l->size, PU_STATIC, NULL));
+			rawData = Z_Malloc(l->disksize, PU_STATIC, NULL);
+			decData = Z_Malloc(l->size, PU_STATIC, NULL);
 
 			if (fread(rawData, 1, l->disksize, handle) < l->disksize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1654,7 +1643,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 			Z_Free(decData);
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 #else
@@ -1674,8 +1663,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			unsigned long rawSize = l->disksize;
 			unsigned long decSize = size;
 
-			rawData = (UINT8 *)(Z_Malloc(rawSize, PU_STATIC, NULL));
-			decData = (UINT8 *)(dest);
+			rawData = Z_Malloc(rawSize, PU_STATIC, NULL);
+			decData = dest;
 
 			if (fread(rawData, 1, rawSize, handle) < rawSize)
 				I_Error("wad %d, lump %d: cannot read compressed data", wad, lump);
@@ -1711,7 +1700,7 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si
 			Z_Free(rawData);
 
 #ifdef NO_PNG_LUMPS
-			ErrorIfPNG((UINT8 *)(dest), size, wadfiles[wad]->filename, l->fullname);
+			ErrorIfPNG((UINT8 *)dest, size, wadfiles[wad]->filename, l->fullname);
 #endif
 			return size;
 		}
@@ -1899,7 +1888,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0);
 
 		dest = Z_Calloc(sizeof(patch_t), tag, &lumpcache[lump]);
-		Patch_Create((softwarepatch_t *)(lumpdata), len, dest);
+		Patch_Create((softwarepatch_t*)lumpdata, len, dest);
 
 		Z_Free(lumpdata);
 	}
@@ -1921,7 +1910,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 	if (!TestValidLump(wad, lump))
 		return NULL;
 
-	patch = (patch_t *)(W_CacheSoftwarePatchNumPwad(wad, lump, tag));
+	patch = (patch_t *)W_CacheSoftwarePatchNumPwad(wad, lump, tag);
 
 	if (patch == NULL)
 		return NULL;
@@ -1932,7 +1921,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
 		Patch_CreateGL(patch);
 #endif
 
-	return (void*)(patch);
+	return (void *)patch;
 }
 
 void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
@@ -1950,20 +1939,17 @@ void *W_GetCachedPatchNumPwad(UINT16 wad, UINT16 lump)
 
 #ifdef ROTSPRITE
 // Caches a rotsprite for patch rotation.
-void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump)
+void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 {
-	if (!TestValidLump(wad, lump))
-		return NULL;
+	lumpcache_t *rotcache = wadfiles[wadnum]->rotcache;
 
-	lumpcache_t *rotcache = wadfiles[wad]->rotcache;
-
-	if (!rotcache[lump])
+	if (!rotcache[lumpnum])
 	{
 		rotsprite_t *rspr = RotatedPatch_Create(ROTANGLES);
-		Z_SetUser(rspr, (void**)(&rotcache[lump]));
+		Z_SetUser(rspr, (void **)(&rotcache[lumpnum]));
 	}
 
-	return (void*)(rotcache[lump]);
+	return (void *)(rotcache[lumpnum]);
 }
 #endif // ROTSPRITE
 
@@ -1976,7 +1962,7 @@ void W_UnlockCachedPatch(void *patch)
 	// have different lifetimes from software's.
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
-		HWR_UnlockCachedPatch((GLPatch_t *)(((patch_t *)(patch))->hardware));
+		HWR_UnlockCachedPatch((GLPatch_t *)((patch_t *)patch)->hardware);
 	else
 #endif
 	Z_ChangeTag(patch, PU_PATCH);
@@ -2011,7 +1997,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	if (rotationangle < 1 || rotationangle >= ROTANGLES)
 		return W_CachePatchNum(num, tag);
 
-	rspr = (rotsprite_t *)(W_GetCachedRotPatchPwad(WADFILENUM(num), LUMPNUM(num)));
+	rspr = (rotsprite_t *)W_GetCachedRotPatchPwad(WADFILENUM(num),LUMPNUM(num));
 
 	if (rspr == NULL)
 		return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
@@ -2020,7 +2006,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag)
 	{
 		INT32 xpivot = 0, ypivot = 0;
 
-		ptr = (patch_t *)(W_CachePatchNum(num, PU_PATCH));
+		ptr = (patch_t *)W_CachePatchNum(num, PU_PATCH);
 		if (ptr == NULL)
 			return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
 
@@ -2213,7 +2199,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = file_size - (22 + 65536);
+	const long startpos = (file_size - (22 + 65536));
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2227,7 +2213,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2238,7 +2224,7 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		char* fullname;
 		char* trimname;
 		char* dotpos;
@@ -2250,9 +2236,8 @@ static int W_VerifyPK3(FILE *fp, lumpchecklist_t *checklist, boolean status)
 
 		if (verified == true)
 		{
-			fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-			strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-			fullname[zentry->namelen] = 0;
+			fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+			strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 			// Strip away file address and extension for the 8char name.
 			if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2461,7 +2446,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 	fseek(fp, 0, SEEK_END);
 	file_size = ftell(fp);
 
-	const long startpos = file_size - (22 + 65536);
+	const long startpos = (file_size - (22 + 65536));
 	if (!ResFindSignature(fp, pat_end, max(0l, startpos)))
 		return true;
 
@@ -2475,7 +2460,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
 
-	CLEANUP(pfree) char *cdir = (char *)(malloc(LONG(zend.cdirsize)));
+	CLEANUP(pfree) char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
 
 	if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
 	{
@@ -2486,7 +2471,7 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 
 	for (i = 0; i < numlumps; i++)
 	{
-		zentry_t *zentry = (zentry_t *)(cdir + offset);
+		zentry_t *zentry = (zentry_t*)(cdir + offset);
 		CLEANUP(pfree) char* fullname = NULL;
 		char* trimname;
 		char* dotpos;
@@ -2496,9 +2481,8 @@ static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
 			return false;
 		}
 
-		fullname = (char *)(malloc(SHORT(zentry->namelen) + 1));
-		strncpy(fullname, (char *)(zentry + 1), SHORT(zentry->namelen));
-		fullname[zentry->namelen] = 0;
+		fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
+		strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
 
 		// Strip away file address and extension for the 8char name.
 		if ((trimname = strrchr(fullname, '/')) != NULL)
@@ -2589,18 +2573,6 @@ static int W_CheckFileContains(const char *filename, lumpchecklist_t *checklist)
 	return contains;
 }
 
-int W_CheckAutoLoadContainsMap(const char *filename)
-{
-	// for now this checks for map marker
-	static lumpchecklist_t autoloadblacklist[] =
-	{
-		{"MAP", 3},
-		{NULL,  0},
-	};
-
-	return W_CheckFileContains(filename, autoloadblacklist);
-}
-
 int W_CheckPostLoadList(const char *filename)
 {
 	static lumpchecklist_t postloadlist[] =
@@ -2613,6 +2585,7 @@ int W_CheckPostLoadList(const char *filename)
 		{"SOC_", 		4},
 		{"MAINCFG",		7},
 		{"OBJCTCFG", 	8},
+		{"MAP",			3},
 
 		{NULL, 0},
 	};
@@ -2645,14 +2618,14 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		size_t *vsizecache;
 
 		// Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
-		UINT8 *wadData = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+		UINT8 *wadData = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		if (wadData == NULL)
 			I_Error("vres_GetMap: Invalid WadData!\n");
 
-		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)(wadData))->infotableofs));
+		filelump_t *fileinfo = (filelump_t *)(wadData + LONG(((wadinfo_t *)wadData)->infotableofs));
 
-		i = LONG(((wadinfo_t *)(wadData))->numlumps);
-		vsizecache = (size_t *)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
+		i = LONG(((wadinfo_t *)wadData)->numlumps);
+		vsizecache = (size_t*)(Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL));
 
 		for (realentry = 0; realentry < i; realentry++)
 		{
@@ -2664,7 +2637,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			numlumps++;
 		}
 
-		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2673,12 +2646,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		{
 			if (vsizecache[realentry] == 0)
 				continue;
-
 			vlumps[i].size = vsizecache[realentry];
 
 			const char *name = (fileinfo + realentry)->name;
 
-			if (strnlen(name, 8) == 5 && memcmp(name, "MAP", 3) == 0)
+			if (strlen(name) == 5 && memcmp(name, "MAP", 3) == 0)
 			{
 				numlumps--; // We skip map marker, so 1 of entries becomes empty
 				continue; // This will skip i++ so we will write to same entry
@@ -2687,7 +2659,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			// Play it safe with the name in this case.
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8 *)(
+			vlumps[i].data = (UINT8*)(
 				Z_Malloc(vlumps[i].size, PU_LEVEL, NULL) // This is memory inefficient, sorry about that.
 			);
 			memcpy(vlumps[i].data, wadData + LONG((fileinfo + realentry)->filepos), vlumps[i].size);
@@ -2714,7 +2686,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 		}
 		numlumps++;
 
-		vlumps = (virtlump_t *)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
+		vlumps = (virtlump_t*)(Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL));
 		if (vlumps == NULL)
 			I_Error("vres_GetMap: Out of memory!\n");
 
@@ -2735,11 +2707,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum)
 			vlumps[i].size = W_LumpLength(lumpnum);
 			memcpy(vlumps[i].name, name, 8);
 			vlumps[i].name[8] = '\0';
-			vlumps[i].data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_LEVEL));
+			vlumps[i].data = (UINT8*)(W_CacheLumpNum(lumpnum, PU_LEVEL));
 		}
 	}
 
-	vres = (virtres_t *)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
+	vres = (virtres_t*)(Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL));
 	vres->vlumps = vlumps;
 	vres->numlumps = numlumps;
 

src/w_wad.h

@@ -68,11 +68,11 @@ typedef struct
 	unsigned long position; // filelump_t filepos
 	unsigned long disksize; // filelump_t size
 	char name[9];           // filelump_t name[] e.g. "LongEntr"
-	//char *longname;         //                   e.g. "LongEntryName"
+	char *longname;         //                   e.g. "LongEntryName"
 	char *fullname;         //                   e.g. "Folder/Subfolder/LongEntryName.extension"
 
 	size_t namelength;      // length of name
-	//size_t longnamelength;  // length of longname
+	size_t longnamelength;  // length of longname
 	size_t fullnamelength;  // length of fullname
 
 	size_t size; // real (uncompressed) size
@@ -80,8 +80,8 @@ typedef struct
 
 	struct {
 		UINT32 name;        // hash of name
-		//UINT32 longname;    // hash of longname
-		//UINT32 fullname;    // hash of fullname
+		UINT32 longname;    // hash of longname
+		UINT32 fullname;    // hash of fullname
 	} hash;
 } lumpinfo_t;
 
@@ -126,6 +126,7 @@ typedef enum restype
 	RET_UNKNOWN,
 } restype_t;
 
+
 typedef struct wadfile_s
 {
 	char *filename;
@@ -136,8 +137,8 @@ typedef struct wadfile_s
 #ifdef ROTSPRITE
 	lumpcache_t *rotcache; // Cache rotsprites for rotating patches.
 #endif
-	struct FolderCache *startfolders;
-	struct FolderCache *endfolders;
+	aatree_t *startfolders;
+	aatree_t *endfolders;
 	UINT16 numlumps; // this wad's number of resources
 	FILE *handle;
 	UINT32 filesize; // for network
@@ -154,7 +155,6 @@ extern wadfile_t *wadfiles[MAX_WADFILES];
 
 // =========================================================================
 
-void W_Startup(void);
 void W_Shutdown(void);
 
 // Opens a WAD file. Returns the FILE * handle for the file, or NULL if not found or could not be opened
@@ -174,11 +174,13 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames);
 
 #define W_FileHasFolders(wadfile) ((wadfile)->type == RET_PK3)
 
+UINT32 W_HashLumpName(const char *name);
+
 const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump);
 const char *W_CheckNameForNum(lumpnum_t lumpnum);
 
 UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump); // checks only in one pwad
-//UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
+UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump);
 
 /* Find the first lump after F_START for instance. */
 UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlump);
@@ -188,9 +190,9 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
 UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump);
 
 lumpnum_t W_CheckNumForName(const char *name);
-//lumpnum_t W_CheckNumForLongName(const char *name);
+lumpnum_t W_CheckNumForLongName(const char *name);
 lumpnum_t W_GetNumForName(const char *name); // like W_CheckNumForName but I_Error on LUMPERROR
-//lumpnum_t W_GetNumForLongName(const char *name);
+lumpnum_t W_GetNumForLongName(const char *name);
 lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, const char *blockend);
 UINT8 W_LumpExists(const char *name); // Lua uses this.
 UINT8 W_CheckMultipleLumps(const char* lump, ...); // variadic version of above lmao
@@ -231,7 +233,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag);
 void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag);
 
 #ifdef ROTSPRITE
-void *W_GetCachedRotPatchPwad(UINT16 wad, UINT16 lump); // Get patch-based rotsprites from the cache.
+void *W_GetCachedRotPatchPwad(UINT16 wadnum, UINT16 lumpnum); // Get patch-based rotsprites from the cache.
 void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag);
 #endif
 
@@ -241,7 +243,6 @@ void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
 
 int W_VerifyNMUSlumps(const char *filename, FILE *handle, boolean exit_on_error);
 
-int W_CheckAutoLoadContainsMap(const char *filename);
 int W_CheckPostLoadList(const char *filename);
 
 #ifdef __cplusplus

src/z_zone.cpp

@@ -75,6 +75,8 @@ typedef struct memblock_s
 #define MEMORY(x) (void *)((uintptr_t)(x) + sizeof(memblock_t) + ALIGNPAD)
 #define MEMBLOCK(x) (memblock_t *)((uintptr_t)(x) - ALIGNPAD - sizeof(memblock_t))
 
+static thread_handle_t main_thread;
+
 // both the head and tail of the zone memory block list
 static memblock_t head;
 
@@ -108,6 +110,7 @@ static void Command_Memdump_f(void);
 void Z_Init(void)
 {
 	size_t total, memfree;
+	main_thread = I_GetCurrentThread();
 
 	memset(&head, 0x00, sizeof(head));
 
@@ -143,6 +146,8 @@ void Z_Free(void *ptr)
 {
 	memblock_t *block;
 
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 	if (ptr == NULL)
 		return;
 
@@ -237,6 +242,8 @@ void *Z_Malloc(size_t size, INT32 tag, void *user)
 	memblock_t *block;
 	void *ptr;
 
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 #ifdef ZDEBUG2
 	CONS_Debug(DBG_MEMORY, "Z_Malloc %s:%d\n", file, line);
 #endif
@@ -300,6 +307,8 @@ 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
 {
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 #ifdef VALGRIND_MEMPOOL_ALLOC
 	Z_calloc = true;
 #endif
@@ -335,6 +344,8 @@ void *Z_Realloc(void *ptr, size_t size, INT32 tag, void *user)
 	memblock_t *block;
 	size_t copysize;
 
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 #ifdef ZDEBUG2
 	CONS_Debug(DBG_MEMORY, "Z_Realloc %s:%d\n", file, line);
 #endif
@@ -414,6 +425,8 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
 {
 	memblock_t *block, *next;
 
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 #ifdef ZDEBUG
 	Z_CheckHeap2(file, line);
 #else
@@ -447,6 +460,8 @@ void Z_IterateTags(INT32 lowtag, INT32 hightag, boolean (*iterfunc)(void *))
 {
 	memblock_t *block, *next;
 
+	I_Assert(I_GetCurrentThread() == main_thread);
+
 	if (!iterfunc)
 		I_Error("Z_IterateTags: no iterator function was given");
 
@@ -523,19 +538,11 @@ void Z_CheckHeap(INT32 tag)
 #ifdef VALGRIND_MEMPOOL_EXISTS
 		if (!VALGRIND_MEMPOOL_EXISTS(block))
 		{
-			I_Error("Z_CheckHeap :"
-#ifdef ZDEBUG
-				" %s %d"
-#endif
-				" block %u"
+			I_Error("Z_CheckHeap %d: block %u"
 #ifdef ZDEBUG
 				" (owned by %s:%d)"
 #endif
-				" should not exist"
-#ifdef ZDEBUG
-				, file, line
-#endif
-				, blocknumon
+				" should not exist", i, blocknumon
 #ifdef ZDEBUG
 				, block->ownerfile, block->ownerline
 #endif