remove the loop condition for framelimiter

this was for an older iteration where it ran the loop until it hit the target per condition, keeping like this may cause issue if the loop exits per condition instead of the return block
now we return from within the loop

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

@@ -46,16 +46,16 @@
 #ifdef HAVE_THREADS
 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_LockMutex(&con_mutex); }
-#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_UnlockMutex(con_mutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(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

src/d_clisrv.h

@@ -660,11 +660,9 @@ 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

@@ -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
-			}
 		}
 	}
 
@@ -646,6 +653,68 @@ static boolean D_Display(void)
 	return ranwipe;
 }
 
+static UINT64 precision = 0;
+static precise_t sleeptime = 0;
+
+static void D_LimitFps(void)
+{
+	static precise_t curtime = 0, lasttime = 0;
+	static precise_t start;
+	precise_t elapsed = 0;
+
+	sleeptime = 0;
+
+	// timedemo runs uncapped!
+	if (singletics)
+		return;
+
+	// in the case of "match refresh rate" + vsync, don't sleep at all
+	if (cv_vidwait.value && cv_fpscap.value == 0)
+		return;
+
+	const UINT32 framecap = R_GetFramerateCap();
+
+	// uncapped obviously does not need to be... capped...
+	if (framecap == 0)
+		return;
+
+	start = I_GetPreciseTime();
+
+	// frametarget in precise_t ticks (ex. 60fps = ~16,666,666)
+	const precise_t frametarget = precision / framecap;
+
+	while (1)
+	{
+		// check the current time against the "time of the old frame""
+		curtime = I_GetPreciseTime();
+		elapsed = curtime - lasttime;
+
+		// done waiting!
+		// continue as normal
+		if (elapsed >= frametarget)
+		{
+			lasttime = curtime;
+
+			// time we spent :chaosleep:ing or doing absolutely nothing
+			// for frameskip calculations
+			sleeptime = curtime - start;
+			return;
+		}
+
+		// if we have more than 1ms to wait
+		// sleep for a bit to not trash the cpu lul
+		precise_t remaining = frametarget - elapsed;
+
+		if (remaining > (precise_t)(precision / 1000))
+		{
+			// sleep for 90% of the time we gotta wait for the next frame
+			// since we dont wanna oversleep :chaosleep:
+			I_SleepDuration(9 * remaining / 10);
+		}
+	}
+	// the rest we just be waitin until we meet our frametime target
+}
+
 // =========================================================================
 // D_SRB2Loop
 // =========================================================================
@@ -657,7 +726,6 @@ void D_SRB2Loop(void)
 	tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
 	double deltatics = 0.0;
 	double deltasecs = 0.0;
-	UINT64 precision = 0;
 
 	boolean interp = false;
 	boolean doDisplay = false;
@@ -697,27 +765,16 @@ 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;
 		precise_t enterprecise, finishprecise;
 
 		enterprecise = I_GetPreciseTime();
 
+		boolean ranwipe = false;
+
 		memset(&g_dc, 0, sizeof(g_dc));
 		Z_Frame_Reset();
 
-		// Casting the return value of a function is bad practice (apparently)
-		const UINT32 framecap = R_GetFramerateCap();
-		capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round
-
-		boolean ranwipe = false;
-
 		I_UpdateTime(cv_timescale.value);
 
 		if (lastwipetic)
@@ -781,6 +838,11 @@ void D_SRB2Loop(void)
 
 				doDisplay = true;
 			}
+
+			if (!dedicated)
+			{
+				G_DeviceLEDTick();
+			}
 		}
 
 		if (interp)
@@ -802,6 +864,10 @@ void D_SRB2Loop(void)
 			R_SetTimeFrac(FRACUNIT);
 		}
 
+		// be sure to limit our fps *before* drawing
+		// so we can properly "pace" our frames
+		D_LimitFps();
+
 		if (interp || doDisplay)
 		{
 			if (!frameskip)
@@ -822,13 +888,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
 
@@ -843,9 +902,9 @@ void D_SRB2Loop(void)
 		// Fully completed frame made.
 		finishprecise = I_GetPreciseTime();
 
-		// Use the time before sleep for frameskip calculations:
+		// Use the time without sleep for frameskip calculations:
 		// post-sleep time is literally being intentionally wasted
-		elapsed = finishprecise - enterprecise;
+		elapsed = (finishprecise - enterprecise) - sleeptime;
 		deltasecs = (double)elapsed / (double)precision;
 		deltatics = deltasecs * (double)NEWTICRATE;
 
@@ -873,19 +932,6 @@ void D_SRB2Loop(void)
 			frameskip = 0;
 		}
 
-		if (!singletics)
-		{
-			// in the case of "match refresh rate" + vsync, don't sleep at all
-			const boolean vsync_with_match_refresh = cv_vidwait.value && cv_fpscap.value == 0;
-
-			if ((elapsed > 0) && (capbudget > elapsed) && !vsync_with_match_refresh)
-			{
-				I_SleepDuration(capbudget - elapsed);
-			}
-		}
-
-		// Capture the time once more to get the real delta time.
-		finishprecise = I_GetPreciseTime();
 		elapsed = finishprecise - enterprecise;
 		deltasecs = (double)elapsed / (double)precision;
 		deltatics = deltasecs * (double)NEWTICRATE;
@@ -1643,6 +1689,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"));
 

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

@@ -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);

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

src/dehacked.c

@@ -173,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);
@@ -8545,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/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();
 

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";
@@ -3899,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"));

src/hardware/hw_main.cpp

@@ -1378,7 +1378,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 
 	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;

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

src/http-mserv.c

@@ -318,7 +318,6 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
-	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }

src/hu_stuff.c

@@ -497,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)
@@ -518,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;

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/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);
 

src/lua_hooklib.c

@@ -615,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);
@@ -626,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);
@@ -638,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);
@@ -655,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);
@@ -665,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);
@@ -676,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);
@@ -695,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);
@@ -723,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;
@@ -783,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);
@@ -802,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);
@@ -890,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))
 	{
@@ -911,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))
 	{
@@ -924,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
@@ -953,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);
@@ -967,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)
 	{
@@ -997,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
@@ -1060,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;
 
@@ -1096,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);
@@ -1114,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);
@@ -1163,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/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_menu.c

@@ -2936,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!
@@ -4016,16 +4016,16 @@ boolean replaynamesloaded = false;
 #ifdef HAVE_THREADS
 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_LockMutex(&replayquerymutex); }
-#  define Unlock_search_state()  if (!I_In_Exiting_Signal_Handler()) { I_UnlockMutex(replayquerymutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_search_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&replayquerymutex); }
+#  define Unlock_search_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(replayquerymutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_search_state()
 #  define Unlock_search_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/
 
 
 #define MAXREPLAYQUERY 37
@@ -5522,6 +5522,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++)
@@ -5681,6 +5682,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);
@@ -7996,9 +8000,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);

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
@@ -1644,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[] =
@@ -1675,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",

src/mserv.c

@@ -262,7 +262,6 @@ Finish_registration (void)
 	{
 		CONS_Printf("\n");
 		CONS_Alert(CONS_NOTICE, "%s\n", rules);
-		free(rules);
 	}
 
 	if (registered)

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

@@ -335,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;
 }
@@ -919,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;
 
@@ -941,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;
-	}
 }
 
 //
@@ -3252,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)
@@ -3620,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])
 	{
@@ -6986,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++)
@@ -8553,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;
@@ -8577,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)
 						{
@@ -10034,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
@@ -10044,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);

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;
 

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;
@@ -4109,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...
@@ -4453,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)
 	{

src/r_draw.cpp

@@ -437,7 +437,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_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

@@ -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)

src/s_sound.c

@@ -473,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;

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)

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

@@ -237,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;
 

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/w_wad.c

@@ -455,7 +455,7 @@ 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);
+	i = header.numlumps * sizeof (*fileinfo);
 	fileinfov = fileinfo = malloc(i);
 
 	if (fseek(handle, header.infotableofs, SEEK_SET) == -1