hash_sparse: change length checks

dont early return on 0 len, let it be the falltrough case, this seems to help branch prediction

CMakeLists.txt

@@ -1,14 +1,46 @@
 cmake_minimum_required(VERSION 3.5)
-# DO NOT CHANGE THIS SRB2 STRING! Some variable names depend on this string.
-# Version change is fine.
-project(SRB2
-	VERSION 1.6
-	LANGUAGES C)
 
 if(${PROJECT_SOURCE_DIR} MATCHES ${PROJECT_BINARY_DIR})
 	message(FATAL_ERROR "In-source builds will bring you a world of pain. Please make a separate directory to invoke CMake from.")
 endif()
 
+# DO NOT CHANGE THIS SRB2 STRING! Some variable names depend on this string.
+# Version change is fine.
+project(SRB2
+	VERSION 1.6
+	LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+#set(CMAKE_CXX_EXTENSIONS OFF)    # optional but recommended: disables GNU extensions, forces pure ISO C++
+set(CMAKE_CXX_EXTENSIONS ON)
+set(CMAKE_C_EXTENSIONS ON)
+
+##### PACKAGE CONFIGURATION #####
+
+set(SRB2_CPACK_GENERATOR "" CACHE STRING "Generator to use for making a package. E.g., ZIP, TGZ, DragNDrop (OSX only). Leave blank for default generator.")
+
+if("${SRB2_CPACK_GENERATOR}" STREQUAL "")
+	if("${CMAKE_SYSTEM_NAME}" MATCHES "Windows")
+		set(SRB2_CPACK_GENERATOR "ZIP")
+	elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+		set(SRB2_CPACK_GENERATOR "TGZ")
+	elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
+		set(SRB2_CPACK_GENERATOR "TGZ")
+	endif()
+endif()
+
+set(CPACK_GENERATOR ${SRB2_CPACK_GENERATOR})
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sonic Robo Blast 2 Kart" CACHE STRING "Program name for display purposes")
+set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes")
+#set(CPACK_PACKAGE_DESCRIPTION_FILE )
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set(CPACK_PACKAGE_VERSION_MAJOR ${SRB2_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${SRB2_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${SRB2_VERSION_PATCH})
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMAKE_VERSION_MAJOR}.${CMAKE_VERSION_MINOR}")
+include(CPack)
+
 # Set up CMAKE path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
 
@@ -73,6 +105,7 @@ endif()
 # OS macros
 if (UNIX)
 	add_definitions(-DUNIXCOMMON)
+	add_link_options(-rdynamic) # Use -rdynamic so a backtrace log shows function names
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCC)
@@ -95,14 +128,12 @@ set(CMAKE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 
 # Set EXE names so the assets CMakeLists can refer to its target
 set(SRB2_SDL2_EXE_NAME srb2kart CACHE STRING "Executable binary output name")
-set(SRB2_WIN_EXE_NAME srb2kartdd CACHE STRING "Executable binary output name for DirectDraw build")
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/src)
 
 add_subdirectory(src)
 add_subdirectory(assets)
 
-
 ## config.h generation
 set(GIT_EXECUTABLE "git" CACHE FILEPATH "Path to git binary")
 include(GitUtilities)
@@ -111,25 +142,3 @@ git_current_branch(SRB2_GIT_BRANCH "${CMAKE_SOURCE_DIR}")
 set(SRB2_COMP_BRANCH "${SRB2_GIT_BRANCH}")
 set(SRB2_COMP_REVISION "${SRB2_COMP_COMMIT}")
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/config.h)
-
-##### PACKAGE CONFIGURATION #####
-
-if(${CMAKE_SYSTEM} MATCHES "Windows")
-	set(CPACK_GENERATOR "ZIP")
-endif()
-if(${CMAKE_SYSTEM} MATCHES "Linux")
-	set(CPACK_GENERATOR "TGZ")
-endif()
-if(${CMAKE_SYSTEM} MATCHES "Darwin")
-	set(CPACK_GENERATOR "DragNDrop")
-endif()
-
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sonic Robo Blast 2 Kart" CACHE STRING "Program name for display purposes")
-set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes")
-#set(CPACK_PACKAGE_DESCRIPTION_FILE )
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
-set(CPACK_PACKAGE_VERSION_MAJOR ${SRB2_VERSION_MAJOR})
-set(CPACK_PACKAGE_VERSION_MINOR ${SRB2_VERSION_MINOR})
-set(CPACK_PACKAGE_VERSION_PATCH ${SRB2_VERSION_PATCH})
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMAKE_VERSION_MAJOR}.${CMAKE_VERSION_MINOR}")
-include(CPack)

LUASTUFF.md

@@ -13,10 +13,12 @@ Mainly for use in visual-only addons like secondcolor.
 
 **Not netsafe**. Returns player's current sliptide roll angle, taking sliptideroll cvar value into account.
 
-## hud.setVoteBackground(name)
+## hud.setVoteBackground(name[, time\_per\_frame])
 
 Changes vote background texture prefix (game looks for PREFIX + "W" or "C" (depends on resolution) + FRAME\_NUMBER).
 
+If time\_per\_frame is set, each frame will last this amount of tics, default value is 2
+
 ## hud.add(fn, "vote") and hud.add(fn, "intermission")
 
 Hud hooks for vote screen and intermission screen. They only get drawer (`v`) as argument.
@@ -120,6 +122,11 @@ v.interpLatch(false)
 ```
 When using a custom string drawer, enable this mode to avoid interpolation artifacting when the string changes.
 
+## cameras[] global array
+
+Local player cameras that can be accessed outside of hud hooks.
+`#cameras` will return amount of available cameras. (0 on dedicated server, 1 with 1 player, 4 with 4p splitscreen, etc)
+
 ## mobj.spritexscale, mobj.spriteyscale, mobj.spritexoffset, mobj.spriteyoffset, mobj.rollangle, mobj.sloperoll, mobj.rollmodel fields
 
 Same fields as in SRB2 2.2

README.md

@@ -22,14 +22,14 @@ We also have a Flatpak available on [Flathub](https://flathub.org/en/apps/org.sr
 
 See [SRB2 Wiki/Source code compiling](http://wiki.srb2.org/wiki/Source_code_compiling). The compiling process for SRB2Kart is largely identical to SRB2.
 
-Currently only the Makefile build system with GCC or Clang compiler is supported.
-CMake is NOT supported at the moment, but will be availible again soon.
-
+For Windows only the Makefile build system with GCC or Clang compiler is supported.
 Visual C++ (MSVC) is unsupported.
 
 64-bit Windows builds are supported and recommended over 32-bit builds, they will build automatically when using the MSYS2 MinGW 64-bit executable (requires the mingw-w64-x86_64-gcc package), no extra flags needed!
 The specific DLLs can be found under /libs/dll-binaries/(i686 for 32bit/x86_64 for 64-bit)/ or in the Release packages
 
+MacOS and Linux can be build with CMake, but it is recommended to use the Makefile for Linux over CMake
+
 Alternatively the [srb2bld](https://github.com/Bijman/srb2bld) script by Bijman can be used aswell!
 
 ## Disclaimer

assets/CMakeLists.txt

@@ -1,5 +1,10 @@
 ## Assets Target Configuration ##
 
+if(${CMAKE_SYSTEM} MATCHES Linux)
+	# Asset installation isn't part of the Linux target
+	return()
+endif()
+
 # For prepending the current source path, later
 FUNCTION(PREPEND var prefix)
    SET(listVar "")

assets/LICENSE-3RD-PARTY.txt

@@ -972,14 +972,6 @@ Public License instead of this License.  But first, please read
           Copyright (C) 1995-2018 Free Software Foundation, Inc.
           https://www.gnu.org/software/gettext/
 
-        - FluidSynth
-          Copyright (C) 2000-2025 Peter Hanappe and others.
-          https://www.fluidsynth.org/
-
-        - libsndfile
-          Copyright (C) 1999-2016 Erik de Castro Lopo
-          https://libsndfile.github.io/libsndfile/
-
         - mpg123
           Copyright (c) 1995-2013 by Michael Hipp and others,
           free software under the terms of the LGPL v2.1
@@ -1707,8 +1699,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                         zlib License
         applies to:
         - Simple DirectMedia Layer
-          Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
-          https://libsdl.org/
+          Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
+          https://www.libsdl.org/hg.php
+
+        - SDL_mixer:  An audio mixer library based on the SDL library
+          Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
+          https://www.libsdl.org/projects/SDL_mixer/
 
         - zlib
           Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler

cmake/Modules/FindFluidSynth.cmake

@@ -1,41 +0,0 @@
-# Find FluidSynth
-# Once done, this will define
-#
-#  FLUIDSYNTH_FOUND - system has FluidSynth
-#  FLUIDSYNTH_INCLUDE_DIRS - FluidSynth include directories
-#  FLUIDSYNTH_LIBRARIES - link libraries
-
-include(LibFindMacros)
-
-libfind_pkg_check_modules(FLUIDSYNTH_PKGCONF FLUIDSYNTH)
-
-# includes
-find_path(FLUIDSYNTH_INCLUDE_DIR
-	NAMES fluidsynth.h
-	PATHS
-		${FLUIDSYNTH_PKGCONF_INCLUDE_DIRS}
-)
-
-# library
-find_library(FLUIDSYNTH_LIBRARY
-	NAMES fluidsynth
-	PATHS
-		${FLUIDSYNTH_PKGCONF_LIBRARY_DIRS}
-		"/usr/lib"
-		"/usr/local/lib"
-)
-
-# set include dir variables
-set(FLUIDSYNTH_PROCESS_INCLUDES FLUIDSYNTH_INCLUDE_DIR)
-set(FLUIDSYNTH_PROCESS_LIBS FLUIDSYNTH_LIBRARY)
-libfind_process(FLUIDSYNTH)
-
-if(FLUIDSYNTH_FOUND AND NOT TARGET FluidSynth::libfluidsynth)
-	add_library(FluidSynth::libfluidsynth UNKNOWN IMPORTED)
-	set_target_properties(
-		FluidSynth::libfluidsynth
-		PROPERTIES
-		IMPORTED_LOCATION "${FLUIDSYNTH_LIBRARY}"
-		INTERFACE_INCLUDE_DIRECTORIES "${FLUIDSYNTH_INCLUDE_DIR}"
-	)
-endif()

cmake/Modules/FindGME.cmake

@@ -1,6 +1,6 @@
 include(LibFindMacros)
 
-libfind_pkg_check_modules(GME_PKGCONF GME)
+libfind_pkg_check_modules(GME_PKGCONF LIBGME)
 
 find_path(GME_INCLUDE_DIR
 	NAMES gme.h
@@ -8,6 +8,7 @@ find_path(GME_INCLUDE_DIR
 		${GME_PKGCONF_INCLUDE_DIRS}
 		"/usr/include/gme"
 		"/usr/local/include/gme"
+	PATH_SUFFIXES gme
 )
 
 find_library(GME_LIBRARY
@@ -20,4 +21,4 @@ find_library(GME_LIBRARY
 
 set(GME_PROCESS_INCLUDES GME_INCLUDE_DIR)
 set(GME_PROCESS_LIBS GME_LIBRARY)
-libfind_process(GME)
+libfind_process(GME)

cmake/Modules/FindOPENMPT.cmake

@@ -1,6 +1,6 @@
 include(LibFindMacros)
 
-libfind_pkg_check_modules(OPENMPT_PKGCONF OPENMPT)
+libfind_pkg_check_modules(OPENMPT_PKGCONF LIBOPENMPT)
 
 find_path(OPENMPT_INCLUDE_DIR
 	NAMES libopenmpt.h
@@ -8,6 +8,7 @@ find_path(OPENMPT_INCLUDE_DIR
 		${OPENMPT_PKGCONF_INCLUDE_DIRS}
 		"/usr/include/libopenmpt"
 		"/usr/local/include/libopenmpt"
+	PATH_SUFFIXES libopenmpt
 )
 
 find_library(OPENMPT_LIBRARY
@@ -20,4 +21,4 @@ find_library(OPENMPT_LIBRARY
 
 set(OPENMPT_PROCESS_INCLUDES OPENMPT_INCLUDE_DIR)
 set(OPENMPT_PROCESS_LIBS OPENMPT_LIBRARY)
-libfind_process(OPENMPT)
+libfind_process(OPENMPT)

cmake/Modules/Findlibbacktrace.cmake

@@ -0,0 +1,33 @@
+include(LibFindMacros)
+
+libfind_pkg_check_modules(LIBBACKTRACE_PKGCONF LIBBACKTRACE)
+
+find_path(LIBBACKTRACE_INCLUDE_DIR
+	NAMES backtrace.h
+	PATHS
+		${LIBBACKTRACE_PKGCONF_INCLUDE_DIRS}
+		"/usr/include"
+		"/usr/local/include"
+)
+
+find_library(LIBBACKTRACE_LIBRARY
+	NAMES backtrace
+	PATHS
+		${LIBBACKTRACE_PKGCONF_LIBRARY_DIRS}
+		"/usr/lib"
+		"/usr/local/lib"
+)
+
+set(LIBBACKTRACE_PROCESS_INCLUDES LIBBACKTRACE_INCLUDE_DIR)
+set(LIBBACKTRACE_PROCESS_LIBS LIBBACKTRACE_LIBRARY)
+libfind_process(LIBBACKTRACE)
+
+if(LIBBACKTRACE_FOUND AND NOT TARGET libbacktrace)
+	add_library(libbacktrace UNKNOWN IMPORTED)
+	set_target_properties(
+		libbacktrace
+		PROPERTIES
+		IMPORTED_LOCATION "${LIBBACKTRACE_LIBRARY}"
+		INTERFACE_INCLUDE_DIRECTORIES "${LIBBACKTRACE_INCLUDE_DIR}"
+	)
+endif()

cmake/Modules/LibFindMacros.cmake

@@ -1,4 +1,4 @@
-# Version 2.2
+# Version 2.4
 # Public Domain, originally written by Lasse Kärkkäinen <tronic>
 # Maintained at https://github.com/Tronic/cmake-modules
 # Please send your improvements as pull requests on Github.
@@ -52,6 +52,10 @@ function (libfind_pkg_detect PREFIX)
   if (libraryargs)
     find_library(${PREFIX}_LIBRARY NAMES ${libraryargs} HINTS ${${PREFIX}_PKGCONF_LIBRARY_DIRS})
   endif()
+  # Read pkg-config version
+  if (${PREFIX}_PKGCONF_VERSION)
+    set(${PREFIX}_VERSION ${${PREFIX}_PKGCONF_VERSION} PARENT_SCOPE)
+  endif()
 endfunction()
 
 # Extracts a version #define from a version.h file, output stored to <PREFIX>_VERSION.
@@ -125,24 +129,39 @@ function (libfind_process PREFIX)
 
   # Process deps to add to
   foreach (i ${PREFIX} ${${PREFIX}_DEPENDENCIES})
-    if (DEFINED ${i}_INCLUDE_OPTS OR DEFINED ${i}_LIBRARY_OPTS)
+    if (DEFINED ${i}_INCLUDE_OPTS)
       # The package seems to export option lists that we can use, woohoo!
       list(APPEND includeopts ${${i}_INCLUDE_OPTS})
+    else()
+      if (DEFINED ${i}_INCLUDE_DIR)
+        # Singular forms can be used
+        list(APPEND includeopts ${i}_INCLUDE_DIR)
+      else()
+        if (DEFINED ${i}_INCLUDE_DIRS)
+          # Plural forms can be used
+          list(APPEND includeopts ${i}_INCLUDE_DIRS)
+        else()
+          # Oh no, we don't know the option names
+          message(FATAL_ERROR "We couldn't determine config variable names for ${i} includes. Aieeh!")
+        endif()
+      endif()
+    endif()
+
+    if (DEFINED ${i}_LIBRARY_OPTS)
+      # The package seems to export option lists that we can use, woohoo!
       list(APPEND libraryopts ${${i}_LIBRARY_OPTS})
     else()
-      # If plural forms don't exist or they equal singular forms
-      if ((NOT DEFINED ${i}_INCLUDE_DIRS AND NOT DEFINED ${i}_LIBRARIES) OR
-          ({i}_INCLUDE_DIR STREQUAL ${i}_INCLUDE_DIRS AND ${i}_LIBRARY STREQUAL ${i}_LIBRARIES))
+      if (DEFINED ${i}_LIBRARY)
         # Singular forms can be used
-        if (DEFINED ${i}_INCLUDE_DIR)
-          list(APPEND includeopts ${i}_INCLUDE_DIR)
-        endif()
-        if (DEFINED ${i}_LIBRARY)
-          list(APPEND libraryopts ${i}_LIBRARY)
-        endif()
+        list(APPEND libraryopts ${i}_LIBRARY)
       else()
-        # Oh no, we don't know the option names
-        message(FATAL_ERROR "We couldn't determine config variable names for ${i} includes and libs. Aieeh!")
+        if (DEFINED ${i}_LIBRARIES)
+          # Plural forms can be used
+          list(APPEND libraryopts ${i}_LIBRARIES)
+        else()
+          # Oh no, we don't know the option names
+          message(FATAL_ERROR "We couldn't determine config variable names for ${i} libraries. Aieeh!")
+        endif()
       endif()
     endif()
   endforeach()
@@ -209,12 +228,12 @@ function (libfind_process PREFIX)
         message(STATUS "  ${PREFIX}_LIBRARY_OPTS=${libraryopts}")
         message(STATUS "  ${PREFIX}_LIBRARIES=${libs}")
       endif()
-      set (${PREFIX}_INCLUDE_OPTS ${includeopts} PARENT_SCOPE)
-      set (${PREFIX}_LIBRARY_OPTS ${libraryopts} PARENT_SCOPE)
-      set (${PREFIX}_INCLUDE_DIRS ${includes} PARENT_SCOPE)
-      set (${PREFIX}_LIBRARIES ${libs} PARENT_SCOPE)
-      set (${PREFIX}_FOUND TRUE PARENT_SCOPE)
     endif()
+    set (${PREFIX}_INCLUDE_OPTS ${includeopts} PARENT_SCOPE)
+    set (${PREFIX}_LIBRARY_OPTS ${libraryopts} PARENT_SCOPE)
+    set (${PREFIX}_INCLUDE_DIRS ${includes} PARENT_SCOPE)
+    set (${PREFIX}_LIBRARIES ${libs} PARENT_SCOPE)
+    set (${PREFIX}_FOUND TRUE PARENT_SCOPE)
     return()
   endif()
 

src/.gitignore

@@ -1,3 +1,4 @@
 /cscope.out
 *.json
 *.idx
+*.gdb_history

src/CMakeLists.txt

@@ -2,6 +2,8 @@
 
 # Core sources
 set(SRB2_CORE_SOURCES
+	core/memory.cpp
+	core/thread_pool.cpp
 	am_map.c
 	b_bot.c
 	command.c
@@ -18,17 +20,21 @@ set(SRB2_CORE_SOURCES
 	f_wipe.c
 	filesrch.c
 	g_game.c
+	g_demo.c
 	g_input.c
 	hu_stuff.c
 	i_tcp.c
 	info.c
+	k_hud.c
 	lzf.c
 	m_aatree.c
 	m_anigif.c
 	m_argv.c
 	m_bbox.c
 	m_cheat.c
+	m_curl.c
 	m_cond.c
+	m_emotes.cpp
 	m_fixed.c
 	m_menu.c
 	m_textinput.c
@@ -40,19 +46,25 @@ set(SRB2_CORE_SOURCES
 	mserv.c
 	http-mserv.c
 	qs22j.c
+	r_skins.c
 	s_sound.c
 	screen.c
 	sounds.c
 	st_stuff.c
-	#string.c
+	string.c
 	tables.c
 	v_video.c
 	w_wad.c
 	y_inter.c
-	z_zone.c
+	z_zone.cpp
 )
 
 set(SRB2_CORE_HEADERS
+	core/memory.h
+	core/thread_pool.h
+	m_curl.h
+	m_emotes.h
+	k_hud.h
 	am_map.h
 	b_bot.h
 	byteptr.h
@@ -78,6 +90,7 @@ set(SRB2_CORE_HEADERS
 	fastcmp.h
 	filesrch.h
 	g_game.h
+	g_demo.h
 	g_input.h
 	g_state.h
 	hu_stuff.h
@@ -109,6 +122,7 @@ set(SRB2_CORE_HEADERS
 	md5.h
 	mserv.h
 	qs22j.h
+	r_skins.h
 	s_sound.h
 	screen.h
 	sounds.h
@@ -123,18 +137,18 @@ set(SRB2_CORE_HEADERS
 )
 
 set(SRB2_CORE_RENDER_SOURCES
-	r_bsp.c
+	r_bsp.cpp
 	r_data.c
-	r_draw.c
-	r_fps.c
-	r_main.c
-	r_patch.c
-	r_patchrotation.c
-	r_plane.c
-	r_segs.c
+	r_draw.cpp
+	r_fps.cpp
+	r_main.cpp
+	r_patch.cpp
+	r_patchrotation.cpp
+	r_plane.cpp
+	r_segs.cpp
 	r_sky.c
 	r_splats.c
-	r_things.c
+	r_things.cpp
 	r_portal.c
 
 	r_bsp.h
@@ -162,7 +176,7 @@ set(SRB2_CORE_GAME_SOURCES
 	p_inter.c
 	p_lights.c
 	p_map.c
-	p_maputl.c
+	p_maputl.cpp
 	p_mobj.c
 	p_polyobj.c
 	p_saveg.c
@@ -193,10 +207,6 @@ set(SRB2_CORE_GAME_SOURCES
 	k_stats.h
 )
 
-if(NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-	set(SRB2_CORE_SOURCES ${SRB2_CORE_SOURCES} string.c)
-endif()
-
 prepend_sources(SRB2_CORE_SOURCES)
 prepend_sources(SRB2_CORE_HEADERS)
 prepend_sources(SRB2_CORE_RENDER_SOURCES)
@@ -226,10 +236,23 @@ set(SRB2_CONFIG_HWRENDER ON CACHE BOOL
 	"Enable hardware rendering through OpenGL.")
 set(SRB2_CONFIG_STATIC_OPENGL OFF CACHE BOOL
 	"Use statically linked OpenGL. NOT RECOMMENDED.")
-set(SRB2_CONFIG_USE_FBO_OGL ON CACHE BOOL
-	"Enable OpenGL FBO Downsampling support.")
 set(SRB2_CONFIG_DEDICATED OFF CACHE BOOL
 	"Build a dedicated server.")
+set(SRB2_CONFIG_LIBBACKTRACE ON CACHE BOOL
+	"Enable using libbacktrace for crashlogs.")
+set(SRB2_CONFIG_LTO ON CACHE BOOL
+	"Enable link time optimizations, improves performance at the cost of longer link times.")
+set(SRB2_CONFIG_ASAN OFF CACHE BOOL
+	"Compile with AddressSanitizer (libasan).")
+set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
+	"Compile with UndefinedBehaviorSanitizer (libubsan).")
+
+set(SRB2_CONFIG_SATURNPAK ON CACHE BOOL
+	"Enable Saturn specific special packet. Required for using the newer resynch system")
+set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
+	"Enable Saturn specific allowjoin toggle.")
+set(SRB2_CONFIG_SCREENFBO ON CACHE BOOL
+	"Enable hardware renderer (OpenGL) FBO downsampling support")
 
 if(${SRB2_CONFIG_DEDICATED})
 	set(SRB2_CONFIG_HAVE_GME NO)
@@ -469,16 +492,36 @@ if(${SRB2_CONFIG_HAVE_CURL})
 	endif()
 endif()
 
+if(${SRB2_CONFIG_LIBBACKTRACE})
+	if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES})
+        if(${SRB2_SYSTEM_BITS} EQUAL 64)
+			set(LIBBACKTRACE_FOUND ON)
+			set(LIBBACKTRACE_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/libbacktrace/include)
+			set(LIBBACKTRACE_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/libbacktrace/lib/x86_64 -lbacktrace")
+		else() # 32-bit
+			message(WARNING "libbacktrace is unsupported on 32-bit builds.")
+		endif()
+	else()
+		find_package(libbacktrace)
+	endif()
+	if(${LIBBACKTRACE_FOUND})
+		set(SRB2_HAVE_LIBBACKTRACE ON)
+		add_definitions(-DHAVE_LIBBACKTRACE)
+	else()
+		message(WARNING "You have specified that libbacktrace is available but it was not found.")
+	endif()
+endif()
+
 if(${SRB2_CONFIG_HWRENDER})
 	add_definitions(-DHWRENDER)
 	set(SRB2_HWRENDER_SOURCES
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_batching.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_shaders.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_bsp.c
-		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.c
+		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.cpp
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c
-		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.c
+		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
@@ -493,7 +536,6 @@ if(${SRB2_CONFIG_HWRENDER})
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_data.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_defs.h
-		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_dll.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_gl.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_glob.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.h
@@ -512,7 +554,6 @@ if(${SRB2_CONFIG_HWRENDER})
 	set(SRB2_R_OPENGL_HEADERS
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/r_opengl/r_opengl.h
 	)
-
 endif()
 
 if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
@@ -525,25 +566,40 @@ if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
 	endif()
 endif()
 
-if(${SRB2_CONFIG_HWRENDER})
-	if(${SRB2_CONFIG_USE_FBO_OGL})
-		set(SRB2_USE_FBO_OGL ON)
-		add_definitions(-DUSE_FBO_OGL)
-	endif()
+if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_SCREENFBO})
+	add_definitions(-DUSE_FBO_OGL)
+endif()
+
+if(${SRB2_CONFIG_SATURNPAK})
+	add_definitions(-DDOSATURNPAK)
+endif()
+
+if(${SRB2_CONFIG_SATURNJOIN})
+	add_definitions(-DDOSATURNJOIN)
 endif()
 
 # Targets
 
 # Compatibility flag with later versions of GCC
 # We should really fix our code to not need this
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -mno-ms-bitfields)
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|x64|amd64|AMD64|em64t|EM64T)")
+		add_compile_options(-mno-ms-bitfields)
+	endif()
+	add_compile_options(-Wno-trigraphs)
 endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -Wno-absolute-value)
+# TODO: fix prng and P_CreateBlockmap overflow at some point
+add_compile_options(-fwrapv)
+
+if (${CMAKE_BUILD_TYPE} MATCHES Debug)
+	add_compile_options(-O0)
+else()
+	add_compile_options(-O3)
 endif()
 
+add_compile_options(-g)
+
 add_definitions(-DCMAKECONFIG)
 
 #add_library(SRB2Core STATIC

src/Makefile.d/detect.mk

@@ -64,9 +64,9 @@ endif
 
 # This must have high to low order.
 gcc_versions:=\
-	151 150 15\
+	152 151 150 15\
 	142 141 140 14\
-	132 131 130 13\
+	133 132 131 130 13\
 	123 122 121 120 12\
 	114 113 112 111 110 11\
 	105 104 103 102 101 100 10\
@@ -77,7 +77,7 @@ gcc_versions:=\
 	55 54 53 52 51 50\
 	49 48 47 46 45 44 43 42 41 40
 
-latest_gcc_version:=15.1.1
+latest_gcc_version:=15.2
 
 # Automatically set version flag, but not if one was
 # manually set. And don't bother if this is a clean only

src/Makefile.d/features.mk

@@ -8,7 +8,6 @@ passthru_opts+=\
 	HAVE_MINIUPNPC\
 	HAVE_DISCORDRPC DEVELOP\
 	NOHOLEPUNCH\
-	NOOPENMPT\
 
 # build with debugging information
 ifdef DEBUGMODE
@@ -92,6 +91,7 @@ endif
 
 default_packages:=\
 	LIBGME/libgme/LIBGME\
+	OPENMPT/libopenmpt/LIBOPENMPT\
 	ZLIB/zlib\
 
 $(foreach p,$(default_packages),\

src/Makefile.d/sdl.mk

@@ -29,19 +29,8 @@ ifndef NOHW
 sources+=sdl/ogl_sdl.c
 endif
 
-ifndef NOOPENMPT
-LIBOPENMPT_PKGCONFIG?=libopenmpt
-$(eval $(call Use_pkg_config,LIBOPENMPT))
-opts+=-DHAVE_OPENMPT
-endif
-
-NOMIXER=1
-
 ifdef NOMIXER
-#sources+=sdl/dummy_sound.c
-sources+=sdl/sdl_sound.c
-SNDFILE_PKGCONFIG?=sndfile
-$(eval $(call Use_pkg_config,SNDFILE))
+sources+=sdl/dummy_sound.c
 else
 opts+=-DHAVE_MIXER
 sources+=sdl/mixer_sound.c
@@ -56,8 +45,15 @@ opts+=-DHAVE_THREADS
 sources+=sdl/i_threads.c
 endif
 
-SDL_PKGCONFIG?=sdl3
+ifdef SDL_PKGCONFIG
 $(eval $(call Use_pkg_config,SDL))
+else
+SDL_CONFIG?=$(call Prefix,sdl2-config)
+SDL_CFLAGS?=$(shell $(SDL_CONFIG) --cflags)
+SDL_LDFLAGS?=$(shell $(SDL_CONFIG) \
+		$(if $(STATIC),--static-libs,--libs))
+$(eval $(call Propogate_flags,SDL))
+endif
 
 ifdef MINGW
 ifndef NOSDLMAIN

src/Makefile.d/versions.mk

@@ -20,7 +20,10 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wno-trigraphs
+WFLAGS:=-Wall -Wno-trigraphs -Wnull-dereference
+ifdef GCC152
+WFLAGS+=-Wzero-as-null-pointer-constant
+endif
 ifndef GCC295
 #WFLAGS+=-Wno-packed
 endif

src/Makefile.d/win32.mk

@@ -79,14 +79,14 @@ $(eval $(call _set,LIBOPENMPT))
 lib:=../libs/SDL2_mixer/$(mingw)
 
 ifdef SDL
-mixer_opts:=-I$(lib)/include/SDL3
+mixer_opts:=-I$(lib)/include/SDL2
 mixer_libs:=-L$(lib)/lib
 
 lib:=../libs/SDL2/$(mingw)
-SDL_opts:=-I$(lib)/include/SDL3\
+SDL_opts:=-I$(lib)/include/SDL2\
 	$(mixer_opts) -Dmain=SDL_main
 SDL_libs:=-L$(lib)/lib $(mixer_libs)\
-	-lmingw32 -lSDL3main -lSDL3 -mwindows
+	-lmingw32 -lSDL2main -lSDL2 -mwindows
 $(eval $(call _set,SDL))
 endif
 

src/Sourcefile

@@ -1,3 +1,4 @@
+string.c
 am_map.c
 b_bot.c
 command.c
@@ -42,7 +43,6 @@ s_sound.c
 screen.c
 sounds.c
 st_stuff.c
-string.c
 tables.c
 v_video.c
 w_wad.c

src/android/i_system.c

@@ -226,10 +226,6 @@ const char *I_LocateWad(void)
   return "/sdcard/srb2";
 }
 
-void I_GetJoystickEvents(void){}
-
-void I_GetJoystick2Events(void){}
-
 char *I_GetEnv(const char *name)
 {
   LOGW("I_GetEnv() called?!");

src/b_bot.c

@@ -47,7 +47,7 @@ static inline void B_BuildTailsTiccmd(mobj_t *sonic, mobj_t *tails, ticcmd_t *cm
 		if (sonic->player->pflags & (PF_MACESPIN|PF_ITEMHANG))
 		{
 			cmd->forwardmove = sonic->player->cmd.forwardmove;
-			cmd->angleturn = abs((signed)(tails->angle - sonic->angle))>>16;
+			cmd->angleturn = abs((signed)(tails->angle - sonic->angle)) >> TICCMD_REDUCE;
 			if (sonic->angle < tails->angle)
 				cmd->angleturn = -cmd->angleturn;
 		} else if (dist > FixedMul(512*FRACUNIT, tails->scale))
@@ -139,13 +139,13 @@ void B_KeysToTiccmd(mobj_t *mo, ticcmd_t *cmd, boolean forward, boolean backward
 			// Don't mess with bot inputs during these unhandled movement conditions.
 			// The normal AI doesn't use abilities, so custom AI should be sending us exactly what it wants anyway.
 			if (forward)
-				cmd->forwardmove += MAXPLMOVE<<FRACBITS>>16;
+				cmd->forwardmove += MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 			if (backward)
-				cmd->forwardmove -= MAXPLMOVE<<FRACBITS>>16;
+				cmd->forwardmove -= MAXPLMOVE<<FRACBITS >> TICCMD_REDUCE;
 			if (left || strafeleft)
-				cmd->sidemove -= MAXPLMOVE<<FRACBITS>>16;
+				cmd->sidemove -= MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 			if (right || straferight)
-				cmd->sidemove += MAXPLMOVE<<FRACBITS>>16;
+				cmd->sidemove += MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 		} else {
 			// In standard 2D mode, interpret "forward" as "the way you're facing" and everything else as "the way you're not facing"
 			if (left || right)
@@ -163,23 +163,23 @@ void B_KeysToTiccmd(mobj_t *mo, ticcmd_t *cmd, boolean forward, boolean backward
 					right = true;
 			}
 			if (left || strafeleft)
-				cmd->sidemove -= MAXPLMOVE<<FRACBITS>>16;
+				cmd->sidemove -= MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 			if (right || straferight)
-				cmd->sidemove += MAXPLMOVE<<FRACBITS>>16;
+				cmd->sidemove += MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 		}
 	} else {
 		if (forward)
-			cmd->forwardmove += MAXPLMOVE<<FRACBITS>>16;
+			cmd->forwardmove += MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 		if (backward)
-			cmd->forwardmove -= MAXPLMOVE<<FRACBITS>>16;
+			cmd->forwardmove -= MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 		if (left)
 			cmd->angleturn += 1280;
 		if (right)
 			cmd->angleturn -= 1280;
 		if (strafeleft)
-			cmd->sidemove -= MAXPLMOVE<<FRACBITS>>16;
+			cmd->sidemove -= MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 		if (straferight)
-			cmd->sidemove += MAXPLMOVE<<FRACBITS>>16;
+			cmd->sidemove += MAXPLMOVE << FRACBITS >> TICCMD_REDUCE;
 	}
 	if (jump)
 		cmd->buttons |= BT_DRIFT;

src/blua/lapi.c

@@ -519,6 +519,23 @@ LUA_API int lua_pushthread (lua_State *L) {
 ** get functions (Lua -> stack)
 */
 
+static void auxgetstr (lua_State *L, const TValue *t, const char *k) {
+  const TValue *slot;
+  TValue key;
+  TString *str = luaS_new(L, k);
+  api_checkvalidindex(L, t);
+  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
+    setobj2s(L, L->top, slot);
+    api_incr_top(L);
+  }
+  else {
+    setsvalue(L, &key, str);
+    luaV_finishget(L, t, L->top, L->top, slot);
+    api_incr_top(L);
+  }
+  lua_unlock(L);
+}
+
 
 LUA_API void lua_gettable (lua_State *L, int idx) {
   StkId t;
@@ -531,15 +548,8 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
 
 
 LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
   lua_lock(L);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_gettable(L, t, &key, L->top);
-  api_incr_top(L);
-  lua_unlock(L);
+  auxgetstr(L, index2adr(L, idx), k);
 }
 
 
@@ -630,6 +640,26 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
 ** set functions (stack -> Lua)
 */
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
+  TValue key;
+  const TValue *slot;
+  TString *str = luaS_new(L, k);
+  api_checknelems(L, 1);
+  api_checkvalidindex(L, t);
+  if (luaV_fastset(L, t, str, slot, luaH_setstr, L->top)) {
+    setobj2t(L, cast(TValue *, slot), L->top - 1);
+    L->top--;  /* pop value */
+  }
+  else {
+    setsvalue2s(L, &key, str);
+    luaV_finishset(L, t, &key, L->top - 1, slot);
+    L->top--;  /* pop value */
+  }
+  lua_unlock(L);
+}
+
 
 LUA_API void lua_settable (lua_State *L, int idx) {
   StkId t;
@@ -642,18 +672,12 @@ LUA_API void lua_settable (lua_State *L, int idx) {
   lua_unlock(L);
 }
 
+#pragma GCC diagnostic pop
+
 
 LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
-  StkId t;
-  TValue key;
   lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2adr(L, idx);
-  api_checkvalidindex(L, t);
-  setsvalue(L, &key, luaS_new(L, k));
-  luaV_settable(L, t, &key, L->top - 1);
-  L->top--;  /* pop value */
-  lua_unlock(L);
+  auxsetstr(L, index2adr(L, idx), k);
 }
 
 

src/blua/lauxlib.c

@@ -20,6 +20,7 @@
 #define lauxlib_c
 #define LUA_LIB
 
+#include "ldebug.h"
 #include "lua.h"
 
 #include "lauxlib.h"
@@ -93,6 +94,57 @@ LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
 /* }====================================================== */
 
 
+/*
+** {======================================================
+** 'luaL_resourcetryagain'
+** This function uses 'errno' to check whether the last error was
+** related to lack of resources (e.g., not enough memory or too many
+** open files).  If so, the function performs a full garbage collection
+** to try to release resources, and then it returns 1 to signal to
+** the caller that it is worth trying again the failed operation.
+** Otherwise, it returns 0.  Because error codes are not ANSI C, the
+** code must handle any combination of error codes that are defined.
+** =======================================================
+*/
+
+LUALIB_API int luaL_resourcetryagain (lua_State *L) {
+
+/* these are the resource-related errors in Linux */
+#if defined(EMFILE) || defined(ENFILE) || defined(ENOMEM)
+
+#if !defined(EMFILE)	/* too many open files in the process */
+#define EMFILE		-1	/* if not defined, use an impossible value */
+#endif
+
+#if !defined(ENFILE)	/* too many open files in the system */
+#define ENFILE		-1
+#endif
+
+#if !defined(ENOMEM)	/* not enough memory */
+#define ENOMEM		-1
+#endif
+
+  if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+    CONS_Alert(CONS_WARNING, "%s, force calling lua garbage collector\n", strerror(errno));
+    lua_gc(L, LUA_GCCOLLECT, 0);  /* try to release resources with a full GC */
+    return 1;  /* signal to try again the creation */
+  }
+
+#endif
+
+  return 0;  /* else, asume errors are not due to lack of resources */
+
+}
+
+/* }====================================================== */
+
+
+/*
+** {======================================================
+** Userdata's metatable manipulation
+** =======================================================
+*/
+
 LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
                                  const char *const lst[]) {
   const char *name = (def) ? luaL_optstring(L, narg, def) :
@@ -417,8 +469,19 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
 
 
 LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  while (l--)
-    luaL_addchar(B, *s++);
+ while (l) {
+    size_t space = bufffree(B);
+    if (space == 0) {
+      luaL_prepbuffer(B);
+      lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
+      space = LUAL_BUFFERSIZE;
+    }
+    if (space > l) space = l;
+    memcpy(B->p, s, space);
+    B->p += space;
+    s += space;
+    l -= space;
+  }
 }
 
 
@@ -635,6 +698,6 @@ static int panic (lua_State *L) {
 
 LUALIB_API lua_State *luaL_newstate (void) {
   lua_State *L = lua_newstate(l_alloc, NULL);
-  if (L) lua_atpanic(L, &panic);
+  if (l_likely(L)) lua_atpanic(L, &panic);
   return L;
 }

src/blua/lauxlib.h

@@ -95,6 +95,8 @@ LUALIB_API FUNCREPORT int (luaL_error) (lua_State *L, const char *fmt, ...);
 LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
                                    const char *const lst[]);
 
+LUALIB_API int (luaL_resourcetryagain) (lua_State *L);
+
 LUALIB_API int (luaL_ref) (lua_State *L, int t);
 LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
 

src/blua/lcode.c

@@ -626,8 +626,20 @@ static void codenot (FuncState *fs, expdesc *e) {
   removevalues(fs, e->t);
 }
 
+/*
+** Check whether expression 'e' is a literal string
+*/
+static int isKstr (FuncState *fs, expdesc *e) {
+  return (e->k == VK && ttisstring(&fs->f->k[e->u.s.info]));
+}
 
+/*
+** Create expression 't[k]'. 't' must have its final result already in a
+** register or upvalue. Upvalues can only be indexed by literal strings.
+*/
 void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
+  if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non string? */
+    luaK_exp2anyreg(fs, t);  /* put it in a register */
   t->u.s.aux = luaK_exp2RK(fs, k);
   t->k = VINDEXED;
 }
@@ -790,18 +802,19 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
     case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
     case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
     case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
+      break;
+    }
+    case OPR_EQ: case OPR_LT: case OPR_LE: {
+      codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
+      break;
+    }
+    case OPR_NE: case OPR_GT: case OPR_GE: {
+      codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
+      break;
+    }
     default: lua_assert(0);
   }
 }

src/blua/lcode.h

@@ -21,13 +21,13 @@
 
 
 /*
-** grep "ORDER OPR" if you change these enums
+** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
   OPR_CONCAT,
-  OPR_NE, OPR_EQ,
-  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_EQ, OPR_LT, OPR_LE,
+  OPR_NE, OPR_GT, OPR_GE,
   OPR_AND, OPR_OR,
   OPR_BAND, OPR_BOR, OPR_BXOR,
   OPR_BSHL, OPR_BSHR,

src/blua/ldebug.c

@@ -542,16 +542,39 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
 
 
 static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+  TMS tm = 0;
   Instruction i;
   if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
     return NULL;  /* calling function is not Lua (or is unknown) */
   ci--;  /* calling function */
   i = ci_func(ci)->l.p->code[currentpc(L, ci)];
-  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
-      GET_OPCODE(i) == OP_TFORLOOP)
-    return getobjname(L, ci, GETARG_A(i), name);
-  else
-    return NULL;  /* no useful name can be found */
+  switch (GET_OPCODE(i)) {
+    case OP_CALL:
+    case OP_TAILCALL:
+    case OP_TFORLOOP:
+      return getobjname(L, ci, GETARG_A(i), name);
+    case OP_GETGLOBAL:
+    case OP_SELF:
+    case OP_GETTABLE: tm = TM_INDEX; break;
+    case OP_SETGLOBAL:
+    case OP_SETTABLE: tm = TM_NEWINDEX; break;
+    case OP_EQ: tm = TM_EQ; break;
+    case OP_ADD: tm = TM_ADD; break;
+    case OP_SUB: tm = TM_SUB; break;
+    case OP_MUL: tm = TM_MUL; break;
+    case OP_DIV: tm = TM_DIV; break;
+    case OP_MOD: tm = TM_MOD; break;
+    case OP_POW: tm = TM_POW; break;
+    case OP_UNM: tm = TM_UNM; break;
+    case OP_LEN: tm = TM_LEN; break;
+    case OP_LT: tm = TM_LT; break;
+    case OP_LE: tm = TM_LE; break;
+    case OP_CONCAT: tm = TM_CONCAT; break;
+    default:
+      return NULL;  /* else no useful name can be found */
+  }
+  *name = getstr(G(L)->tmname[tm]);
+  return "metamethod";
 }
 
 

src/blua/ldo.c

@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
 
 
 void luaD_growstack (lua_State *L, int n) {
-  if (l_likely(n <= L->stacksize))  /* double size is enough? */
+  if (n <= L->stacksize)  /* double size is enough? */
     luaD_reallocstack(L, 2*L->stacksize);
   else
     luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
     ci->top = L->top + LUA_MINSTACK;
     lua_assert(ci->top <= L->stack_last);
     ci->nresults = nresults;
-    if (L->hookmask & LUA_MASKCALL)
+    if (l_unlikely(L->hookmask & LUA_MASKCALL))
       luaD_callhook(L, LUA_HOOKCALL, -1);
     lua_unlock(L);
     n = (*curr_func(L)->c.f)(L);  /* do the actual call */

src/blua/liolib.c

@@ -58,12 +58,6 @@ static int pushresult (lua_State *L, int i, const char *filename) {
 }
 
 
-static void fileerror (lua_State *L, int arg, const char *filename) {
-  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
-  luaL_argerror(L, arg, lua_tostring(L, -1));
-}
-
-
 #define tofilep(L)	((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
 
 
@@ -165,6 +159,24 @@ static int StartsWith(const char *a, const char *b) // this is wolfs being lazy
    return 0;
 }
 
+/*
+** Equivalent to 'fopen', but if it fails due to a lack of resources
+** (see 'luaL_resourcetryagain'), do an "emergency" garbage collection to try
+** to close some files and then tries to open the file again.
+*/
+static FILE *trytoopen (lua_State *L, const char *path, const char *mode) {
+  FILE *f = fopen(path, mode);
+  if (f == NULL && luaL_resourcetryagain(L))  /* resource failure? */
+    f = fopen(path, mode);  /* try to open again */
+  return f;
+}
+
+static void opencheck (lua_State *L, const char *fname, const char *mode) {
+  FILE **p = newfile(L);
+  *p = trytoopen(L, fname, mode);
+  if (l_unlikely(*p == NULL))
+    luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
+}
 
 static int io_open(lua_State *L)
 {
@@ -212,7 +224,7 @@ static int io_open(lua_State *L)
 	}
 
 	pf = newfile(L);
-	*pf = fopen(destFilename, mode);
+	*pf = trytoopen(L, destFilename, mode);
 	return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
 }
 
@@ -220,6 +232,8 @@ static int io_open(lua_State *L)
 static int io_tmpfile (lua_State *L) {
   FILE **pf = newfile(L);
   *pf = tmpfile();
+  if (*pf == NULL && luaL_resourcetryagain(L))  /* resource failure? */
+    *pf = tmpfile();  /* try to open again */
   return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
 }
 
@@ -238,10 +252,7 @@ static int g_iofile (lua_State *L, int f, const char *mode) {
   if (!lua_isnoneornil(L, 1)) {
     const char *filename = lua_tostring(L, 1);
     if (filename) {
-      FILE **pf = newfile(L);
-      *pf = fopen(filename, mode);
-      if (l_unlikely(*pf == NULL))
-        fileerror(L, 1, filename);
+      opencheck(L, filename, mode);
     }
     else {
       tofile(L);  /* check that it's a valid file handle */
@@ -290,10 +301,7 @@ static int io_lines (lua_State *L) {
   }
   else {
     const char *filename = luaL_checkstring(L, 1);
-    FILE **pf = newfile(L);
-    *pf = fopen(filename, "r");
-    if (l_unlikely(*pf == NULL))
-      fileerror(L, 1, filename);
+    opencheck(L, filename, "r");
     aux_lines(L, lua_gettop(L), 1);
     return 1;
   }
@@ -348,20 +356,21 @@ static int read_line (lua_State *L, FILE *f) {
 
 
 static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
+  size_t tbr = n;  /* number of chars to be read */
+  size_t rlen;  /* how much to read in each cycle */
+  size_t nr;  /* number of chars actually read in each cycle */
   luaL_Buffer b;
   luaL_buffinit(L, &b);
   rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
   do {
     char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    if (rlen > tbr) rlen = tbr;  /* cannot read more than asked */
     nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
-    n -= nr;  /* still have to read `n' chars */
-  } while (n > 0 && nr == rlen);  /* until end of count or eof */
+    tbr -= nr;  /* still have to read 'tbr' chars */
+  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
   luaL_pushresult(&b);  /* close buffer */
-  return (n == 0 || lua_objlen(L, -1) > 0);
+  return (tbr == 0 || tbr < n);  /* true iff read something */
 }
 
 
@@ -424,13 +433,13 @@ static int f_read (lua_State *L) {
 
 static int io_readline (lua_State *L) {
   FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int sucess;
+  int success;
   if (f == NULL)  /* file is already closed? */
     luaL_error(L, "file is already closed");
-  sucess = read_line(L, f);
+  success = read_line(L, f);
   if (ferror(f))
     return luaL_error(L, "%s", strerror(errno));
-  if (sucess) return 1;
+  if (success) return 1;
   else {  /* EOF */
     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
       lua_settop(L, 0);

src/blua/lopcodes.h

@@ -232,6 +232,8 @@ OP_VARARG/*	A B	R(A), R(A+1), ..., R(A+B-1) = vararg		*/
   (*) In OP_SETLIST, if (B == 0) then B = `top';
       if (C == 0) then next `instruction' is real C
 
+  (*) In OP_SELF, the index must be a string.
+
   (*) For comparisons, A specifies what condition the test should accept
       (true or false).
 

src/blua/lparser.c

@@ -881,10 +881,10 @@ static const struct {
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
    {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* power and concat (right associative) */
-   {3, 3}, {3, 3},                  /* equality and inequality */
-   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
-   {2, 2}, {1, 1}                   /* logical (and/or) */
+   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
+   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
+   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
+   {2, 2}, {1, 1}                   /* and, or */
    ,{6, 6}, {6, 6}, {6, 6},           /* bit-wise (band/bor/bxor) */
    {7, 7}, {7, 7}		    /* shl/shr */
 };

src/blua/lstring.c

@@ -51,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
                                        unsigned int h) {
   TString *ts;
   stringtable *tb;
-  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
+  if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
     luaM_toobig(L);
   ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
   ts->tsv.len = l;
@@ -72,18 +72,72 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
 }
 
 
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
+// string hash taken from luaJIT
+
+/* Unaligned load of uint32_t. */
+static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
+{
+  uint32_t result;
+  memcpy(&result, ptr, 4);
+  return result;
+}
+
+// smol macro to look a little less messy lul
+#define getu8(p) *cast(const uint8_t *, p)
+
+/* Keyed sparse ARX string hash. Constant time. */
+static unsigned hash_sparse(const char *str, size_t len)
+{
+  /* Constants taken from lookup3 hash by Bob Jenkins. */
+  unsigned int a, b, h = cast(unsigned int, len);
+#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
+  if (len >= 4) {  /* Caveat: unaligned access! */
+    a  = getu32(str);
+    h ^= getu32(str+len-4);
+    b  = getu32(str+(len>>1)-2);
+    h ^= b; h -= rol(b, 14);
+    b += getu32(str+(len>>2)-1);
+  } else if (len > 0) {
+    a  = getu8(str);
+    h ^= getu8(str+len-1);
+    b  = getu8(str+(len>>1));
+    h ^= b; h -= rol(b, 14);
+  } else {
+    return 0;
+  }
+  a ^= h; a -= rol(h, 11);
+  b ^= a; b -= rol(a, 25);
+  h ^= b; h -= rol(b, 16);
+#undef rol
+  return h;
+}
+
+#undef getu8
+
+
+static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
+#if 0
   unsigned int h = cast(unsigned int, l);  /* seed */
   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
   size_t l1;
   for (l1=l; l1>=step; l1-=step)  /* compute hash */
     h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
+  return h;
+#else
+  return hash_sparse(str, l);
+#endif
+}
+
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
+  unsigned int h = luaS_hash(str, l);
   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
        o != NULL;
        o = o->gch.next) {
     TString *ts = rawgco2ts(o);
-    if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
+    if (ts->tsv.hash == h &&
+        ts->tsv.len == l &&
+       (memcmp(str, getstr(ts), l) == 0)) {
       /* string may be dead */
       if (isdead(G(L), o)) changewhite(o);
       return ts;

src/blua/lstrlib.c

@@ -527,7 +527,7 @@ static int str_find_aux (lua_State *L, int find) {
         if (find) {
           lua_pushinteger(L, s1-s+1);  /* start */
           lua_pushinteger(L, res-s);   /* end */
-          return push_captures(&ms, NULL, 0) + 2;
+          return push_captures(&ms, NULL, NULL) + 2;
         }
         else
           return push_captures(&ms, s1, res);

src/blua/ltm.c

@@ -61,7 +61,7 @@ TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
 }
 
 
-TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event) {
+TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
   Table *mt;
   switch (ttype(o)) {
     case LUA_TTABLE:

src/blua/ltm.h

@@ -55,7 +55,7 @@ LUAI_DATA const char *const luaT_typenames[];
 
 
 LUAI_FUNC TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event);
+LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event);
 LUAI_FUNC void luaT_init (lua_State *L);
 
 #endif

src/blua/luaconf.h

@@ -772,10 +772,10 @@ union luai_Cast { double l_d; long l_l; };
 
 #include <stdio.h>
 #if defined(__GNUC__)
-#define l_likely(x)	(__builtin_expect(((x) != 0), 1))
-#define l_unlikely(x)	(__builtin_expect(((x) != 0), 0))
+#define l_likely(x)		(__builtin_expect(!!(x), 1))
+#define l_unlikely(x)	(__builtin_expect(!!(x), 0))
 #else
-#define l_likely(x)	(x)
+#define l_likely(x)		(x)
 #define l_unlikely(x)	(x)
 #endif
 

src/blua/lvm.c

@@ -28,7 +28,7 @@
 
 
 
-/* limit for table tag-method chains (to avoid loops) */
+/* limit for table tag-method chains (to avoid infinite loops) */
 #define MAXTAGLOOP	100
 
 
@@ -105,61 +105,94 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
 }
 
 
-void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
-  int loop;
+/*
+** Finish the table access 'val = t[key]'.
+** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
+** t[k] entry (which must be nil).
+*/
+void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
+                      const TValue *slot) {
+  int loop;  /* counter to avoid infinite loops */
+  const TValue *tm;  /* metamethod */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    TValue *tm;
-    if (ttistable(t)) {  /* `t' is a table? */
-      Table *h = hvalue(t);
-      const TValue *res = luaH_get(h, key); /* do a primitive get */
-      if (!ttisnil(res) ||  /* result is no nil? */
-          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
-        setobj2s(L, val, res);
+    if (slot == NULL) {  /* 't' is not a table? */
+      lua_assert(!ttistable(t));
+      tm = luaT_gettmbyobj(L, t, TM_INDEX);
+      if (l_unlikely(ttisnil(tm)))
+        luaG_typeerror(L, t, "index");  /* no metamethod */
+      /* else will try the metamethod */
+    }
+    else {  /* 't' is a table */
+      lua_assert(ttisnil(slot));
+      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
+      if (tm == NULL) {  /* no metamethod? */
+        setnilvalue(val);  /* result is nil */
         return;
       }
-      /* else will try the tag method */
+      /* else will try the metamethod */
     }
-    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
-      luaG_typeerror(L, t, "index");
-    if (ttisfunction(tm)) {
-      callTMres(L, val, tm, t, key);
+    if (ttisfunction(tm)) {  /* is metamethod a function? */
+      callTMres(L, val, tm, t, key);  /* call it */
       return;
     }
-    t = tm;  /* else repeat with `tm' */
+    t = tm;  /* else try to access 'tm[key]' */
+    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
+      setobj2s(L, val, slot);  /* done */
+      return;
+    }
+    /* else repeat (tail call 'luaV_finishget') */
   }
-  luaG_runerror(L, "loop in gettable");
+  luaG_runerror(L, "'__index' chain too long; possible loop");
 }
 
-
-void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
-  int loop;
+/*
+** Finish a table assignment 't[key] = val'.
+** If 'slot' is NULL, 't' is not a table.  Otherwise, 'slot' points
+** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
+** entry.  (The value at 'slot' must be nil, otherwise 'luaV_fastset'
+** would have done the job.)
+*/
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
+                     StkId val, const TValue *slot) {
+  int loop;  /* counter to avoid infinite loops */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    TValue *tm = NULL;
-    if (ttistable(t)) {  /* `t' is a table? */
+    const TValue *tm;
+    if (slot != NULL) {
+      lua_assert(ttistable(t) && ttisnil(slot));
       Table *h = hvalue(t);
-      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
-      /* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
-      if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
-         ((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
-        setobj2t(L, oldval, val);
+      /* must check the metamethod */
+      /* slot is nil=> look for newindex, slot is not nil => look for usedindex */
+      if (!((ttisnil(slot) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
+         ((!ttisnil(slot)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
+        /* no metamethod and (now) there is an entry with given key */
+        setobj2t(L, cast(TValue *, slot), val);
         luaC_barriert(L, h, val);
         return;
       }
-      /* else will try the tag method */
+      /* else will try the metamethod */
     }
-    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
-      luaG_typeerror(L, t, "index");
+    else {  /* not a table; check metamethod */
+      if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
+        luaG_typeerror(L, t, "index");
+    }
+    /* try the metamethod */
     if (ttisfunction(tm)) {
       callTM(L, tm, t, key, val);
       return;
     }
-    t = tm;  /* else repeat with `tm' */
+    t = tm;  /* else repeat assignment over 'tm' */
+    if (luaV_fastset(L, t, key, slot, luaH_set, val))
+      return;  /* done */
+    /* else loop */
   }
-  luaG_runerror(L, "loop in settable");
+  luaG_runerror(L, "settable chain too long; possible loop");
 }
+#pragma GCC diagnostic pop
 
 
-static int call_binTM (lua_State *L, TValue *p1, TValue *p2,
+static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                        StkId res, TMS event) {
   const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
   if (ttisnil(tm))
@@ -184,7 +217,7 @@ static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
 }
 
 
-static int call_orderTM (lua_State *L, TValue *p1, TValue *p2,
+static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
                          TMS event) {
   const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
   const TValue *tm2;
@@ -366,6 +399,7 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
 
 
 #define arith_op(op,tm) { \
+        StkId ra = RA(i); \
         TValue *rb = RKB(i); \
         TValue *rc = RKC(i); \
         if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -377,6 +411,24 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
       }
 
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+
+/*
+** copy of 'luaV_gettable', but protecting call to potential metamethod
+** (which can reallocate the stack)
+*/
+#define gettableProtected(L,t,k,v)  { const TValue *slot; \
+  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
+  else Protect(luaV_finishget(L,t,k,v,slot)); }
+
+
+/* same for 'luaV_settable' */
+#define settableProtected(L,t,k,v) { const TValue *slot; \
+  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
+    Protect(luaV_finishset(L,t,k,v,slot)); }
+
+
 
 void luaV_execute (lua_State *L, int nexeccalls) {
   LClosure *cl;
@@ -386,13 +438,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
  reentry:  /* entry point */
   lua_assert(isLua(L->ci));
   pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;
-  base = L->base;
-  k = cl->p->k;
+  cl = &clvalue(L->ci->func)->l;  /* local reference to function's closure */
+  k = cl->p->k;  /* local reference to function's constant table */
+  base = L->base;  /* local copy of function's base */
   /* main loop of interpreter */
   for (;;) {
     const Instruction i = *pc++;
-    StkId ra;
     if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
       traceexec(L, pc);
@@ -402,26 +453,28 @@ void luaV_execute (lua_State *L, int nexeccalls) {
       }
       base = L->base;
     }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
     lua_assert(base == L->base && L->base == L->ci->base);
     lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
     lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
     switch (GET_OPCODE(i)) {
       case OP_MOVE: {
+        StkId ra = RA(i);
         setobjs2s(L, ra, RB(i));
         continue;
       }
       case OP_LOADK: {
+        StkId ra = RA(i);
         setobj2s(L, ra, KBx(i));
         continue;
       }
       case OP_LOADBOOL: {
+        StkId ra = RA(i);
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
         continue;
       }
       case OP_LOADNIL: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
@@ -429,11 +482,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETUPVAL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
         continue;
       }
       case OP_GETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         TValue *rb = KBx(i);
         sethvalue(L, &g, cl->env);
@@ -442,10 +497,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
+        StkId ra = RA(i);
+        StkId rb = RB(i);
+        TValue *rc = RKC(i);
+        gettableProtected(L, rb, rc, ra);
         continue;
       }
       case OP_SETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
@@ -453,16 +512,21 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETUPVAL: {
+        StkId ra = RA(i);
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
         continue;
       }
       case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
+        StkId ra = RA(i);
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        settableProtected(L, ra, rb, rc);
         continue;
       }
       case OP_NEWTABLE: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int c = GETARG_C(i);
         sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -470,9 +534,16 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SELF: {
+        StkId ra = RA(i);
+        const TValue *slot;
         StkId rb = RB(i);
-        setobjs2s(L, ra+1, rb);
-        Protect(luaV_gettable(L, rb, RKC(i), ra));
+        TValue *rc = RKC(i);
+        TString *key = rawtsvalue(rc);  /* key must be a string */
+        setobjs2s(L, ra + 1, rb);
+        if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
+          setobj2s(L, ra, slot);
+        }
+        else Protect(luaV_finishget(L, rb, rc, ra, slot));
         continue;
       }
       case OP_ADD: {
@@ -488,6 +559,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_DIV: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -503,6 +575,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_MOD: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -522,26 +595,27 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_BAND: {
-	arith_op(luai_numand, TM_AND);
-	continue;
+        arith_op(luai_numand, TM_AND);
+        continue;
       }
       case OP_BOR: {
-	arith_op(luai_numor, TM_OR);
-	continue;
+        arith_op(luai_numor, TM_OR);
+        continue;
       }
       case OP_BXOR: {
-	arith_op(luai_numxor, TM_XOR);
-	continue;
+        arith_op(luai_numxor, TM_XOR);
+        continue;
       }
       case OP_BSHL: {
-	arith_op(luai_numshl, TM_SHL);
-	continue;
+        arith_op(luai_numshl, TM_SHL);
+        continue;
       }
       case OP_BSHR: {
-	arith_op(luai_numshr, TM_SHR);
-	continue;
+        arith_op(luai_numshr, TM_SHR);
+        continue;
       }
       case OP_BNOT: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -553,6 +627,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_UNM: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -564,11 +639,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_NOT: {
+        StkId ra = RA(i);
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
         continue;
       }
       case OP_LEN: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         switch (ttype(rb)) {
           case LUA_TTABLE: {
@@ -626,12 +703,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TEST: {
+        StkId ra = RA(i);
         if (l_isfalse(ra) != GETARG_C(i))
           dojump(L, pc, GETARG_sBx(*pc));
         pc++;
         continue;
       }
       case OP_TESTSET: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (l_isfalse(rb) != GETARG_C(i)) {
           setobjs2s(L, ra, rb);
@@ -641,6 +720,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int nresults = GETARG_C(i) - 1;
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
@@ -662,6 +742,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_TAILCALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         L->savedpc = pc;
@@ -694,6 +775,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_RETURN: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
@@ -709,6 +791,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_FORLOOP: {
+        StkId ra = RA(i);
         lua_Number step = nvalue(ra+2);
         lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
         lua_Number limit = nvalue(ra+1);
@@ -721,6 +804,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_FORPREP: {
+        StkId ra = RA(i);
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
@@ -737,6 +821,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TFORLOOP: {
+        StkId ra = RA(i);
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+2, ra+2);
         setobjs2s(L, cb+1, ra+1);
@@ -753,6 +838,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETLIST: {
+        StkId ra = RA(i);
         int n = GETARG_B(i);
         int c = GETARG_C(i);
         int last;
@@ -775,10 +861,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CLOSE: {
+        StkId ra = RA(i);
         luaF_close(L, ra);
         continue;
       }
       case OP_CLOSURE: {
+        StkId ra = RA(i);
         Proto *p;
         Closure *ncl;
         int nup, j;
@@ -799,6 +887,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_VARARG: {
+        StkId ra = RA(i);
         int b = GETARG_B(i) - 1;
         int j;
         CallInfo *ci = L->ci;
@@ -822,3 +911,5 @@ void luaV_execute (lua_State *L, int nexeccalls) {
     }
   }
 }
+
+#pragma GCC diagnostic pop

src/blua/lvm.h

@@ -22,14 +22,61 @@
 	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
 
 
+/*
+** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
+** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
+** return 0 (meaning it will have to check metamethod) with 'slot'
+** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
+** 'f' is the raw get function to use.
+*/
+#define luaV_fastget(L,t,k,slot,f) \
+  (!ttistable(t)  \
+   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
+   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
+      !ttisnil(slot)))  /* result not nil? */
+
+/*
+** standard implementation for 'gettable'
+*/
+#define luaV_gettable(L,t,k,v) { const TValue *slot; \
+  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
+  else luaV_finishget(L,t,k,v,slot); }
+
+
+/*
+** Fast track for set table. If 't' is a table and 't[k]' is not nil,
+** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
+** return false with 'slot' equal to NULL (if 't' is not a table) or
+** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
+** returns true, there is no need to 'invalidateTMcache', because the
+** call is not creating a new entry.
+*/
+#define luaV_fastset(L,t,k,slot,f,v) \
+  (!ttistable(t) \
+   ? (slot = NULL, 0) \
+   : (slot = f(L, hvalue(t), k), \
+     ttisnil(slot) ? 0 \
+     : (__extension__ ({ \
+          if (valiswhite(v) && isblack(obj2gco(hvalue(t)))) \
+            luaC_barrierback(L, hvalue(t)); \
+          setobj2t(L, cast(TValue *,slot), v); \
+          1; \
+        }))))
+
+#define luaV_settable(L,t,k,v) { const TValue *slot; \
+  if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
+    luaV_finishset(L,t,k,v,slot); }
+
+
+
 LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
 LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
 LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
 LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
-                                            StkId val);
-LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
-                                            StkId val);
+LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
+                               StkId val, const TValue *tm);
+LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
+                               StkId val, const TValue *oldval);
 LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
 LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
 

src/command.c

@@ -655,7 +655,7 @@ static void COM_Alias_f(void)
 		CONS_Printf(M_GetText("All aliases that start with \x87'%s'\x80 are:\n"), begin);
 
 		int count = 0;
-		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head != NULL; head = head->next)
 		{
 			if (strncmp(begin, head->name, szBegin) == 0)
 			{
@@ -676,7 +676,7 @@ static void COM_Alias_f(void)
 		/* Display alias subtext, show all aliases. */
 		CONS_Printf(M_GetText("alias <name> <command>: create a shortcut command that executes other command(s)\n"));
 
-		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head != NULL; head = head->next)
 		{
 			CONS_Printf(alias_format, head->name, head->value);
 		}
@@ -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 && !mapheaderinfo[newvalue])
+					if (newvalue >= 0 && newvalue < NUMMAPS && !mapheaderinfo[newvalue])
 						continue; // Don't allocate the header.  That just makes memory usage skyrocket.
 
 				} while (!M_CanShowLevelInList(newvalue, gt));

src/command.h

@@ -13,13 +13,13 @@
 #ifndef __COMMAND_H__
 #define __COMMAND_H__
 
+#include <stdio.h>
+#include "doomdef.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <stdio.h>
-#include "doomdef.h"
-
 //===================================
 // Command buffer & command execution
 //===================================

src/config.h.in

@@ -11,21 +11,6 @@
 
 #ifdef CMAKECONFIG
 
-// Base SRB2 hashes
-#define ASSET_HASH_SRB2_SRB      "${SRB2_ASSET_srb2.srb_HASH}"
-#ifdef USE_PATCH_DTA
-#define ASSET_HASH_PATCH_DTA     "${SRB2_ASSET_patch.dta_HASH}"
-#endif
-
-// SRB2Kart-specific hashes
-#define ASSET_HASH_GFX_KART      "${SRB2_ASSET_gfx.kart_HASH}"
-#define ASSET_HASH_TEXTURES_KART "${SRB2_ASSET_textures.kart_HASH}"
-#define ASSET_HASH_CHARS_KART    "${SRB2_ASSET_chars.kart_HASH}"
-#define ASSET_HASH_MAPS_KART     "${SRB2_ASSET_maps.kart_HASH}"
-#ifdef USE_PATCH_KART
-#define ASSET_HASH_PATCH_KART    "00000000000000000000000000000000"
-#endif
-
 #define SRB2_COMP_REVISION       "${SRB2_COMP_REVISION}"
 #define SRB2_COMP_BRANCH         "${SRB2_COMP_BRANCH}"
 
@@ -33,30 +18,10 @@
 
 #else
 
-/* Manually defined asset hashes for non-CMake builds
- * Last updated 2015 / 05 / 03 - SRB2 v2.1.15 - srb2.srb
- * Last updated 2018 / 12 / 23 - SRB2 v2.1.22 - patch.dta
- * Last updated 2019 / 01 / 18 - Kart v1.0.2 - Main assets
- * Last updated 2020 / 08 / 30 - Kart v1.3 - patch.kart
- * Last updated 2022 / 08 / 16 - Kart v1.4 - Main assets
- * Last updated 2022 / 08 / 19 - Kart v1.5 - gfx.kart
- * Last updated 2022 / 11 / 01 - Kart v1.6 - gfx.kart, maps.kart
- */
+#define SRB2_COMP_REVISION       ""
+#define SRB2_COMP_BRANCH         ""
 
-// Base SRB2 hashes
-#define ASSET_HASH_SRB2_SRB      "c1b9577687f8a795104aef4600720ea7"
-#ifdef USE_PATCH_DTA
-#define ASSET_HASH_PATCH_DTA     "b04fd9624bfd94dc96dcf4f400f7deb4"
-#endif
-
-// SRB2Kart-specific hashes
-#define ASSET_HASH_GFX_KART      "06f86ee16136eb8a7043b15001797034"
-#define ASSET_HASH_TEXTURES_KART "abb53d56aba47c3a8cb0f764da1c8b80"
-#define ASSET_HASH_CHARS_KART    "e2c428347dde52858a3dacd29fc5b964"
-#define ASSET_HASH_MAPS_KART     "d051e55141ba736582228c456953cd98"
-#ifdef USE_PATCH_KART
-#define ASSET_HASH_PATCH_KART    "00000000000000000000000000000000"
-#endif
+#define CMAKE_ASSETS_DIR         ""
 
 #endif
 #endif

src/console.c

@@ -169,6 +169,8 @@ static CV_PossibleValue_t menuhighlight_cons_t[] =
 };
 consvar_t cons_menuhighlight = {"menuhighlight", "Gametype Default", CV_SAVE, menuhighlight_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+consvar_t cons_consoleprintinmenu = {"consoleprintinmenu", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 static void CON_Print(char *msg);
 
 //
@@ -426,6 +428,7 @@ void CON_Init(void)
 		CV_RegisterVar(&cons_backpic);
 		CV_RegisterVar(&cons_backcolor);
 		CV_RegisterVar(&cons_menuhighlight);
+		CV_RegisterVar(&cons_consoleprintinmenu);
 		COM_AddCommand("bind", CONS_Bind_f);
 	}
 	else
@@ -586,12 +589,18 @@ static void CON_ChangeHeight(void)
 
 // Handles Console moves in/out of screen (per frame)
 //
-static void CON_MoveConsole(void)
+void CON_MoveConsole(void)
 {
 	static fixed_t fracmovement = 0;
 
 	Lock_state();
 
+	if (con_curlines == con_destlines)
+	{
+		Unlock_state();
+		return;
+	}
+
 	// instant
 	if (!cons_speed.value)
 	{
@@ -1584,13 +1593,12 @@ void CON_Drawer(void)
 	}
 
 	// console movement
-	if (con_curlines != con_destlines)
-		CON_MoveConsole();
+	CON_MoveConsole();
 
 	if (con_curlines > 0)
 		CON_DrawConsole();
 	else if (gamestate == GS_LEVEL || gamestate == GS_INTERMISSION || gamestate == GS_CUTSCENE || gamestate == GS_CREDITS
-		|| gamestate == GS_VOTING || gamestate == GS_EVALUATION || gamestate == GS_WAITINGPLAYERS)
+		|| gamestate == GS_VOTING || gamestate == GS_EVALUATION || gamestate == GS_WAITINGPLAYERS || (cons_consoleprintinmenu.value && gamestate == GS_TITLESCREEN))
 		CON_DrawHudlines();
 
 	Unlock_state();

src/console.h

@@ -36,6 +36,7 @@ extern INT32 con_destlines;
 extern UINT32 con_scalefactor; // console text scale factor
 
 extern consvar_t cons_backcolor, cons_menuhighlight;
+extern consvar_t cons_consoleprintinmenu;
 
 extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *orangemap,\
  *skymap, *goldmap, *lavendermap, *teamap, *steelmap, *pinkmap, *brownmap, *peachmap;
@@ -51,6 +52,7 @@ void CON_ClearHUD(void); // clear heads up messages
 
 void CON_Ticker(void);
 void CON_Drawer(void);
+void CON_MoveConsole(void);
 void CONS_Error(const char *msg); // print out error msg, and wait a key
 
 // force console to move out

src/d_clisrv.c

@@ -332,7 +332,7 @@ void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(const UINT8 **p, INT32 playernu
 #ifdef PARANOIA
 	if (id >= MAXNETXCMD)
 		I_Error("Command id %d too big", id);
-	if (listnetxcmd[id] != 0)
+	if (listnetxcmd[id] != NULL)
 		I_Error("Command id %d already used", id);
 #endif
 	listnetxcmd[id] = cmd_f;
@@ -365,7 +365,7 @@ void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_
 		CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %d... (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam));
 		if (buf == NULL)
 		{
-			textcmdbuf[playerid] = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
+			textcmdbuf[playerid] = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
 			textcmdbuf[playerid]->cmd[0] = 0;
 			textcmdbuf[playerid]->next = NULL;
 			WriteNetXCmd(textcmdbuf[playerid]->cmd, id, param, nparam);
@@ -377,7 +377,7 @@ void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_
 
 		if (buf->cmd[0]+2+nparam > MAXTEXTCMD)
 		{
-			buf->next = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
+			buf->next = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
 			buf->next->cmd[0] = 0;
 			buf->next->next = NULL;
 			WriteNetXCmd(buf->next->cmd, id, param, nparam);
@@ -454,13 +454,13 @@ static UINT8* D_GetTextcmd(tic_t tic, INT32 playernum)
 	// If we don't have an entry for the tic, make it.
 	if (!textcmdtic)
 	{
-		textcmdtic = *tctprev = Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL);
+		textcmdtic = *tctprev = (textcmdtic_t*)Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL);
 		textcmdtic->tic = tic;
 	}
 
 	// If we don't have an entry for the player, make it.
 	if (!textcmdtic->playercmds[playernum])
-		textcmdtic->playercmds[playernum] = Z_Calloc(MAXTEXTCMD, PU_STATIC, NULL);
+		textcmdtic->playercmds[playernum] = (UINT8*)Z_Calloc(MAXTEXTCMD, PU_STATIC, NULL);
 
 	return textcmdtic->playercmds[playernum];
 }
@@ -1141,7 +1141,7 @@ typedef enum
 static void GetPackets(void);
 
 static cl_mode_t cl_mode = CL_SEARCHING;
-static UINT16 cl_lastcheckedfilecount = 0;	// used for full file list
+static UINT16 cl_lastcheckedfilecount = 0; // used for full file list
 
 // Player name send/load
 
@@ -1182,7 +1182,7 @@ static void CV_LoadPlayerNames(UINT8 **p)
 //
 // Keep the local client informed of our status.
 //
-static inline void CL_DrawConnectionStatus(void)
+static void CL_DrawConnectionStatus(void)
 {
 	INT32 ccstime = I_GetTime();
 
@@ -1217,24 +1217,26 @@ static inline void CL_DrawConnectionStatus(void)
 			case CL_DOWNLOADSAVEGAME:
 				if (filedownload.current != -1)
 				{
-					UINT32 currentsize = fileneeded[filedownload.current].currentsize;
-					UINT32 totalsize = fileneeded[filedownload.current].totalsize;
-					INT32 dldlength;
+					INT32 dldlength = 0;
+					fileneeded_t *file = &fileneeded[filedownload.current];
+					UINT32 currentsize = file->currentsize;
+					UINT32 totalsize   = file->totalsize;
 
 					cltext = M_GetText("Downloading game state...");
 					Net_GetNetStat();
 
-					dldlength = (INT32)((currentsize/(double)totalsize) * 256);
+					if (totalsize != 0)
+						dldlength = (INT32)((currentsize/(double)totalsize) * 256);
 					if (dldlength > 256)
 						dldlength = 256;
 					V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111);
 					V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 96);
 
 					V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
-						va(" %4uK/%4uK",currentsize>>10,totalsize>>10));
+						va(" %4uK/%4uK", currentsize>>10, totalsize>>10));
 
 					V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
-						va("%3.1fK/s ", ((double)getbps)/1024));
+						va("%3.1fK/s ", ((double)getbps)/1024.0));
 				}
 				else
 					cltext = M_GetText("Waiting to download game state...");
@@ -1270,29 +1272,30 @@ static inline void CL_DrawConnectionStatus(void)
 	{
 		if (cl_mode == CL_CHECKFILES)
 		{
-			INT32 totalfileslength;
+			INT32 totalfileslength = 0;
 			INT32 checkednum = 0;
 			INT32 i;
 
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-24, V_YELLOWMAP|MENUCAPS, "Press ESC to abort");
 
-			//ima just count files here
+			// ima just count files here
 			for (i = 0; i < fileneedednum; i++)
 				if (fileneeded[i].status != FS_NOTCHECKED)
 					checkednum++;
 
 			// Loading progress
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Checking server addons...");
-			totalfileslength = (INT32)((checkednum/(double)(fileneedednum)) * 256);
+			if (fileneedednum != 0)
+				totalfileslength = (INT32)((checkednum/(double)fileneedednum) * 256);
 			M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
-				va(" %2u/%2u Files",checkednum,fileneedednum));
+				va(" %2u/%2u Files", checkednum, fileneedednum));
 		}
 		else if (cl_mode == CL_LOADFILES)
 		{
-			INT32 totalfileslength;
+			INT32 totalfileslength = 0;
 			INT32 loadcompletednum = 0;
 			INT32 i;
 
@@ -1305,12 +1308,13 @@ static inline void CL_DrawConnectionStatus(void)
 
 			// Loading progress
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Loading server addons...");
-			totalfileslength = (INT32)((loadcompletednum/(double)(fileneedednum)) * 256);
+			if (fileneedednum != 0)
+				totalfileslength = (INT32)((loadcompletednum/(double)fileneedednum) * 256);
 			M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
-				va(" %2u/%2u Files",loadcompletednum,fileneedednum));
+				va(" %2u/%2u Files", loadcompletednum, fileneedednum));
 		}
 		else if (cl_mode == CL_VIEWSERVER)
 		{
@@ -1438,19 +1442,22 @@ static inline void CL_DrawConnectionStatus(void)
 		}
 		else if (filedownload.current != -1)
 		{
-			INT32 dldlength;
-			INT32 totalfileslength;
-			UINT32 totaldldsize;
+			INT32 dldlength = 0;
+			INT32 totalfileslength = 0;
+			UINT32 totaldldsize = 0;
 			static char tempname[28];
 			fileneeded_t *file = &fileneeded[filedownload.current];
 			char *filename = file->filename;
+			UINT32 currentsize = file->currentsize;
+			UINT32 totalsize   = file->totalsize;
 
 			// Draw the bottom box.
 			M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-58-8, 32, 1);
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-14, V_YELLOWMAP|MENUCAPS, "Press ESC to abort");
 
 			Net_GetNetStat();
-			dldlength = (INT32)((file->currentsize/(double)file->totalsize) * 256);
+			if (totalsize != 0)
+				dldlength = (INT32)((currentsize/(double)totalsize) * 256);
 			if (dldlength > 256)
 				dldlength = 256;
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, 256, 8, 175);
@@ -1483,29 +1490,30 @@ static inline void CL_DrawConnectionStatus(void)
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-22, V_YELLOWMAP|MENUCAPS,
 				va(M_GetText("\"%s\""), tempname));
 			V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS,
-				va(" %4uK/%4uK",file->currentsize>>10,file->totalsize>>10));
+				va(" %4uK/%4uK", currentsize>>10, totalsize>>10));
 			V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS,
-				va("%3.1fK/s ", ((double)getbps)/1024));
+				va("%3.1fK/s ", ((double)getbps)/1024.0));
 
 			// Download progress
 
-			if (file->currentsize != file->totalsize)
-				totaldldsize = filedownload.completedsize+file->currentsize; //Add in single file progress download if applicable
+			if (currentsize != totalsize)
+				totaldldsize = filedownload.completedsize+currentsize; // Add in single file progress download if applicable
 			else
 				totaldldsize = filedownload.completedsize;
 
 			V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-14, V_YELLOWMAP|MENUCAPS, "Overall Download Progress");
-			totalfileslength = (INT32)((totaldldsize/(double)filedownload.totalsize) * 256);
+			if (filedownload.totalsize != 0)
+				totalfileslength = (INT32)((totaldldsize/(double)filedownload.totalsize) * 256);
 			M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
 			V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
 
-			if (filedownload.totalsize>>20 >= 10) //display in MB if over 10MB
+			if (filedownload.totalsize>>20 >= 10) // display in MB if over 10MB
 				V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
-					va(" %4uM/%4uM",totaldldsize>>20,filedownload.totalsize>>20));
+					va(" %4uM/%4uM", totaldldsize>>20, filedownload.totalsize>>20));
 			else
 				V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
-					va(" %4uK/%4uK",totaldldsize>>10,filedownload.totalsize>>10));
+					va(" %4uK/%4uK", totaldldsize>>10, filedownload.totalsize>>10));
 
 			V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
 					va("%2u/%2u Files ", filedownload.completednum, filedownload.totalnum));
@@ -1777,6 +1785,9 @@ static void SV_SendPlayerInfo(INT32 node)
 
 static void SV_SendMapIcon(INT32 node)
 {
+	if (node == 0)
+		return;
+
 	doomdata_t *netbuffer = DOOMCOM_DATA(doomcom);
 
 	const char *map = va("%sP", G_BuildMapName(gamemap));
@@ -1952,7 +1963,7 @@ static boolean SV_ResendingSavegameToAnyone(void)
 static void SV_SendSaveGame(INT32 node, boolean resending)
 {
 	size_t length, compressedlen;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	UINT8 *compressedsave;
 	UINT8 *buffertosend;
 
@@ -2022,7 +2033,7 @@ static consvar_t cv_dumpconsistency = {"dumpconsistency", "Off", CV_NETVAR, CV_O
 static void SV_SavedGame(void)
 {
 	size_t length;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	char tmpsave[264];
 
 	if (!cv_dumpconsistency.value)
@@ -2062,7 +2073,7 @@ static void SV_SavedGame(void)
 
 static void CL_LoadReceivedSavegame(boolean reloading)
 {
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	size_t length, decompressedlen;
 	char tmpsave[264];
 
@@ -2071,6 +2082,7 @@ static void CL_LoadReceivedSavegame(boolean reloading)
 	length = FIL_ReadFile(tmpsave, &save.buffer);
 
 	CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(length));
+
 	if (!length)
 	{
 		I_Error("Can't read savegame sent");
@@ -2154,7 +2166,7 @@ static void CL_ReloadReceivedSavegame(void)
 	// we dont have P_ForceLocalAngle so were setting it manually here
 	for (i = 0; i <= splitscreen; i++)
 	{
-		P_ForceLocalAngle(&players[displayplayers[i]], (angle_t)(players[displayplayers[i]].cmd.angleturn << 16));
+		P_ForceLocalAngle(&players[displayplayers[i]], (angle_t)(players[displayplayers[i]].cmd.angleturn << TICCMD_REDUCE));
 	}
 
 	for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
@@ -2193,12 +2205,8 @@ static void SendAskInfo(INT32 node)
 	HSendPacket(node, false, 0, sizeof (askinfo_pak));
 }
 
-serverelem_t serverlist[MAXSERVERLIST];
+serverelem_t serverlist[MAXSERVERLIST] = {};
 UINT32 serverlistcount = 0;
-UINT32 serverlistultimatecount = 0;
-
-static boolean resendserverlistnode[MAXNETNODES];
-static tic_t serverlistepoch;
 
 static void SL_ClearServerList(INT32 connectedserver)
 {
@@ -2211,8 +2219,7 @@ static void SL_ClearServerList(INT32 connectedserver)
 			serverlist[i].node = 0;
 		}
 	serverlistcount = 0;
-
-	memset(resendserverlistnode, 0, sizeof resendserverlistnode);
+	//memset(serverlist, 0, sizeof(serverlist));
 }
 
 static UINT32 SL_SearchServer(INT32 node)
@@ -2229,8 +2236,6 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
 {
 	UINT32 i;
 
-	resendserverlistnode[node] = false;
-
 	// search if not already on it
 	i = SL_SearchServer(node);
 	if (i == UINT32_MAX)
@@ -2264,7 +2269,7 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
 	M_SortServerList();
 }
 
-void CL_UpdateServerList (void)
+void CL_UpdateServerList(void)
 {
 	SL_ClearServerList(0);
 
@@ -2282,14 +2287,12 @@ void CL_UpdateServerList (void)
 		SendAskInfo(BROADCASTADDR);
 }
 
-void CL_QueryServerList (msg_server_t *server_list)
+void CL_QueryServerList(msg_server_t *server_list)
 {
 	INT32 i;
 
 	CL_UpdateServerList();
 
-	serverlistepoch = I_GetTime();
-
 	for (i = 0; server_list[i].header.buffer[0]; i++)
 	{
 		// Make sure MS version matches our own, to
@@ -2302,42 +2305,20 @@ void CL_QueryServerList (msg_server_t *server_list)
 			if (node == -1)
 				continue; // no more node free, or resolution failure
 			SendAskInfo(node);
-			resendserverlistnode[node] = true;
-			// Leave this node open. It'll be closed if the
-			// request times out (CL_TimeoutServerList).
-		}
-	}
 
-	serverlistultimatecount = i;
-}
-
-#define SERVERLISTRESENDRATE NEWTICRATE
-
-void CL_TimeoutServerList(void)
-{
-	if (netgame && serverlistultimatecount > serverlistcount)
-	{
-		const tic_t timediff = I_GetTime() - serverlistepoch;
-		const tic_t timetoresend = timediff % SERVERLISTRESENDRATE;
-		const boolean timedout = timediff > connectiontimeout;
-
-		if (timedout || (timediff > 0 && timetoresend == 0))
-		{
-			INT32 node;
-
-			for (node = 1; node < MAXNETNODES; ++node)
-			{
-				if (resendserverlistnode[node])
-				{
-					if (timedout)
-						Net_CloseConnection(node|FORCECLOSE);
-					else
-						SendAskInfo(node);
-				}
-			}
-
-			if (timedout)
-				serverlistultimatecount = serverlistcount;
+			// Force close the connection so that servers can't eat
+			// up nodes forever if we never get a reply back from them
+			// (usually when they've not forwarded their ports).
+			//
+			// Don't worry, we'll get in contact with the working
+			// servers again when they send SERVERINFO to us later!
+			//
+			// (Note: as a side effect this probably means every
+			// server in the list will probably be using the same node (e.g. node 1),
+			// not that it matters which nodes they use when
+			// the connections are closed afterwards anyway)
+			// -- Monster Iestyn 12/11/18
+			Net_CloseConnection(node|FORCECLOSE);
 		}
 	}
 }
@@ -3504,6 +3485,9 @@ void CL_Reset(void)
 
 	memset(player_muted, 0, sizeof(player_muted));
 
+	for (INT32 i = 0; i < MAXPLAYERS; ++i)
+		playerinfo[i].node = 255;
+
 	// D_StartTitle should get done now, but the calling function will handle it
 }
 
@@ -4292,6 +4276,9 @@ void D_ClientServerInit(void)
 #endif
 	D_LoadBan(false);
 
+	for (INT32 i = 0; i < MAXPLAYERS; ++i)
+		playerinfo[i].node = 255;
+
 	gametic = 0;
 	localgametic = 0;
 
@@ -4527,7 +4514,7 @@ static void Got_AddPlayer(const UINT8 **p, INT32 playernum)
 			DEBFILE("spawning me\n");
 		}
 
-		P_ForceLocalAngle(&players[newplayernum], (angle_t)(players[newplayernum].cmd.angleturn << 16));
+		P_ForceLocalAngle(&players[newplayernum], (angle_t)(players[newplayernum].cmd.angleturn << TICCMD_REDUCE));
 
 		D_SendPlayerConfig();
 		addedtogame = true;
@@ -6474,6 +6461,7 @@ static void SV_SendTics(void)
 				continue;
 			DEBFILE(va("Sent %d anyway\n", realfirsttic));
 		}
+
 		realfirsttic = max(realfirsttic, firstticstosend);
 
 		// compute the length of the packet and cut it if too large
@@ -6619,7 +6607,8 @@ void SV_SpawnPlayer(INT32 playernum, INT32 x, INT32 y, angle_t angle)
 			// -- Monster Iestyn 16/01/18
 			break;
 		}
-		netcmds[tic%BACKUPTICS][playernum].angleturn = (INT16)((angle>>16) | TICCMD_RECEIVED);
+
+		netcmds[tic%BACKUPTICS][playernum].angleturn = (INT16)((angle >> TICCMD_REDUCE) | TICCMD_RECEIVED);
 
 		if (!tic) // failsafe for gametic == 0 -- Monster Iestyn 16/01/18
 			break;
@@ -7248,7 +7237,7 @@ void CL_ClearRewinds(void)
 
 rewind_t *CL_SaveRewindPoint(size_t demopos)
 {
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	rewind_t *rewind;
 
 	if (rewindhead && rewindhead->leveltime + REWIND_POINT_INTERVAL > leveltime)
@@ -7271,7 +7260,7 @@ rewind_t *CL_SaveRewindPoint(size_t demopos)
 
 rewind_t *CL_RewindToTime(tic_t time)
 {
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	rewind_t *rewind;
 
 	while (rewindhead && rewindhead->leveltime > time)

src/d_clisrv.h

@@ -516,7 +516,6 @@ typedef struct
 
 extern serverelem_t serverlist[MAXSERVERLIST];
 extern UINT32 serverlistcount;
-extern UINT32 serverlistultimatecount;
 extern INT32 mapchangepending;
 
 // Points inside doomcom
@@ -627,7 +626,6 @@ void CL_ClearPlayer(INT32 playernum);
 void CL_RemovePlayer(INT32 playernum, INT32 reason);
 void CL_QueryServerList(msg_server_t *list);
 void CL_UpdateServerList(void);
-void CL_TimeoutServerList(void);
 
 void CL_AbortConnection(void);
 

src/d_main.c

@@ -80,6 +80,31 @@
 
 #include "lua_script.h"
 
+/* Manually defined asset hashes for non-CMake builds
+ * Last updated 2015 / 05 / 03 - SRB2 v2.1.15 - srb2.srb
+ * Last updated 2018 / 12 / 23 - SRB2 v2.1.22 - patch.dta
+ * Last updated 2019 / 01 / 18 - Kart v1.0.2 - Main assets
+ * Last updated 2020 / 08 / 30 - Kart v1.3 - patch.kart
+ * Last updated 2022 / 08 / 16 - Kart v1.4 - Main assets
+ * Last updated 2022 / 08 / 19 - Kart v1.5 - gfx.kart
+ * Last updated 2022 / 11 / 01 - Kart v1.6 - gfx.kart, maps.kart
+ */
+
+// Base SRB2 hashes
+#define ASSET_HASH_SRB2_SRB      "c1b9577687f8a795104aef4600720ea7"
+#ifdef USE_PATCH_DTA
+#define ASSET_HASH_PATCH_DTA     "b04fd9624bfd94dc96dcf4f400f7deb4"
+#endif
+
+// SRB2Kart-specific hashes
+#define ASSET_HASH_GFX_KART      "06f86ee16136eb8a7043b15001797034"
+#define ASSET_HASH_TEXTURES_KART "abb53d56aba47c3a8cb0f764da1c8b80"
+#define ASSET_HASH_CHARS_KART    "e2c428347dde52858a3dacd29fc5b964"
+#define ASSET_HASH_MAPS_KART     "d051e55141ba736582228c456953cd98"
+#ifdef USE_PATCH_KART
+#define ASSET_HASH_PATCH_KART    "00000000000000000000000000000000"
+#endif
+
 #ifdef CMAKECONFIG
 #include "config.h"
 #else
@@ -249,21 +274,17 @@ static void D_Renderview(void)
 
 	R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL));
 
-	if (rendermode == render_soft)
+	if (rendermode == render_soft && cv_homremoval.value)
 	{
-		// if this is display player 1
-		if (cv_homremoval.value)
+		if (cv_homremoval.value == 1)
 		{
-			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);
-			}
+			// 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);
 		}
 	}
 
@@ -297,7 +318,6 @@ static void D_Renderview(void)
 					break;
 				default: // Initialize for P1
 					viewwindowy = viewwindowx = 0;
-					objectsdrawn = 0;
 					break;
 			}
 
@@ -308,19 +328,17 @@ 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
+			}
 		}
 	}
 
@@ -639,7 +657,7 @@ void D_SRB2Loop(void)
 	tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
 	double deltatics = 0.0;
 	double deltasecs = 0.0;
-	UINT64 precision;
+	UINT64 precision = 0;
 
 	boolean interp = false;
 	boolean doDisplay = false;
@@ -758,11 +776,6 @@ void D_SRB2Loop(void)
 
 				doDisplay = true;
 			}
-
-			if (!dedicated)
-			{
-				G_DeviceLEDTick();
-			}
 		}
 
 		if (interp)
@@ -792,9 +805,9 @@ void D_SRB2Loop(void)
 			}
 			else if (!dedicated)
 			{
-				// always update console and hud
-				// otherwise it may take minutes to open it
-				CON_Drawer();
+				// always update console movement
+				// otherwise it will takes literal ages to open
+				CON_MoveConsole();
 			}
 		}
 
@@ -804,6 +817,13 @@ 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
 
@@ -882,10 +902,11 @@ void D_ClearState(void)
 
 	// okay, stop now
 	// (otherwise the game still thinks we're playing!)
+#ifdef HAVE_CURL
 	CURLAbortFile();
+#endif
 	SV_StopServer();
 	SV_ResetServer();
-	serverlistultimatecount = 0;
 
 	for (i = 0; i < MAXPLAYERS; i++)
 		CL_ClearPlayer(i);
@@ -947,6 +968,9 @@ void D_ClearState(void)
 //
 void D_StartTitle(void)
 {
+	if (dedicated)
+		I_Error("D_StartTitle is called on dedicated server");
+
 	D_ClearState();
 	multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao
 	F_StartTitleScreen();
@@ -1187,17 +1211,13 @@ static void IdentifyVersion(void)
 #endif
 
 	char tempsrb2path[256] = ".";
-	getcwd(tempsrb2path, 256);
+	if (getcwd(tempsrb2path, 256) == NULL)
+		strcpy(tempsrb2path, ".");
 
 	// get the current directory (possible problem on NT with "." as current dir)
 	if (!srb2waddir)
 	{
-		if (tempsrb2path[0])
-			srb2waddir = tempsrb2path;
-		else
-		{
-			srb2waddir = ".";
-		}
+		srb2waddir = tempsrb2path;
 	}
 
 #if (1) // reduce the amount of findfile by only using full cwd in this func
@@ -1264,7 +1284,7 @@ static void IdentifyVersion(void)
 	if (AddIWAD("extra3.kart", srb2waddir))
 		found_extra3_kart = true;
 
-#if defined (HAVE_SDL)
+#if !defined (HAVE_SDL) || defined (HAVE_MIXER)
 #define MUSICTEST(str) \
 	musicpath = va(pandf, srb2waddir, str);\
 	handle = W_OpenWadFile(&musicpath, false); \
@@ -1618,12 +1638,6 @@ 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"));
 
@@ -1870,7 +1884,8 @@ void D_SRB2Main(void)
 	if (M_CheckParm("-warp") && M_IsNextParm())
 	{
 		const char *word = M_GetNextParm();
-		pstartmap = G_FindMapByNameOrCode(word, 0);
+		pstartmap = G_FindMapByNameOrCode(word, NULL);
+
 		if (! pstartmap)
 			I_Error("Cannot find a map remotely named '%s'\n", word);
 		else

src/d_net.c

@@ -59,7 +59,7 @@ static INT16 reboundsize[MAXREBOUND];
 static INT32 rebound_head, rebound_tail;
 
 /// \brief max length per packet
-INT16 hardware_MAXPACKETLENGTH;
+INT16 hardware_MAXPACKETLENGTH = 0;
 
 boolean (*I_NetGet)(void) = NULL;
 void (*I_NetSend)(void) = NULL;
@@ -96,7 +96,7 @@ INT32 ticruned = 0, ticmiss = 0;
 
 // globals
 INT32 getbps = 0, sendbps = 0;
-float lostpercent = 0, duppercent = 0, gamelostpercent = 0;
+float lostpercent = 0.0f, duppercent = 0.0f, gamelostpercent = 0.0f;
 INT32 packetheaderlength = 0;
 
 boolean Net_GetNetStat(void)
@@ -492,6 +492,7 @@ void Net_AckTicker(void)
 				ackpak[i].acknum = 0;
 				continue;
 			}
+
 			DEBFILE(va("Resend ack %d, %u<%d at %u\n", ackpak[i].acknum, ackpak[i].senttime,
 				NODETIMEOUT, I_GetTime()));
 			memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
@@ -1224,7 +1225,7 @@ void D_SetDoomcom(void)
 	if (doomcom)
 		return;
 
-	doomcom = Z_Calloc(sizeof (doomcom_t), PU_STATIC, NULL);
+	doomcom = Z_Calloc(sizeof(doomcom_t), PU_STATIC, NULL);
 	doomcom->id = DOOMCOM_ID;
 	doomcom->numslots = doomcom->numnodes = 1;
 }
@@ -1266,6 +1267,7 @@ boolean D_CheckNetGame(void)
 		ret = true;
 	if (client && netgame)
 		netgame = false;
+
 	server = true; // WTF? server always true???
 		// no! The deault mode is server. Client is set elsewhere
 		// when the client executes connect command.
@@ -1301,6 +1303,7 @@ boolean D_CheckNetGame(void)
 
 	if (doomcom->id != DOOMCOM_ID)
 		I_Error("Doomcom buffer invalid!");
+
 	if (doomcom->numnodes > MAXNETNODES)
 		I_Error("Too many nodes (%d), max:%d", doomcom->numnodes, MAXNETNODES);
 
@@ -1309,14 +1312,17 @@ boolean D_CheckNetGame(void)
 	{
 		char filename[21];
 		INT32 k = doomcom->consoleplayer - 1;
+
 		if (M_IsNextParm())
 			k = atoi(M_GetNextParm()) - 1;
+
 		while (!debugfile && k < MAXPLAYERS)
 		{
 			k++;
 			sprintf(filename, "debug%d.txt", k);
 			debugfile = fopen(va("%s" PATHSEP "%s", srb2home, filename), "w");
 		}
+
 		if (debugfile)
 			CONS_Printf(M_GetText("debug output to: %s\n"), va("%s" PATHSEP "%s", srb2home, filename));
 		else

src/d_netcmd.c

@@ -54,6 +54,9 @@
 #include "fastcmp.h"
 #include "m_perfstats.h"
 
+#include "r_data.h"
+#include "r_skins.h"
+
 #ifdef NETGAME_DEVMODE
 #define CV_RESTRICT CV_NETVAR
 #else
@@ -144,6 +147,7 @@ static void Command_Addfile(void);
 static void Command_Addskins(void);
 static void Command_GLocalSkin(void);
 static void Command_ListWADS_f(void);
+static void Command_LocateLump_f(void);
 static void Command_ListDoomednums_f(void);
 static void Command_ListUnusedSprites_f(void);
 static void Command_RunSOC(void);
@@ -248,7 +252,7 @@ consvar_t cv_competitionboxes = {"competitionboxes", "Random", CV_NETVAR|CV_CHEA
 
 #ifdef SEENAMES
 static CV_PossibleValue_t seenames_cons_t[] = {{0, "Off"}, {1, "Colorless"}, {2, "Team"}, {3, "Ally/Foe"}, {0, NULL}};
-consvar_t cv_seenames = {"seenames", "Off", CV_SAVE, seenames_cons_t, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_seenames = {"seenames", "Off", CV_SAVE, seenames_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_allowseenames = {"allowseenames", "No", CV_NETVAR, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
 #endif
 
@@ -270,7 +274,7 @@ consvar_t cv_skin4 = {"skin4", DEFAULTSKIN4, CV_SAVE|CV_CALL|CV_NOINIT, NULL, Sk
 // haha I've beaten you now, ONLINE
 consvar_t cv_localskin = {"internal___localskin", "none", CV_HIDEN, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_showlocalskinmenus = {"showlocalskinmenus", "Yes", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_showlocalskinmenus = {"showlocalskinmenus", "Yes", CV_SAVE|CV_CALL, CV_YesNo, ShowLocalskinMenu_Onchange, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_skipmapcheck = {"skipmapcheck", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -457,16 +461,16 @@ consvar_t cv_showping = {"showping", "Always", CV_SAVE, showping_cons_t, NULL, 0
 
 static CV_PossibleValue_t pingmeasurement_cons_t[] = {{0, "Frames"}, {1, "Milliseconds"}, {0, NULL}};
 consvar_t cv_pingmeasurement = {"pingmeasurement", "Frames", CV_SAVE, pingmeasurement_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_pingicon = {"pingicon", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_pingicon = {"pingicon", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 static CV_PossibleValue_t cv_pingstyle_cons_t[] = {{0, "New"}, {1, "Old"}, {0, NULL}};
-consvar_t cv_pingstyle = {"pingstyle", "New", CV_SAVE, cv_pingstyle_cons_t, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_pingstyle = {"pingstyle", "New", CV_SAVE, cv_pingstyle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_luaimmersion = {"luaimmersion", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_luaimmersion = {"luaimmersion", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_showviewpointtext = {"showviewpointtext", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_showviewpointtext = {"showviewpointtext", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-consvar_t cv_showdownloadprompt = {"showdownloadprompt", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_showdownloadprompt = {"showdownloadprompt", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 // Intermission time Tails 04-19-2002
 static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}};
@@ -638,6 +642,7 @@ void D_RegisterServerCommands(void)
 	COM_AddCommand("addfile", Command_Addfile);
 	COM_AddCommand("addskins", Command_Addskins);
 	COM_AddCommand("listwad", Command_ListWADS_f);
+	COM_AddCommand("locatelump", Command_LocateLump_f);
 	COM_AddCommand("listmapthings", Command_ListDoomednums_f);
 	COM_AddCommand("listunusedsprites", Command_ListUnusedSprites_f);
 
@@ -937,6 +942,7 @@ void D_RegisterClientCommands(void)
 	CV_RegisterVar(&cv_chatbacktint);
 	CV_RegisterVar(&cv_chatcentertext);
 	CV_RegisterVar(&cv_songcredits);
+	CV_RegisterVar(&cv_pausesongcredits);
 	CV_RegisterVar(&cv_showfreeplay);
 	CV_RegisterVar(&cv_skinselectspin);
 	CV_RegisterVar(&cv_showallmaps);
@@ -994,6 +1000,8 @@ void D_RegisterClientCommands(void)
 
 		CV_RegisterVar(&cv_litesteer[i]);
 
+		CV_RegisterVar(&cv_autoaccel[i]);
+
 		CV_RegisterVar(&cv_usejoystick[i]);
 		CV_RegisterVar(&cv_joyscale[i]);
 		CV_RegisterVar(&cv_rumble[i]);
@@ -1001,9 +1009,12 @@ void D_RegisterClientCommands(void)
 		CV_RegisterVar(&cv_gamepadled[i]);
 	}
 
+	CV_RegisterVar(&cv_gamepadledifunfocused);
+	CV_RegisterVar(&cv_rumbleifunfocused);
+
 	CV_RegisterVar(&cv_usemouse);
 	CV_RegisterVar(&cv_invertmouse);
-	CV_RegisterVar(&cv_mousesens);
+	CV_RegisterVar(&cv_mousexsens);
 	CV_RegisterVar(&cv_mouseysens);
 	CV_RegisterVar(&cv_mousevisible);
 
@@ -2647,8 +2658,6 @@ static void Command_Map_f(void)
 		return;
 	}
 
-	M_ClearMenus(true);
-
 	last_map_cmd = I_GetTime();
 
 	size_t first_option;
@@ -2785,7 +2794,7 @@ static void Command_Map_f(void)
 	// G_TOLFlag handles both multiplayer gametype and ignores it for !multiplayer
 	else
 	{
-		if (!mapheaderinfo[newmapnum-1])
+		if (mapheaderinfo[newmapnum-1] == NULL)
 		{
 			CONS_Alert(CONS_WARNING, M_GetText("Invalid mapheaderinfo for Course %s (%s)\n"), realmapname, G_BuildMapName(newmapnum));
 			return;
@@ -2830,6 +2839,8 @@ static void Command_Map_f(void)
 
 	fromlevelselect = false;
 
+	M_ClearMenus(true);
+
 	D_MapChange(newmapnum, newgametype, newencoremode, newresetplayers, 0, false, false);
 }
 
@@ -4720,7 +4731,30 @@ static void Command_ListWADS_f(void)
 	}
 }
 
-#define MAXDOOMEDNUM 4095
+static void Command_LocateLump_f(void)
+{
+	if (COM_Argc() == 1)
+	{
+		CONS_Printf("Usage: locatelump <lump1>[ <lump2>[ ...]]\n");
+		return;
+	}
+
+	for (size_t i = 1; i < COM_Argc(); ++i)
+	{
+		const char *name = COM_Argv(i);
+
+		lumpnum_t num = W_CheckNumForName(name);
+
+		const char *wadname = "(not found)";
+
+		if (num != LUMPERROR)
+		{
+			wadname = wadfiles[WADFILENUM(num)]->filename;
+		}
+
+		CONS_Printf("%s - %s\n", name, wadname);
+	}
+}
 
 static void Command_ListDoomednums_f(void)
 {

src/d_netfil.c

@@ -131,6 +131,8 @@ static UINT32 curl_origtotalfilesize;
 static char *curl_realname = NULL;
 fileneeded_t *curl_curfile = NULL;
 HTTP_login *curl_logins = NULL;
+
+static void CURLGetFile(void);
 #endif
 
 /** Fills a serverinfo packet with information about wad files loaded.
@@ -1163,8 +1165,12 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
 	filestatus_t homecheck; // store result of last file search
 	boolean badmd5 = false; // store whether md5 was bad from either of the first two searches (if nothing was found in the third)
 
-	// skip for startup, our mainwads wont be in there
-	if (loaded_config)
+	// see IdentifyVersion
+	// Iwads skip findfile due to passing fullpath to W_OpenWadFile
+#if 0
+	// skip for Iwads, as they wont be in there
+	if (!startupiwadcount)
+#endif
 	{
 		if (cv_addons_option.value == 3 && *cv_addons_folder.string != '\0')
 		{
@@ -1301,6 +1307,7 @@ void CURLPrepareFile(const char* url, int dfilenum)
 	if (!multi_handle)
 	{
 		cc = curl_global_init(CURL_GLOBAL_ALL);
+
 		if (cc < 0)
 		{
 			I_OutputMsg("libcurl: curl_global_init() returned %d\n", cc);
@@ -1309,6 +1316,7 @@ void CURLPrepareFile(const char* url, int dfilenum)
 		{
 			multi_handle = curl_multi_init();
 		}
+
 		if (!multi_handle)
 		{
 			I_OutputMsg("libcurl: curl_multi_init() failed\n");
@@ -1437,7 +1445,7 @@ void CURLAbortFile(void)
 #endif
 }
 
-void CURLGetFile(void)
+static void CURLGetFile(void)
 {
 #ifdef HAVE_THREADS
 	I_lock_mutex(&downloadmutex);
@@ -1479,7 +1487,8 @@ void CURLGetFile(void)
 				e = m->easy_handle;
 				easyres = m->data.result;
 
-				char *filename = Z_StrDup(curl_realname);
+				char *filename = malloc(strlen(curl_realname)+1);
+				strcpy(filename, curl_realname);
 				nameonly(filename);
 
 				if (easyres != CURLE_OK)
@@ -1517,7 +1526,7 @@ void CURLGetFile(void)
 					}
 				}
 
-				Z_Free(filename);
+				free(filename);
 				curl_curfile->file = NULL;
 				filedownload.remaining--;
 				mc = curl_multi_remove_handle(multi_handle, e);

src/d_netfil.h

@@ -119,7 +119,6 @@ size_t nameonlylength(const char *s);
 #ifdef HAVE_CURL
 void CURLPrepareFile(const char* url, int dfilenum);
 void CURLAbortFile(void);
-void CURLGetFile(void);
 HTTP_login * CURLGetLogin (const char *url, HTTP_login ***return_prev_next);
 size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream);
 #endif

src/d_ticcmd.h

@@ -46,15 +46,20 @@ typedef enum
 // Mainly movements/button commands per game tick,
 // plus a checksum for internal state consistency.
 
+// ticcmd turning bits
+#define TICCMD_REDUCE 16
+
+// ticcmd latency mask
+#define TICCMD_LATENCYMASK 0xFF
+
 // bits in angleturn
-#define TICCMD_RECEIVED 1
-#define TICCMD_XY 2
+#define TICCMD_RECEIVED (0x01) /* Actual tic recieved from client */
 
 typedef struct
 {
 	SINT8 forwardmove; // -MAXPLMOVE to MAXPLMOVE (50)
 	SINT8 sidemove; // -MAXPLMOVE to MAXPLMOVE (50)
-	INT16 angleturn; // <<16 for angle delta - saved as 1 byte into demos
+	INT16 angleturn; // << TICCMD_REDUCE for angle delta - saved as 1 byte into demos
 	INT16 aiming; // vertical aiming, see G_BuildTicCmd
 	UINT16 buttons;
 	INT16 driftturn; // SRB2Kart: Used for getting drift turn speed

src/dedicated/CMakeLists.txt

@@ -1,21 +1,75 @@
 # Declare dedicated interface sources
 
-target_sourcefile(c)
+set(SRB2_DEDICATED_SOURCES
+	i_system.c
+	i_main.c
+	i_video.c
+	i_sound.c
+	i_threads.c
+	dosstr.c
+	endtxt.c
+)
 
-target_sources(SRB2SDL2 PRIVATE)
+set(SRB2_DEDICATED_HEADERS
+	endtxt.h
+)
+
+source_group("Interface Code" FILES ${SRB2_DEDICATED_SOURCES} ${SRB2_DEDICATED_HEADERS})
+
+set(SRB2_DEDICATED_TOTAL_SOURCES
+	${SRB2_CORE_SOURCES}
+	${SRB2_CORE_HEADERS}
+	${SRB2_PNG_SOURCES}
+	${SRB2_PNG_HEADERS}
+	${SRB2_CORE_RENDER_SOURCES}
+	${SRB2_CORE_GAME_SOURCES}
+	${SRB2_LUA_SOURCES}
+	${SRB2_LUA_HEADERS}
+	${SRB2_BLUA_SOURCES}
+	${SRB2_BLUA_HEADERS}
+	${SRB2_DEDICATED_SOURCES}
+	${SRB2_DEDICATED_HEADERS}
+)
+
+source_group("Main" FILES ${SRB2_CORE_SOURCES} ${SRB2_CORE_HEADERS})
+source_group("Renderer" FILES ${SRB2_CORE_RENDER_SOURCES})
+source_group("Game" FILES ${SRB2_CORE_GAME_SOURCES})
+source_group("LUA" FILES ${SRB2_LUA_SOURCES} ${SRB2_LUA_HEADERS})
+source_group("LUA\\Interpreter" FILES ${SRB2_BLUA_SOURCES} ${SRB2_BLUA_HEADERS})
 
 if(${CMAKE_SYSTEM} MATCHES Windows)
-	target_sources(SRB2SDL2 PRIVATE
-		../win32/win_dbg.c
-		../win32/Srb2win.rc)
+	set(SRB2_DEDICATED_TOTAL_SOURCES ${SRB2_DEDICATED_TOTAL_SOURCES}
+		${CMAKE_SOURCE_DIR}/src/win32/win_dbg.c
+		${CMAKE_SOURCE_DIR}/src/win32/Srb2win.rc
+	)
 endif()
 
+add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32 ${SRB2_DEDICATED_TOTAL_SOURCES})
+
 if(${CMAKE_SYSTEM} MATCHES Windows)
-	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2kartd)
 elseif(${CMAKE_SYSTEM} MATCHES Linux)
-	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2dlegacy)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2kartd)
 else()
-	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2kartd)
+endif()
+
+if(${CMAKE_SYSTEM} MATCHES Darwin)
+	find_library(CORE_FOUNDATION_LIBRARY "CoreFoundation")
+	target_link_libraries(SRB2SDL2 PRIVATE
+		${CORE_FOUNDATION_LIBRARY}
+	)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
+
+	# Configure the app bundle icon and plist properties
+	target_sources(SRB2SDL2 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/macosx/Srb2mac.icns")
+	set_target_properties(SRB2SDL2 PROPERTIES
+		MACOSX_BUNDLE_ICON_FILE "Srb2mac"
+		MACOSX_BUNDLE_BUNDLE_NAME "Sonic Robo Blast 2"
+		MACOSX_BUNDLE_BUNDLE_VERSION ${SRB2_VERSION}
+
+		RESOURCE "${CMAKE_CURRENT_SOURCE_DIR}/macosx/Srb2mac.icns"
+	)
 endif()
 
 if(${CMAKE_SYSTEM} MATCHES Darwin)
@@ -24,25 +78,27 @@ if(${CMAKE_SYSTEM} MATCHES Darwin)
 		${CORE_LIB}
 		${PNG_LIBRARIES}
 		${ZLIB_LIBRARIES}
+		${CURL_LIBRARIES}
 	)
 	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
 else()
 	target_link_libraries(SRB2SDL2 PRIVATE
 		${PNG_LIBRARIES}
 		${ZLIB_LIBRARIES}
+		${CURL_LIBRARIES}
 	)
-
 	if(${CMAKE_SYSTEM} MATCHES Linux)
 		target_link_libraries(SRB2SDL2 PRIVATE
 			m
 			rt
+			pthread
 		)
 	endif()
 endif()
 
-#target_link_libraries(SRB2SDL2 PRIVATE SRB2Core)
-
-set_target_properties(SRB2SDL2 PROPERTIES VERSION ${SRB2_VERSION})
+if(${SRB2_HAVE_LIBBACKTRACE})
+	target_link_libraries(SRB2SDL2 PRIVATE ${LIBBACKTRACE_LIBRARIES})
+endif()
 
 if(${CMAKE_SYSTEM} MATCHES Windows)
 	target_link_libraries(SRB2SDL2 PRIVATE
@@ -60,20 +116,35 @@ target_include_directories(SRB2SDL2 PRIVATE
 
 target_compile_definitions(SRB2SDL2 PRIVATE
 	-DDEDICATED
+	-DHAVE_THREADS
 )
 
-## strip debug symbols into separate file when using gcc
-if(CMAKE_COMPILER_IS_GNUCC)
-	if(${CMAKE_BUILD_TYPE} MATCHES Debug)
-		message(STATUS "Will make separate debug symbols in *.debug")
-		add_custom_command(TARGET SRB2SDL2 POST_BUILD
-			COMMAND ${OBJCOPY} --only-keep-debug $<TARGET_FILE:SRB2SDL2> $<TARGET_FILE:SRB2SDL2>.debug
-			COMMAND ${OBJCOPY} --strip-debug $<TARGET_FILE:SRB2SDL2>
-			COMMAND ${OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE_NAME:SRB2SDL2>.debug $<TARGET_FILE:SRB2SDL2>
-		)
-	endif()
+if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE)
+	set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif()
 
+if(SRB2_CONFIG_ASAN)
+	target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address)
+	target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
+endif()
+
+if(SRB2_CONFIG_UBSAN)
+	target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
+	target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
+endif()
+
+## strip debug symbols into separate file when using gcc
+# if(CMAKE_COMPILER_IS_GNUCC)
+# 	if(${CMAKE_BUILD_TYPE} MATCHES Debug)
+# 		message(STATUS "Will make separate debug symbols in *.debug")
+# 		add_custom_command(TARGET SRB2SDL2 POST_BUILD
+# 			COMMAND ${OBJCOPY} --only-keep-debug $<TARGET_FILE:SRB2SDL2> $<TARGET_FILE:SRB2SDL2>.debug
+# 			COMMAND ${OBJCOPY} --strip-debug $<TARGET_FILE:SRB2SDL2>
+# 			COMMAND ${OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE_NAME:SRB2SDL2>.debug $<TARGET_FILE:SRB2SDL2>
+# 		)
+# 	endif()
+# endif()
+
 #### Installation ####
 if(${CMAKE_SYSTEM} MATCHES Darwin)
 	install(TARGETS SRB2SDL2

src/dedicated/i_system.c

@@ -167,6 +167,8 @@ static char returnWadPath[256];
 #include "../i_video.h"
 #include "../i_sound.h"
 #include "../i_system.h"
+#include "../i_time.h"
+#include "../i_net.h"
 #include "../screen.h" //vid.WndParent
 #include "../d_net.h"
 #include "../g_game.h"
@@ -178,10 +180,6 @@ static char returnWadPath[256];
 
 #include "../m_argv.h"
 
-#ifdef MAC_ALERT
-#include "macosx/mac_alert.h"
-#endif
-
 #include "../d_main.h"
 
 #if !defined(NOMUMBLE) && defined(HAVE_MUMBLE)
@@ -196,8 +194,6 @@ UINT8 keyboard_started = false;
 
 #ifdef HAVE_TERMIOS
 // TERMIOS console code from Quake3: thank you!
-boolean stdin_active = true;
-
 typedef struct
 {
 	size_t cursor;
@@ -699,11 +695,7 @@ void I_JoyScale4(void)
 
 
 */
-void I_ShutdownJoystick(void)
-{
-}
-
-void I_GetJoystickEvents(UINT8 index)
+void I_ShutdownJoystick(UINT8 index)
 {
 	(void)index;
 }

src/dedicated/i_video.c

@@ -115,10 +115,6 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
 	return -1;
 }
 
-void VID_RefreshModeList(void)
-{
-}
-
 void VID_PrepareModeList(void)
 {
 }

src/doomdef.h

@@ -20,7 +20,6 @@
 // but I can't stand that gibberish. D:
 #define SOUND_DUMMY   0
 #define SOUND_MIXER   1
-#define SOUND_SDL     2
 
 #ifndef SOUND
 #ifdef HAVE_SDL
@@ -28,7 +27,7 @@
 #ifdef HAVE_MIXER
     #define SOUND SOUND_MIXER
 #else
-	#define SOUND SOUND_SDL
+	#define SOUND SOUND_DUMMY
 #endif
 #else
 	#define SOUND SOUND_DUMMY
@@ -41,22 +40,45 @@
 #define ASMCALL
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "doomtype.h"
 
+#ifdef __cplusplus               /* Only when compiled as C++ */
+    #include <algorithm>        /* std::min, std::max, std::sort, … */
+#endif
+
+#ifdef __cplusplus
+// Force libc++ to expose std::min/std::max even when <cmath> is included first (Apple clang quirk)
+#ifndef _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
+#define _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
+#endif
+#ifndef _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#endif
+
+// Optional: only try <version> if it actually exists (newer Xcode)
+#if __has_include(<version>)
+#include <version>
+#endif
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <cstring>
+#include <climits>
+
+extern "C" {
+#else
+#include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <string.h>
 
-#define _USE_MATH_DEFINES // fixes M_PI errors in r_plane.c for Visual Studio
-#ifdef __cplusplus
-#include <cmath>
-#else
-#include <math.h>
+#include <limits.h>
 #endif
 
 #include <sys/types.h>
@@ -108,8 +130,8 @@ extern char  logfilename[1024];
 #else
 #define VERSION    1 // Game version
 #define SUBVERSION 6 // more precise version number
-#define VERSIONSTRING "Saturn v9.x - Testing"
-#define VERSIONSTRINGW L"Saturn v9.x - Testing "
+#define VERSIONSTRING "Saturn v9.2"
+#define VERSIONSTRINGW L"Saturn v9.2"
 
 #define SATURN_TESTING // comment out for saturn release builds!
 

src/doomstat.h

@@ -542,7 +542,7 @@ extern mapthing_t *redctfstarts[MAXPLAYERS]; // CTF
 #else
 #define DEBUGFILE
 #ifdef DEBUGFILE
-#define DEBFILE(msg) { if (debugfile) { fputs(msg, debugfile); fflush(debugfile); } }
+#define DEBFILE(msg) { if (UNLIKELY(debugfile)) { fputs(msg, debugfile); fflush(debugfile); } }
 #else
 #define DEBFILE(msg) {}
 #endif

src/f_finale.c

@@ -644,7 +644,7 @@ void F_CreditDrawer(void)
 			sc = FRACUNIT; // quick hack so I don't have to add another field to credits_pics
 		}
 
-		V_DrawFixedPatch(credits_pics[i].x<<FRACBITS, (credits_pics[i].y<<FRACBITS) - 4*(animtimer<<FRACBITS)/5, sc, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH_LOWPRIORITY), colormap);
+		V_DrawFixedPatch(credits_pics[i].x<<FRACBITS, (credits_pics[i].y<<FRACBITS) - 4*(animtimer<<FRACBITS)/5, sc, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH), colormap);
 	}
 
 	// Dim the background
@@ -1172,9 +1172,7 @@ void F_StartWaitingPlayers(void)
 	randskin = M_RandomKey(numskins);
 	boolean waithires = skins[randskin].flags && SF_HIRES;
 
-	if (waitcolormap)
-		Z_Free(waitcolormap);
-
+	Z_Free(waitcolormap);
 	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0);
 
 	if (waithires)
@@ -1318,7 +1316,7 @@ boolean F_ContinueResponder(event_t *event)
 	keypressed = true;
 	imcontinuing = true;
 	continuetime = TICRATE;
-	S_StartSound(0, sfx_itemup);
+	S_StartSound(NULL, sfx_itemup);
 	return true;
 }
 

src/fastcmp.h

@@ -10,7 +10,7 @@ FUNCINLINE static ATTRINLINE boolean fasticmp(const char *s, const char *c)
 }
 
 // case-sensitive of the above
-FUNCINLINE static ATTRINLINE boolean fastcmp(const char *s, const char *c)
+FUNCINLINE static ATTRINLINE PUREFUNC boolean fastcmp(const char *s, const char *c)
 {
 	for (; *s && *s == *c; s++, c++) ;
 	return (*s == *c); // make sure both strings ended
@@ -18,7 +18,7 @@ FUNCINLINE static ATTRINLINE boolean fastcmp(const char *s, const char *c)
 
 // length-limited of the above
 // only true if both strings are at least l characters long AND match, case-sensitively!
-FUNCINLINE static ATTRINLINE boolean fastncmp(const char *s, const char *c, UINT16 l)
+FUNCINLINE static ATTRINLINE PUREFUNC boolean fastncmp(const char *s, const char *c, UINT16 l)
 {
 	for (; *s && *s == *c && --l; s++, c++) ;
 	return !l; // make sure you reached the end

src/filesrch.c

@@ -49,7 +49,7 @@ size_t menupathindex[menudepth] = {};
 size_t menudepthleft = menudepth;
 
 char menusearchbuf[MAXSTRINGLENGTH+1];
-textinput_t menusearch;
+textinput_t menusearch = {};
 
 char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
 size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
@@ -271,10 +271,13 @@ static boolean filemenucmp(char *haystack, char *needle)
 {
 	static char localhaystack[128];
 	strlcpy(localhaystack, haystack, 128);
+
 	if (!cv_addons_search_case.value)
 		strupr(localhaystack);
+
 	if (cv_addons_search_type.value)
-		return (strstr(localhaystack, needle) != 0);
+		return (strstr(localhaystack, needle) != NULL);
+
 	return (!strncmp(localhaystack, needle, menusearch.length));
 }
 
@@ -314,8 +317,7 @@ void closefilemenu(boolean validsize)
 		coredirmenu = NULL;
 	}
 
-	if (refreshdirname)
-		Z_Free(refreshdirname);
+	Z_Free(refreshdirname);
 	refreshdirname = NULL;
 }
 
@@ -343,8 +345,7 @@ void searchfilemenu(char *tempname)
 
 	if (!menusearch.length)
 	{
-		if (dirmenu)
-			Z_Free(dirmenu);
+		Z_Free(dirmenu);
 		dirmenu = coredirmenu;
 		sizedirmenu = sizecoredirmenu;
 
@@ -386,8 +387,8 @@ void searchfilemenu(char *tempname)
 				I_Error("searchfilemenu(): could not create \"No results...\".");
 		sizedirmenu = 1;
 		dir_on[menudepthleft] = 0;
-		if (tempname)
-			Z_Free(tempname);
+		Z_Free(tempname);
+
 		return;
 	}
 
@@ -502,8 +503,8 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
 	{
 		closedir(dirhandle);
 		closefilemenu(false);
-		if (tempname)
-			Z_Free(tempname);
+		Z_Free(tempname);
+
 		return false;
 	}
 

src/g_demo.c

@@ -55,6 +55,8 @@
 #include "k_stats.h" // SRB2kart
 #include "r_fps.h" // frame interpolation/uncapped
 
+#include <errno.h>
+
 #ifdef HAVE_DISCORDRPC
 #include "discord.h"
 #endif
@@ -74,7 +76,7 @@ static tic_t demostarttime; // for comparative timing purposes
 
 //@TODO put these all in a struct for namespacing purposes?
 static char demoname[128];
-savebuffer_t demobuf = {0};
+savebuffer_t demobuf = {};
 static UINT8 *demotime_p, *demoinfo_p;
 static UINT8 *demoend;
 static UINT8 demoflags;
@@ -246,10 +248,12 @@ void G_ReadDemoExtraData(void)
 	{
 		extradata = READUINT8(demobuf.p);
 
+		player_t *player = &players[p];
+
 		if (extradata & DXD_RESPAWN)
 		{
-			if (players[p].mo)
-				P_DamageMobj(players[p].mo, NULL, NULL, DMG_INSTAKILL); // Is this how this should work..?
+			if (player->mo)
+				P_DamageMobj(player->mo, NULL, NULL, DMG_INSTAKILL); // Is this how this should work..?
 		}
 
 		if (extradata & DXD_SKIN)
@@ -264,11 +268,11 @@ void G_ReadDemoExtraData(void)
 			kartspeed = READUINT8(demobuf.p);
 			kartweight = READUINT8(demobuf.p);
 
-			if (!fasticmp(skins[players[p].skin].name, name))
+			if (!fasticmp(skins[player->skin].name, name))
 				FindClosestSkinForStats(p, kartspeed, kartweight);
 
-			players[p].kartspeed = kartspeed;
-			players[p].kartweight = kartweight;
+			player->kartspeed = kartspeed;
+			player->kartweight = kartweight;
 		}
 
 		if (extradata & DXD_COLOR)
@@ -279,9 +283,9 @@ void G_ReadDemoExtraData(void)
 			for (i = 0; i < MAXSKINCOLORS; i++)
 				if (fasticmp(KartColor_Names[i], name)) // SRB2kart
 				{
-					players[p].skincolor = i;
-					if (players[p].mo)
-						players[p].mo->color = i;
+					player->skincolor = i;
+					if (player->mo)
+						player->mo->color = i;
 					break;
 				}
 		}
@@ -300,17 +304,17 @@ void G_ReadDemoExtraData(void)
 			switch (extradata)
 			{
 				case DXD_PST_PLAYING:
-					players[p].pflags |= PF_WANTSTOJOIN; // fuck you
+					player->pflags |= PF_WANTSTOJOIN; // fuck you
 					break;
 				case DXD_PST_SPECTATING:
-					players[p].pflags &= ~PF_WANTSTOJOIN; // double-fuck you
+					player->pflags &= ~PF_WANTSTOJOIN; // double-fuck you
 
 					if (!playeringame[p])
 					{
 						CL_ClearPlayer(p);
 						playeringame[p] = true;
 						G_AddPlayer(p);
-						players[p].spectator = true;
+						player->spectator = true;
 
 						// There's likely an off-by-one error in timing recording or playback of joins. This hacks around it so I don't have to find out where that is. \o/
 						if (oldcmd[p].forwardmove)
@@ -318,11 +322,11 @@ void G_ReadDemoExtraData(void)
 					}
 					else
 					{
-						players[p].spectator = true;
-						if (players[p].mo)
-							P_DamageMobj(players[p].mo, NULL, NULL, DMG_INSTAKILL);
+						player->spectator = true;
+						if (player->mo)
+							P_DamageMobj(player->mo, NULL, NULL, DMG_INSTAKILL);
 						else
-							players[p].playerstate = PST_REBORN;
+							player->playerstate = PST_REBORN;
 					}
 					break;
 				case DXD_PST_LEFT:
@@ -330,7 +334,7 @@ void G_ReadDemoExtraData(void)
 					break;
 			}
 
-			G_ResetViews();
+			G_ResetViews(false); // dont reset our freecam pls thx!
 
 			// maybe these are necessary?
 			if (G_BattleGametype())
@@ -1132,7 +1136,29 @@ void G_GhostTicker(void)
 	for (g = ghosts, p = NULL; g; g = g->next)
 	{
 		// Skip normal demo data.
-		UINT8 ziptic = READUINT8(g->p);
+		UINT8 ziptic;
+
+		if (g->done)
+		{
+			continue;
+		}
+
+		ziptic = READUINT8(g->p);
+
+fadeghost:
+		// Demo ends after ghost data.
+		if (ziptic == DEMOMARKER)
+		{
+			g->mo->momx = g->mo->momy = g->mo->momz = 0;
+
+			g->done = true;
+			if (p)
+			{
+				p->next = g->next;
+			}
+
+			continue;
+		}
 
 #ifdef DEMO_COMPAT_100
 		if (g->version != 0x0001)
@@ -1140,8 +1166,14 @@ void G_GhostTicker(void)
 #endif
 		while (ziptic != DW_END) // Get rid of extradata stuff
 		{
-			if (ziptic == 0) // Only support player 0 info for now
+			if (ziptic < MAXPLAYERS)
 			{
+#ifdef DEVELOP
+				UINT8 playerid = ziptic;
+#endif
+				// We want to skip *any* player extradata because some demos have extradata for bogus players,
+				// but if there is tic data later for those players *then* we'll consider it invalid.
+
 				ziptic = READUINT8(g->p);
 
 				if (ziptic & DXD_SKIN)
@@ -1153,13 +1185,26 @@ void G_GhostTicker(void)
 				if (ziptic & DXD_NAME)
 					g->p += 16; // yea
 
-				if (ziptic & DXD_PLAYSTATE && READUINT8(g->p) != DXD_PST_PLAYING)
-					I_Error("Ghost is not a record attack ghost"); //@TODO lmao don't blow up like this
+				if (ziptic & DXD_PLAYSTATE)
+				{
+					UINT8 playstate = READUINT8(g->p);
+					if (playstate != DXD_PST_PLAYING)
+					{
+#ifdef DEVELOP
+						CONS_Alert(CONS_WARNING, "Ghost demo has non-playing playstate for player %d\n", playerid + 1);
+#endif
+						;
+					}
+				}
 			}
 			else if (ziptic == DW_RNG)
+			{
 				g->p += 4; // RNG seed
+			}
 			else
-				I_Error("Ghost is not a record attack ghost"); //@TODO lmao don't blow up like this
+			{
+				I_Error("Ghost is not a record attack ghost DXD (ziptic = %u)", ziptic); //@TODO lmao don't blow up like this
+			}
 
 			ziptic = READUINT8(g->p);
 		}
@@ -1182,7 +1227,7 @@ void G_GhostTicker(void)
 		if (ziptic & ZT_DRIFT)
 			g->p += 2;
 		if (ziptic & ZT_LATENCY)
-			g->p += 1;
+			g->p++;
 
 		// Grab ghost data.
 		ziptic = READUINT8(g->p);
@@ -1191,10 +1236,12 @@ void G_GhostTicker(void)
 		if (g->version != 0x0001)
 		{
 #endif
+		if (ziptic == DEMOMARKER) // Had to end early for some reason
+			goto fadeghost;
 		if (ziptic == 0xFF)
 			goto skippedghosttic; // Didn't write ghost info this frame
-		else if (ziptic != 0)
-			I_Error("Ghost is not a record attack ghost"); //@TODO lmao don't blow up like this
+		if (ziptic != 0)
+			I_Error("Ghost is not a record attack ghost ZIPTIC"); //@TODO lmao don't blow up like this
 		ziptic = READUINT8(g->p);
 #ifdef DEMO_COMPAT_100
 		}
@@ -1365,7 +1412,7 @@ void G_GhostTicker(void)
 		{
 #endif
 		if (READUINT8(g->p) != 0xFF) // Make sure there isn't other ghost data here.
-			I_Error("Ghost is not a record attack ghost"); //@TODO lmao don't blow up like this
+			I_Error("Ghost is not a record attack ghost GHOSTEND"); //@TODO lmao don't blow up like this
 #ifdef DEMO_COMPAT_100
 		}
 #endif
@@ -1385,20 +1432,6 @@ skippedghosttic:
 				break;
 		}
 
-		// Demo ends after ghost data.
-		if (*g->p == DEMOMARKER)
-		{
-			g->mo->momx = g->mo->momy = g->mo->momz = 0;
-
-			if (p)
-				p->next = g->next;
-			else
-				ghosts = g->next;
-
-			Z_Free(g);
-			continue;
-		}
-
 		p = g;
 	}
 }
@@ -1593,7 +1626,7 @@ void G_ConfirmRewind(tic_t rewindtime)
 	displayplayers[2] = olddp3;
 	displayplayers[3] = olddp4;
 	R_ExecuteSetViewSize();
-	G_ResetViews();
+	G_ResetViews(true);
 
 	for (i = splitscreen; i >= 0; i--)
 		P_ResetCamera(&players[displayplayers[i]], &camera[i]);
@@ -2370,49 +2403,69 @@ static long G_GetCreationTime(char *filepath)
 
 static char *G_GetDemoDate(menudemo_t *pdemo)
 {
-	char *datetime;
-	datetime = malloc(sizeof(pdemo->date)); // mallocma balls
-
-	// no mallocma balls... :c
-	if (!datetime)
-	{
-		return NULL;
-	}
-
+	char *endPos = NULL;
+	static char datetime[11];
 	time_t file_time = 0;
+	const char *format = NULL;
+	struct tm *tm_buf = NULL;
+	CLEANUP(pfree) char *filename = NULL;
 
 	// get le filepath
-	char *filename;
 	filename = strdup(pdemo->filepath);
 
-#if defined (_WIN32)
 	if (!filename)
 	{
-		// if we cant get a filename try just getting the file create time
+#if defined (_WIN32)
+		// if we cant get a filename try just getting the file creation time
 		file_time = G_GetCreationTime(pdemo->filepath);
 		goto skipfilenametime;
-	}
 #else
-	if (!filename)
-	{
-		free(datetime);
 		return NULL;
-	}
 #endif
+	}
 
 	// get the actual filename Zzz...
 	nameonly(filename);
 
-	// convert it to long Zzz....
-	file_time = strtol(filename, NULL, 10);
-	free(filename); // dont need this anymore a
+	// the first 10 characters of a replay name usually is a unix timestamp
+
+	// not long enough to contain a valid timestamp
+	if (strlen(filename) < 10)
+	{
+#if defined (_WIN32)
+		// try to get file creation time
+		file_time = G_GetCreationTime(pdemo->filepath);
+		goto skipfilenametime;
+#else
+		return NULL;
+#endif
+	}
+
+#ifndef AVOID_ERRNO
+	errno = 0;
+#endif
+	// get the timestamp as actual numbers lul
+	file_time = strtol(filename, &endPos, 10);
+
+	if (endPos == filename // Empty string
+#ifndef AVOID_ERRNO
+		|| errno == ERANGE // Number out-of-range
+#endif
+		|| file_time < 0) // Number is not positive
+	{
+#if defined (_WIN32)
+		// just try and get the creation time then
+		file_time = G_GetCreationTime(pdemo->filepath);
+#else
+		return NULL;
+#endif
+	}
 
 #if defined (_WIN32)
 skipfilenametime:
 #endif
 
 	// then throw it into localtime to get an actual human readable format lmao
-	struct tm *tm_buf = NULL;
 	tm_buf = localtime(&file_time);
 
 	// cant believe we ended up in 1970
@@ -2425,14 +2478,10 @@ skipfilenametime:
 		tm_buf = localtime(&file_time);
 
 		if (tm_buf == NULL || tm_buf->tm_year <= 110)
-		{
-			free(datetime);
 			return NULL;
-		}
 
 		goto gotcreationtime;
 #else
-		free(datetime);
 		return NULL;
 #endif
 	}
@@ -2441,17 +2490,27 @@ skipfilenametime:
 gotcreationtime:
 #endif
 
-	const char *format;
-
 	// US ppl are special (:
 	if (cv_demodateformat.value == 2)
 		format = "%m.%d.%Y";
 	else if (cv_demodateformat.value == 1)
 		format = "%d.%m.%Y";
 	else
-		format = strstr(setlocale(LC_TIME, NULL), "en_US") ? "%m.%d.%Y" : "%d.%m.%Y";
+	{
+		const char *locale = setlocale(LC_TIME, NULL);
 
-	strftime(datetime, sizeof(pdemo->date), format, tm_buf);
+		if (locale == NULL)
+			format = "%d.%m.%Y"; // fallback to non US format
+		else if (strstr(locale, "en_US"))
+			format = "%m.%d.%Y";
+		else
+			format = "%d.%m.%Y";
+	}
+
+	if (strftime(datetime, sizeof(datetime), format, tm_buf) == 0)
+	{
+		return NULL;
+	}
 
 	return datetime;
 }
@@ -2460,6 +2519,7 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 {
 	UINT8 infobuffer[96], *info_p;
 	UINT16 pdemoversion;
+	char *demodate = NULL;
 	size_t count;
 
 	FILE *handle = fopen(pdemo->filepath, "rb");
@@ -2498,13 +2558,13 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 			memcpy(pdemo->title, info_p, 64);
 
 			// demo date
-			char *demodate;
 			demodate = G_GetDemoDate(pdemo);
 
 			if (demodate)
-				strncpy(pdemo->date, demodate, sizeof(pdemo->date));
+			{
+				strlcpy(pdemo->date, demodate, sizeof(pdemo->date));
+			}
 
-			free(demodate);
 			break;
 #ifdef DEMO_COMPAT_100
 		case 0x0001:
@@ -2545,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();
 
@@ -2581,7 +2641,7 @@ void G_DoPlayDemo(char *defdemoname)
 				snprintf(msg, 1024, M_GetText("Failed to read file '%s'.\n"), defdemoname);
 				CONS_Alert(CONS_ERROR, "%s", msg);
 				gameaction = ga_nothing;
-				M_StartMessage(msg, NULL, MM_NOTHING);
+				M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 				return;
 			}
 
@@ -2593,7 +2653,7 @@ void G_DoPlayDemo(char *defdemoname)
 			snprintf(msg, 1024, M_GetText("Failed to read lump '%s'.\n"), defdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
 			gameaction = ga_nothing;
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			return;
 		}
 		else // it's an internal demo
@@ -2613,7 +2673,7 @@ void G_DoPlayDemo(char *defdemoname)
 	{
 		snprintf(msg, 1024, M_GetText("%s is not a SRB2Kart replay file.\n"), pdemoname);
 		CONS_Alert(CONS_ERROR, "%s", msg);
-		M_StartMessage(msg, NULL, MM_NOTHING);
+		M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 		G_ResetDemoPlayback();
 		return;
 	}
@@ -2639,7 +2699,7 @@ void G_DoPlayDemo(char *defdemoname)
 		default:
 			snprintf(msg, 1024, M_GetText("%s is an incompatible replay format and cannot be played.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 	}
@@ -2650,7 +2710,7 @@ void G_DoPlayDemo(char *defdemoname)
 	{
 		snprintf(msg, 1024, M_GetText("%s is the wrong type of recording and cannot be played.\n"), pdemoname);
 		CONS_Alert(CONS_ERROR, "%s", msg);
-		M_StartMessage(msg, NULL, MM_NOTHING);
+		M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 		G_ResetDemoPlayback();
 		return;
 	}
@@ -2667,7 +2727,7 @@ void G_DoPlayDemo(char *defdemoname)
 		{
 			snprintf(msg, 1024, M_GetText("%s is an alpha multiplayer replay and cannot be played.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 		}
@@ -2725,7 +2785,7 @@ void G_DoPlayDemo(char *defdemoname)
 			CONS_Alert(CONS_ERROR, "%s", msg);
 
 			if (!CON_Ready()) // In the console they'll just see the notice there! No point pulling them out.
-				M_StartMessage(msg, NULL, MM_NOTHING);
+				M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 
 			G_ResetDemoPlayback();
 			return;
@@ -2763,6 +2823,16 @@ void G_DoPlayDemo(char *defdemoname)
 #endif
 	demobuf.p += 4; // Extrainfo location
 
+	// ...*map* not loaded?
+	if (!gamemap || (gamemap > NUMMAPS) || (W_CheckNumForName(G_BuildMapName(gamemap)) == LUMPERROR))
+	{
+		snprintf(msg, 1024, M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
+		CONS_Alert(CONS_ERROR, "%s", msg);
+		M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
+		G_ResetDemoPlayback();
+		return;
+	}
+
 #ifdef DEMO_COMPAT_100
 	if (demo.version == 0x0001)
 	{
@@ -2790,7 +2860,7 @@ void G_DoPlayDemo(char *defdemoname)
 		{
 			snprintf(msg, 1024, M_GetText("%s features a character that is not currently loaded.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 		}
@@ -2800,7 +2870,7 @@ void G_DoPlayDemo(char *defdemoname)
 		{
 			snprintf(msg, 1024, M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 		}
@@ -2823,7 +2893,7 @@ void G_DoPlayDemo(char *defdemoname)
 		{
 			snprintf(msg, 1024, M_GetText("%s contains no data to be played.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 		}
@@ -2861,7 +2931,7 @@ void G_DoPlayDemo(char *defdemoname)
 	{
 		snprintf(msg, 1024, M_GetText("%s contains no data to be played.\n"), pdemoname);
 		CONS_Alert(CONS_ERROR, "%s", msg);
-		M_StartMessage(msg, NULL, MM_NOTHING);
+		M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 		G_ResetDemoPlayback();
 		return;
 	}
@@ -2910,7 +2980,7 @@ void G_DoPlayDemo(char *defdemoname)
 			{
 				snprintf(msg, 1024, M_GetText("%s is a Record Attack replay with spectators, and is thus invalid.\n"), pdemoname);
 				CONS_Alert(CONS_ERROR, "%s", msg);
-				M_StartMessage(msg, NULL, MM_NOTHING);
+				M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 				G_ResetDemoPlayback();
 				return;
 			}
@@ -2922,7 +2992,7 @@ void G_DoPlayDemo(char *defdemoname)
 		{
 			snprintf(msg, 1024, M_GetText("%s is a Record Attack replay with multiple players, and is thus invalid.\n"), pdemoname);
 			CONS_Alert(CONS_ERROR, "%s", msg);
-			M_StartMessage(msg, NULL, MM_NOTHING);
+			M_StartMessage(msg, M_ReturnToTitleFromError, MM_EVENTHANDLER);
 			G_ResetDemoPlayback();
 			return;
 		}
@@ -3532,7 +3602,6 @@ void G_FreeGhosts(void)
 	ghosts = NULL;
 }
 
-
 boolean G_CheckDemoStatus(void)
 {
 	G_FreeGhosts();

src/g_demo.h

@@ -149,6 +149,7 @@ typedef struct demoghost {
 	UINT8 checksum[16];
 	UINT8 *buffer, *p, color;
 	UINT16 version;
+	boolean done;
 	mobj_t oldmo, *mo;
 	struct demoghost *next;
 } demoghost;

src/g_game.c

@@ -132,7 +132,7 @@ UINT8 skincolor_bluering = SKINCOLOR_STEEL;
 tic_t countdowntimer = 0;
 boolean countdowntimeup = false;
 
-cutscene_t *cutscenes[128];
+cutscene_t *cutscenes[128] = {};
 
 INT16 nextmapoverride = 0;
 boolean skipstats = false;
@@ -144,7 +144,7 @@ mobj_t *blueflag = NULL;
 mapthing_t *rflagpoint = NULL;
 mapthing_t *bflagpoint = NULL;
 
-struct quake quake;
+struct quake quake = {};
 
 // Map Header Information
 mapheader_t* mapheaderinfo[NUMMAPS] = {};
@@ -228,7 +228,7 @@ tic_t racecountdown = 0, exitcountdown = 0; // for racing
 fixed_t gravity = 0;
 fixed_t mapobjectscale = FRACUNIT;
 
-struct maplighting maplighting;
+struct maplighting maplighting = {};
 
 INT16 autobalance = 0; //for CTF team balance
 INT16 teamscramble = 0; //for CTF team scramble
@@ -312,6 +312,8 @@ consvar_t cv_pauseifunfocused = {"pauseifunfocused", "Yes", CV_SAVE, CV_YesNo, N
 static CV_PossibleValue_t songcredits_cons_t[] = {{0, "Off"}, {1, "Default"}, {2, "Box"}, {0, NULL}};
 consvar_t cv_songcredits = {"songcredits", "Default", CV_SAVE, songcredits_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+consvar_t cv_pausesongcredits = {"pausesongcredits", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 // Show "FREE PLAY" when you're alone. :(
 consvar_t cv_showfreeplay = { "showfreeplay", "Yes", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -452,6 +454,14 @@ consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS] = {
 	{"litesteer4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
 };
 
+//static CV_PossibleValue_t autoaccelcons_t[] = {{0, "Off"}, {1, "Manual"}, {2, "Automatic"}, {0, NULL}};
+consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS] = {
+	{"kartautoaccel",  "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel3", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
+};
+
 static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}};
 consvar_t cv_driftsparkpulse = {"driftsparkpulse", "1.4", CV_FLOAT | CV_SAVE, driftsparkpulse_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -513,11 +523,8 @@ void G_ClearRecords(void)
 	INT16 i;
 	for (i = 0; i < NUMMAPS; ++i)
 	{
-		if (mainrecords[i])
-		{
-			Z_Free(mainrecords[i]);
-			mainrecords[i] = NULL;
-		}
+		Z_Free(mainrecords[i]);
+		mainrecords[i] = NULL;
 	}
 }
 
@@ -662,7 +669,7 @@ INT16 G_ClipAimingPitch(INT32 *aiming)
 	else if (*aiming < -limitangle)
 		*aiming = -limitangle;
 
-	return (INT16)((*aiming)>>16);
+	return (INT16)((*aiming) >> TICCMD_REDUCE);
 }
 
 INT16 G_SoftwareClipAimingPitch(INT32 *aiming)
@@ -675,7 +682,7 @@ INT16 G_SoftwareClipAimingPitch(INT32 *aiming)
 	else if (*aiming < -limitangle)
 		*aiming = -limitangle;
 
-	return (INT16)((*aiming)>>16);
+	return (INT16)((*aiming) >> TICCMD_REDUCE);
 }
 
 INT32 JoyAxis(axis_input_e axissel, UINT8 player)
@@ -798,6 +805,10 @@ static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
 static fixed_t sidemove[2] = {2<<FRACBITS>>16, 4<<FRACBITS>>16};
 static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
 
+//
+// G_HandleLocalDriftturn
+// Hack for Lua menus that check directional inputs with driftturn
+//
 static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
 {
 	INT32 axis = 0;
@@ -860,9 +871,8 @@ static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
 //
 static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
 {
-	boolean moveinput = false;
 	INT32 axis = 0;
-	const boolean usejoystick = (cv_usejoystick[(ssplayer-1)].value);
+	const boolean usejoystick = cv_usejoystick[(ssplayer-1)].value;
 
 	// check for inputs and return button commands
 	// for stuff like joining with item button, saltyhop, honking, etc.
@@ -897,15 +907,11 @@ static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
 
 #undef CHECKINPUT
 
-	moveinput = (InputDown(gc_turnleft, ssplayer) || InputDown(gc_turnright, ssplayer)
-	|| InputDown(gc_aimforward, ssplayer) || InputDown(gc_aimbackward, ssplayer) ||
-	(usejoystick && JoyAxis(AXISAIM, ssplayer) != 0) || (usejoystick && JoyAxis(AXISTURN, ssplayer) != 0));
-
 	axis = JoyAxis(AXISLOOKBACK, ssplayer);
 	camspin[ssplayer-1] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
 
 	// Reset to our spec player if we watch someone else.
-	if ((moveinput || cmd->buttons)
+	if ((cmd->driftturn || cmd->buttons)
 		&& displayplayers[0] != consoleplayer && ssplayer == 1)
 	{
 		if (cv_director.value)
@@ -917,6 +923,63 @@ static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
 	}
 }
 
+//
+// G_HandleAutoAcceleration
+//
+static void G_HandleAutoAcceleration(ticcmd_t *cmd, player_t *player, UINT8 forplayer)
+{
+	if (!cv_autoaccel[forplayer].value)
+		return;
+
+	if (gamestate != GS_LEVEL)
+		return;
+
+	// dont accel before and during countdown
+	if (leveltime <= starttime)
+		return;
+
+	// dont do this in menus or when console is onscreen
+	if (menuactive || CON_Ready())
+		return;
+
+	// gotta have a player that aint respawning
+	if (!player->mo || player->kartstuff[k_respawn])
+		return;
+
+	// dont need for "finished" players
+	if (player->exiting || (player->pflags & PF_TIMEOVER))
+		return;
+
+	// dont do during spinout
+	if (player->kartstuff[k_spinouttimer])
+		return;
+
+	// spectators and freecam dont need special handling, see G_BuildTiccmd
+
+	if (cmd->buttons & BT_BRAKE)
+	{
+		if (cmd->buttons & BT_DRIFT ||
+			player->kartstuff[k_sneakertimer] ||
+			player->kartstuff[k_squishedtimer])
+		{
+			cmd->forwardmove = (SINT8)forwardmove[0];
+			cmd->buttons |= BT_ACCELERATE;
+		}
+		else
+		{
+			// allows us to drive backwards if we need to
+			if (cmd->forwardmove > 0)
+				cmd->forwardmove = 0;
+			cmd->buttons &= ~BT_ACCELERATE;
+		}
+	}
+	else
+	{
+		cmd->forwardmove = (SINT8)forwardmove[1];
+		cmd->buttons |= BT_ACCELERATE;
+	}
+}
+
 //
 // G_BuildTiccmd
 // Builds a ticcmd from all of the available inputs
@@ -959,7 +1022,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	// Kart, don't build a ticcmd if someone is resynching or the server is stopped too so we don't fly off course in bad conditions
 	if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching)
 	{
-		cmd->angleturn = (INT16)(lang >> 16);
+		cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
 		cmd->aiming = G_ClipAimingPitch(&laim);
 		return;
 	}
@@ -967,7 +1030,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	// dumbass thing so we can use a few buttons but dont accidentally drive away
 	if (player->spectator || freecam)
 	{
-		cmd->angleturn = (INT16)(lang >> 16);
+		cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
 		G_BuildLocalTiccmd(cmd, ssplayer, freecam);
 
 		// let lua override everything
@@ -1064,7 +1127,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		if (InputDown(gc_accelerate, ssplayer) || (gamepadjoystickmove && axis > 0) || player->kartstuff[k_sneakertimer])
 		{
 			cmd->buttons |= BT_ACCELERATE;
-			forward = forwardmove[1];	// 50
+			forward = forwardmove[1]; // 50
 		}
 		else if (analogjoystickmove && axis > 0)
 		{
@@ -1127,7 +1190,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	cmd->aiming = G_ClipAimingPitch(&laim);
 
-	mousex = mousey = mlooky = 0;
+	mousex = mousey = 0;
 
 	if (forward > MAXPLMOVE)
 		forward = MAXPLMOVE;
@@ -1145,6 +1208,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		cmd->sidemove = (SINT8)(cmd->sidemove + side);
 	}
 
+	G_HandleAutoAcceleration(cmd, player, forplayer);
+
 	//{ SRB2kart - Drift support
 	// Not grouped with the rest of turn stuff because it needs to know what buttons you're pressing for rubber-burn turn
 	// limit turning to angleturn[1] to stop mouselook letting you look too fast
@@ -1166,10 +1231,10 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		|| (leveltime > starttime && (cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE)) // Rubber-burn turn
 		|| (player->kartstuff[k_respawn]) // Respawning
 		|| (player->spectator || objectplacing))) // Not a physical player
-		lang += (cmd->angleturn<<16);
+		lang += (cmd->angleturn << TICCMD_REDUCE);
 
-	cmd->angleturn = (INT16)(lang >> 16);
-	cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
+	cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
+	cmd->latency = modeattacking ? 0 : (leveltime & TICCMD_LATENCYMASK); // Send leveltime when this tic was generated to the server for control lag calculations
 
 	if (!hu_stopped)
 	{
@@ -1750,14 +1815,15 @@ void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive)
 // Increment a viewpoint by offset from the current player. A negative value
 // decrements.
 //
-void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive)
+void G_AdjustViewEx(UINT8 viewnum, INT32 offset, boolean onlyactive, boolean resetfreecam)
 {
 	INT32 *displayplayerp, oldview;
 	displayplayerp = &displayplayers[viewnum-1];
 	oldview = (*displayplayerp);
 
 	// turn off the freecam
-	camera[viewnum-1].freecam = false;
+	if (resetfreecam)
+		camera[viewnum-1].freecam = false;
 
 	G_ResetView(viewnum, ( (*displayplayerp) + offset ), onlyactive);
 
@@ -1771,7 +1837,7 @@ void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive)
 // Ensures all viewpoints are valid
 // Also demotes splitscreen down to one player.
 //
-void G_ResetViews(void)
+void G_ResetViews(boolean resetfreecam)
 {
 	UINT8 splits;
 	UINT8 viewd;
@@ -1795,7 +1861,7 @@ void G_ResetViews(void)
 	*/
 	for (viewd = 1; viewd <= splits; ++viewd)
 	{
-		G_AdjustView(viewd, 0, false);
+		G_AdjustViewEx(viewd, 0, false, resetfreecam);
 	}
 }
 
@@ -1876,7 +1942,7 @@ void G_Ticker(boolean run)
 			G_CopyTiccmd(cmd, &netcmds[buf][i], 1);
 
 			// Use the leveltime sent in the player's ticcmd to determine control lag
-			cmd->latency = modeattacking ? 0 : min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1); //@TODO add a cvar to allow setting this max
+			cmd->latency = modeattacking ? 0 : min(((leveltime & TICCMD_LATENCYMASK) - cmd->latency) & TICCMD_LATENCYMASK, MAXPREDICTTICS-1); //@TODO add a cvar to allow setting this max
 		}
 	}
 
@@ -1884,7 +1950,6 @@ void G_Ticker(boolean run)
 	switch (gamestate)
 	{
 		case GS_LEVEL:
-
 			for (; ra_timeskip < starttime - TICRATE*4; ra_timeskip++)	// this looks weird but this is done to not break compability with older demos for now.
 			{
 				if (demo.title)
@@ -3433,7 +3498,7 @@ void G_LoadGameData(void)
 	INT32 i, j;
 	UINT8 modded = false;
 	UINT8 rtemp;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	//For records
 	tic_t rectime;
@@ -3566,7 +3631,7 @@ void G_SaveGameData(boolean force)
 	size_t length;
 	INT32 i, j;
 	UINT8 btemp;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	(void)force;
 	char backupfile[MAX_WADPATH+4];
 
@@ -3737,7 +3802,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	size_t length;
 	char vcheck[VERSIONSIZE];
 	char savename[255];
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
 	memset(&savedata, 0, sizeof(savedata));
@@ -3823,7 +3888,7 @@ void G_SaveGame(UINT32 savegameslot)
 	boolean saved;
 	char savename[256] = "";
 	const char *backup;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	sprintf(savename, savegamename, savegameslot);
 	backup = va("%s",savename);
@@ -4093,7 +4158,7 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				PU_STATIC, NULL);
 	for (qp = strtok(va("%s", q), " ");
 			qp && fr->total < 255;
-			qp = strtok(0, " "))
+			qp = strtok(NULL, " "))
 	{
 		if (( sp = strcasestr(s, qp) ))
 		{
@@ -4174,7 +4239,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 			{
 				newmapnum = mapnum;
 				newmapname = realmapname;
-				realmapname = 0;
+				realmapname = NULL;
 				Z_Free(apromapname);
 				if (!wanttable)
 					break;
@@ -4195,7 +4260,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 				{
 					apromapnum = mapnum;
 					apromapname = realmapname;
-					realmapname = 0;
+					realmapname = NULL;
 				}
 			}
 			else/* ...match individual keywords */

src/g_game.h

@@ -50,7 +50,7 @@ extern INT16 rw_maximums[NUM_WEAPONS];
 
 // used in game menu
 extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatbacktint, cv_chatspamprotection, cv_chatcentertext/*, cv_compactscoreboard*/;
-extern consvar_t cv_songcredits;
+extern consvar_t cv_songcredits, cv_pausesongcredits;
 extern consvar_t cv_showfreeplay;
 extern consvar_t cv_growmusic, cv_supermusic;
 extern consvar_t cv_pauseifunfocused;
@@ -74,6 +74,8 @@ extern consvar_t cv_ydeadzone[MAXSPLITSCREENPLAYERS];
 
 extern consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS];
 
+extern consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS];
+
 extern consvar_t cv_ghost_besttime, cv_ghost_bestlap, cv_ghost_last, cv_ghost_guest, cv_ghost_staff;
 
 // Hud offsets
@@ -128,6 +130,7 @@ extern consvar_t cv_spinoutroll;
 extern consvar_t cv_squishdance, cv_squishdancespeed;
 
 extern consvar_t cv_playerblendeffects;
+extern consvar_t cv_reducevfx;
 
 extern consvar_t cv_cechotoggle;
 
@@ -262,9 +265,10 @@ boolean G_CanView(INT32 playernum, UINT8 viewnum, boolean onlyactive);
 INT32 G_FindView(INT32 startview, UINT8 viewnum, boolean onlyactive, boolean reverse);
 INT32 G_CountPlayersPotentiallyViewable(boolean active);
 
-void G_ResetViews(void);
+void G_ResetViews(boolean resetfreecam);
 void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive);
-void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive);
+void G_AdjustViewEx(UINT8 viewnum, INT32 offset, boolean onlyactive, boolean resetfreecam);
+#define G_AdjustView(v,o,oa) G_AdjustViewEx(v,o,oa, true)
 
 void G_AddPlayer(INT32 playernum);
 

src/g_input.c

@@ -34,7 +34,7 @@ static CV_PossibleValue_t onecontrolperkey_cons_t[] = {{1, "One"}, {2, "Several"
 static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "Off"}, {0, NULL}};
 
 // mouse values are used once
-consvar_t cv_mousesens = {"mousesens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -81,6 +81,9 @@ consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
 	{"gamepadled4", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle4, 0, NULL, NULL, 0, 0, NULL}
 };
 
+consvar_t cv_gamepadledifunfocused = {"gamepadledunfocused",  "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_rumbleifunfocused = {"rumbleifunfocused",  "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 static void rumble_off_handle(void)
 {
 	if (!cv_rumble[0].value)
@@ -125,17 +128,17 @@ static void led_off_handle4(void)
 	G_ResetPlayerGamepadIndicatorColor(3);
 }
 
-INT32 mousex, mousey;
-INT32 mlooky; // like mousey but with a custom sensitivity for mlook
+INT32 mousex = 0, mousey = 0;
 
 // joystick values are repeated
-INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET];
+INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET] = {};
+INT32 joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET] = {};
 
 // current state of the keys: true if pushed
-UINT8 gamekeydown[NUMINPUTS];
+UINT8 gamekeydown[NUMINPUTS] = {};
 
 // two key codes (or virtual key) per game control
-INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2];
+INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2] = {};
 
 typedef struct
 {
@@ -192,9 +195,8 @@ void G_MapEventsToControls(event_t *ev)
 		case ev_mouse: // buttons are virtual keys
 			if (menuactive || CON_Ready() || chat_on)
 				break;
-			mousex = (INT32)(ev->data2*((cv_mousesens.value*cv_mousesens.value)/110.0f + 0.1f));
-			mousey = (INT32)(ev->data3*((cv_mousesens.value*cv_mousesens.value)/110.0f + 0.1f));
-			mlooky = (INT32)(ev->data3*((cv_mouseysens.value*cv_mousesens.value)/110.0f + 0.1f));
+			mousex = (INT32)(ev->data2*((cv_mousexsens.value*cv_mousexsens.value)/110.0f + 0.1f));
+			mousey = (INT32)(ev->data3*((cv_mouseysens.value*cv_mouseysens.value)/110.0f + 0.1f));
 			break;
 
 		case ev_joystick: // buttons are virtual keys
@@ -215,7 +217,7 @@ void G_MapEventsToControls(event_t *ev)
 
 		case ev_joystick3:
 			i = ev->data1;
-			if (i >= JOYAXISSET)
+			if (i >= JOYAXISSET || menuactive)
 				break;
 			if (ev->data2 != INT32_MAX) joyxmove[2][i] = ev->data2;
 			if (ev->data3 != INT32_MAX) joyymove[2][i] = ev->data3;
@@ -223,7 +225,7 @@ void G_MapEventsToControls(event_t *ev)
 
 		case ev_joystick4:
 			i = ev->data1;
-			if (i >= JOYAXISSET)
+			if (i >= JOYAXISSET || menuactive)
 				break;
 			if (ev->data2 != INT32_MAX) joyxmove[3][i] = ev->data2;
 			if (ev->data3 != INT32_MAX) joyymove[3][i] = ev->data3;
@@ -931,7 +933,7 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
 
 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 
-	if (cv_gamepadled[playernum].value == 0
+	if (cv_gamepadled[playernum].value == 0 || (window_notinfocus && cv_gamepadledifunfocused.value == 0)
 	 || color >= MAXTRANSLATIONS)
 	{
 		return;
@@ -946,6 +948,8 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
 
 static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
+
 	if (cv_gamepadled[playernum].value == 0)
 	{
 		I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
@@ -990,6 +994,7 @@ void G_ResetDeviceLED(void)
 
 static void G_ResetPlayerDeviceRumble(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 	I_GamepadRumble(playernum, 0, 0, 0);
 }
 
@@ -1007,7 +1012,7 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
 {
 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 
-	if (cv_rumble[playernum].value == 0)
+	if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0))
 	{
 		return;
 	}

src/g_input.h

@@ -109,15 +109,17 @@ typedef enum
 } gamecontrols_e;
 
 // mouse values are used once
-extern consvar_t cv_mousesens, cv_mouseysens;
+extern consvar_t cv_mousexsens, cv_mouseysens;
 extern consvar_t cv_controlperkey;
 extern consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS];
 extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
 extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS];
 extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
 
+extern consvar_t cv_gamepadledifunfocused;
+extern consvar_t cv_rumbleifunfocused;
+
 extern INT32 mousex, mousey;
-extern INT32 mlooky; //mousey with mlookSensitivity
 
 extern INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET];
 

src/hardware/hw_batching.c

@@ -214,7 +214,7 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 	const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
 
 	const GLMipmap_t *texture1 = poly1->hash & 0x80000000 ? NULL : poly1->texture;
-	const GLMipmap_t *texture2 = poly1->hash & 0x80000000 ? NULL : poly2->texture;
+	const GLMipmap_t *texture2 = poly2->hash & 0x80000000 ? NULL : poly2->texture;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (!texture1 && !texture2)
@@ -237,7 +237,7 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 
 // This function organizes the geometry collected by HWR_ProcessPolygon calls into batches and uses
 // the rendering backend to draw them.
-void HWR_RenderBatches(boolean sort)
+void HWR_RenderBatches(void)
 {
 	int finalVertexWritePos = 0; // position in finalVertexArray
 	int finalIndexWritePos  = 0; // position in finalVertexIndexArray
@@ -288,13 +288,10 @@ void HWR_RenderBatches(boolean sort)
 		polygonArraySorted[i] = &polygonArray[i];
 	}
 
-	if (sort)
-	{
-		// sort polygons
-		PS_START_TIMING(ps_hw_batchsorttime);
-		qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), (useshader ? comparePolygons : comparePolygonsNoShaders));
-		PS_STOP_TIMING(ps_hw_batchsorttime);
-	}
+	// sort polygons
+	PS_START_TIMING(ps_hw_batchsorttime);
+	qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), (useshader ? comparePolygons : comparePolygonsNoShaders));
+	PS_STOP_TIMING(ps_hw_batchsorttime);
 
 	// sort order
 	// 1. shader
@@ -303,9 +300,7 @@ void HWR_RenderBatches(boolean sort)
 	// 4. colors + light level
 	// not sure about what order of the last 2 should be, or if it even matters
 
-	// dont overwrite this on consecutive calls
-	if (!sort)
-		PS_START_TIMING(ps_hw_batchdrawtime);
+	PS_START_TIMING(ps_hw_batchdrawtime);
 
 	currentShader      = polygonArraySorted[0]->shader;
 	currentTexture     = polygonArraySorted[0]->texture;
@@ -396,7 +391,7 @@ void HWR_RenderBatches(boolean sort)
 				nextSurfaceInfo = nextEntry->surf;
 
 				if (nextPolyFlags & PF_NoTexture)
-					nextTexture = 0;
+					nextTexture = NULL;
 
 				if (useshader && currentShader != nextShader)
 				{
@@ -500,8 +495,7 @@ void HWR_RenderBatches(boolean sort)
 	polygonArraySize = 0;
 	unsortedVertexArraySize = 0;
 
-	if (!sort)
-		PS_STOP_TIMING(ps_hw_batchdrawtime);
+	PS_STOP_TIMING(ps_hw_batchdrawtime);
 }
 
 #endif // HWRENDER

src/hardware/hw_batching.h

@@ -37,7 +37,7 @@ typedef struct
 void HWR_StartBatching(void);
 void HWR_SetCurrentTexture(GLMipmap_t *texture);
 void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, int shader, boolean horizonSpecial);
-void HWR_RenderBatches(boolean sort);
+void HWR_RenderBatches(void);
 
 #ifdef __cplusplus
 } // extern "C"

src/hardware/hw_cache.cpp

@@ -619,7 +619,6 @@ static void HWR_PrecacheLevelFlats(void)
 	// lookup for flats that may´ve been already loaded
 	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
 	std::unordered_set<UINT32> flatpresent;
-	lumpnum_t lump;
 	size_t i, j;
 	INT32 k;
 
@@ -649,9 +648,8 @@ static void HWR_PrecacheLevelFlats(void)
 				const INT32 pic = ceiling ? sec->ceilingpic : sec->floorpic;
 
 				const levelflat_t *levelflat = &levelflats[pic];
-				lump = levelflat->lumpnum;
 
-				load_flat(lump, R_NoEncore(sec, ceiling));
+				load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
 
 				if (levelflat->speed) // is it an animated flat ?
 				{
@@ -672,9 +670,8 @@ static void HWR_PrecacheLevelFlats(void)
 		for (i = 0; i < numlevelflats; i++)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
-			lump = levelflat->lumpnum;
 
-			load_flat(lump, false);
+			load_flat(levelflat->lumpnum, false);
 
 			if (levelflat->speed) // is it an animated flat ?
 			{

src/hardware/hw_clip.c

@@ -335,7 +335,7 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 	floatangle = 2.0 + (45.0 + ((double)tilt / 1.9)) * clipfov / 90.0;
 	if (floatangle >= 180.0)
 		return 0xffffffff;
-	a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle);
+	a1 = (angle_t)lrint(ANG1 * floatangle);
 	return a1;
 }
 

src/hardware/hw_gl.h

@@ -80,6 +80,9 @@ UINT32 GL_CreateLightTable(RGBA_t *hw_lighttable);
 void GL_ClearLightTables(void);
 void GL_SetScreenPalette(RGBA_t *palette);
 
+void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
+                      FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/hardware/hw_main.cpp

@@ -101,7 +101,8 @@ sector_t *gl_backsector = NULL;
 static constexpr float clipping_distances[] = {1024.0f, 2048.0f, 4096.0f, 6144.0f, 8192.0f, 12288.0f, 16384.0f};
 // values for bsp culling
 // slightly higher than the far clipping plane to compensate for impreciseness
-static constexpr INT32 bsp_culling_distances[] = {(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
+static constexpr INT32 bsp_culling_distances[] = {
+	(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
 	(6144+512)*FRACUNIT, (8192+512)*FRACUNIT, (12288+512)*FRACUNIT, (16384+512)*FRACUNIT};
 
 // Performance stats
@@ -587,15 +588,11 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 	const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
 
 	// Get the slope pointer to simplify future code
-	if (sec->f_slope && !isceiling)
+	if (!isceiling && sec->f_slope)
 		slope = sec->f_slope;
-	else if (sec->c_slope && isceiling)
+	else if (isceiling && sec->c_slope)
 		slope = sec->c_slope;
 
-	// Set fixedheight to the slope's height from our viewpoint, if we have a slope
-	if (slope)
-		fixedheight = P_GetSlopeZAt(slope, viewx, viewy);
-
 	height = FixedToFloat(fixedheight);
 
 	// Allocate plane-vertex buffer if we need to
@@ -643,8 +640,8 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 	pv = planepoly->pts;
 
 	// reference point for flat texture coord for each vertex around the polygon
-	flatxref = (float)(((fixed_t)pv->x & (~flatflag)) / fflatsize);
-	flatyref = (float)(((fixed_t)pv->y & (~flatflag)) / fflatsize);
+	flatxref = static_cast<float>(static_cast<fixed_t>(pv->x) & (~flatflag)) / fflatsize;
+	flatyref = static_cast<float>(static_cast<fixed_t>(pv->y) & (~flatflag)) / fflatsize;
 
 	if (!isceiling) // it's a floor
 	{
@@ -661,9 +658,13 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 
 	if (angle) // Only needs to be done if there's an altered angle
 	{
+		// This needs to be done so that it scrolls in a different direction after rotation like software
 		tempxsow = flatxref;
 		tempytow = flatyref;
 		anglef   = ANG2RAD(InvAngle(angle));
+
+		// This needs to be done so everything aligns after rotation
+		// It would be done so that rotation is done, THEN the translation, but I couldn't get it to rotate AND scroll like software does
 		cosangf = cosf(anglef);
 		sinangf = sinf(anglef);
 		flatxref = (tempxsow * cosangf) - (tempytow * sinangf);
@@ -683,18 +684,19 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 			vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\
 			vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\
 		}\
+\
+		if (slope)\
+		{\
+			fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
+			height = FixedToFloat(fixedheight);\
+		}\
 \
 		vert->x = (vx);\
 		vert->y = height;\
 		vert->z = (vy);\
 \
-		if (slope)\
-		{\
-			fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
-			vert->y = FixedToFloat(fixedheight);\
-		}\
 }
-	for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++,pv++)
+	for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++, pv++)
 		SETUP3DVERT(v3d, pv->x, pv->y);
 
 	if (slope)
@@ -807,6 +809,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 			}
 		}
 	}
+#undef SETUP3DVERT
 }
 
 #ifdef WALLSPLATS
@@ -1366,8 +1369,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 
 	// x offset the texture
 	const fixed_t texturehpeg = gl_sidedef->textureoffset + gl_curline->offset;
-	const float cliplow  = (float)texturehpeg;
-	const float cliphigh = ((float)texturehpeg + (float)gl_curline->length);
+	const float cliplow  = static_cast<float>(texturehpeg);
+	const float cliphigh = static_cast<float>(texturehpeg) + static_cast<float>(gl_curline->length);
 
 	FUINT lightnum = gl_frontsector->lightlevel;
 	extracolormap_t *colormap = gl_frontsector->extra_colormap;
@@ -1375,14 +1378,13 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 
 	FSurfaceInfo Surf;
 
-	if (gl_frontsector)
-		Surf.PolyColor.s.alpha = 255;
+	Surf.PolyColor.s.alpha = 255;
 
 	const INT32 gl_midtexture = R_GetTextureNum(gl_sidedef->midtexture);
 	GLMapTexture_t *glTex = NULL;
 
-	static constexpr float FLOATMAX = (float)INT32_MAX / (float)FRACUNIT;
-	static constexpr float FLOATMIN = (float)INT32_MIN / (float)FRACUNIT;
+	static constexpr float FLOATMAX = static_cast<float>(INT32_MAX) / static_cast<float>(FRACUNIT);
+	static constexpr float FLOATMIN = static_cast<float>(INT32_MIN) / static_cast<float>(FRACUNIT);
 
 	// two sided line
 	if (gl_backsector)
@@ -1495,8 +1497,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 
 			glTex = HWR_GetTexture(gl_toptexture, noencore);
 
-			wallVerts[3].t = wallVerts[2].t = texturevpeg * glTex->scaleY;
-			wallVerts[0].t = wallVerts[1].t = (texturevpeg + gl_frontsector->ceilingheight - gl_backsector->ceilingheight) * glTex->scaleY;
+			wallVerts[3].t = wallVerts[2].t = static_cast<float>(texturevpeg) * glTex->scaleY;
+			wallVerts[0].t = wallVerts[1].t = static_cast<float>(texturevpeg + gl_frontsector->ceilingheight - gl_backsector->ceilingheight) * glTex->scaleY;
 			wallVerts[0].s = wallVerts[3].s = cliplow * glTex->scaleX;
 			wallVerts[2].s = wallVerts[1].s = cliphigh * glTex->scaleX;
 
@@ -1504,23 +1506,23 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 			if (!(gl_linedef->flags & ML_EFFECT1))
 			{
 				// Unskewed
-				wallVerts[3].t -= (worldtop - gl_frontsector->ceilingheight) * glTex->scaleY;
-				wallVerts[2].t -= (worldtopslope - gl_frontsector->ceilingheight) * glTex->scaleY;
-				wallVerts[0].t -= (worldhigh - gl_backsector->ceilingheight) * glTex->scaleY;
-				wallVerts[1].t -= (worldhighslope - gl_backsector->ceilingheight) * glTex->scaleY;
+				wallVerts[3].t -= static_cast<float>(worldtop - gl_frontsector->ceilingheight) * glTex->scaleY;
+				wallVerts[2].t -= static_cast<float>(worldtopslope - gl_frontsector->ceilingheight) * glTex->scaleY;
+				wallVerts[0].t -= static_cast<float>(worldhigh - gl_backsector->ceilingheight) * glTex->scaleY;
+				wallVerts[1].t -= static_cast<float>(worldhighslope - gl_backsector->ceilingheight) * glTex->scaleY;
 			}
 			else if (gl_linedef->flags & ML_DONTPEGTOP)
 			{
 				// Skewed by top
-				wallVerts[0].t = (texturevpeg + (worldtop - worldhigh)) * glTex->scaleY;
-				wallVerts[1].t = (texturevpeg + (worldtopslope - worldhighslope)) * glTex->scaleY;
+				wallVerts[0].t = static_cast<float>(texturevpeg + (worldtop - worldhigh)) * glTex->scaleY;
+				wallVerts[1].t = static_cast<float>(texturevpeg + (worldtopslope - worldhighslope)) * glTex->scaleY;
 			}
 			else
 			{
 				// Skewed by bottom
-				wallVerts[0].t = wallVerts[1].t = (texturevpeg + (worldtop - worldhigh)) * glTex->scaleY;
-				wallVerts[3].t = wallVerts[0].t - (worldtop - worldhigh) * glTex->scaleY;
-				wallVerts[2].t = wallVerts[1].t - (worldtopslope - worldhighslope) * glTex->scaleY;
+				wallVerts[0].t = wallVerts[1].t = static_cast<float>(texturevpeg + (worldtop - worldhigh)) * glTex->scaleY;
+				wallVerts[3].t = wallVerts[0].t - static_cast<float>(worldtop - worldhigh) * glTex->scaleY;
+				wallVerts[2].t = wallVerts[1].t - static_cast<float>(worldtopslope - worldhighslope) * glTex->scaleY;
 			}
 
 			// set top/bottom coords
@@ -1557,8 +1559,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 
 			glTex = HWR_GetTexture(gl_bottomtexture, noencore);
 
-			wallVerts[3].t = wallVerts[2].t = texturevpeg * glTex->scaleY;
-			wallVerts[0].t = wallVerts[1].t = (texturevpeg + (gl_backsector->floorheight - gl_frontsector->floorheight)) * glTex->scaleY;
+			wallVerts[3].t = wallVerts[2].t = static_cast<float>(texturevpeg * glTex->scaleY);
+			wallVerts[0].t = wallVerts[1].t = static_cast<float>(texturevpeg + (gl_backsector->floorheight - gl_frontsector->floorheight)) * glTex->scaleY;
 			wallVerts[0].s = wallVerts[3].s = cliplow * glTex->scaleX;
 			wallVerts[2].s = wallVerts[1].s = cliphigh * glTex->scaleX;
 
@@ -1566,22 +1568,22 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 			if (!(gl_linedef->flags & ML_EFFECT1))
 			{
 				// Unskewed
-				wallVerts[0].t -= (worldbottom - gl_frontsector->floorheight) * glTex->scaleY;
-				wallVerts[1].t -= (worldbottomslope - gl_frontsector->floorheight) * glTex->scaleY;
-				wallVerts[3].t -= (worldlow - gl_backsector->floorheight) * glTex->scaleY;
-				wallVerts[2].t -= (worldlowslope - gl_backsector->floorheight) * glTex->scaleY;
+				wallVerts[0].t -= static_cast<float>(worldbottom - gl_frontsector->floorheight) * glTex->scaleY;
+				wallVerts[1].t -= static_cast<float>(worldbottomslope - gl_frontsector->floorheight) * glTex->scaleY;
+				wallVerts[3].t -= static_cast<float>(worldlow - gl_backsector->floorheight) * glTex->scaleY;
+				wallVerts[2].t -= static_cast<float>(worldlowslope - gl_backsector->floorheight) * glTex->scaleY;
 			}
 			else if (gl_linedef->flags & ML_DONTPEGBOTTOM)
 			{
 				// Skewed by bottom
-				wallVerts[0].t = wallVerts[1].t = (texturevpeg + (worldlow - worldbottom)) * glTex->scaleY;
-				wallVerts[2].t = wallVerts[1].t - (worldlowslope - worldbottomslope) * glTex->scaleY;
+				wallVerts[0].t = wallVerts[1].t = static_cast<float>(texturevpeg + (worldlow - worldbottom)) * glTex->scaleY;
+				wallVerts[2].t = wallVerts[1].t - static_cast<float>(worldlowslope - worldbottomslope) * glTex->scaleY;
 			}
 			else
 			{
 				// Skewed by top
-				wallVerts[0].t = (texturevpeg + (worldlow - worldbottom)) * glTex->scaleY;
-				wallVerts[1].t = (texturevpeg + (worldlowslope - worldbottomslope)) * glTex->scaleY;
+				wallVerts[0].t = static_cast<float>(texturevpeg + (worldlow - worldbottom)) * glTex->scaleY;
+				wallVerts[1].t = static_cast<float>(texturevpeg + (worldlowslope - worldbottomslope)) * glTex->scaleY;
 			}
 
 			// set top/bottom coords
@@ -1743,13 +1745,13 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 			glTex = HWR_GetTexture(gl_midtexture, noencore);
 
 			// Left side
-			wallVerts[3].t = texturevpeg * glTex->scaleY;
-			wallVerts[0].t = (h - l + texturevpeg) * glTex->scaleY;
+			wallVerts[3].t = static_cast<float>(texturevpeg * glTex->scaleY);
+			wallVerts[0].t = static_cast<float>(h - l + texturevpeg) * glTex->scaleY;
 			wallVerts[0].s = wallVerts[3].s = cliplow * glTex->scaleX;
 
 			// Right side
 			wallVerts[2].t = texturevpegslope * glTex->scaleY;
-			wallVerts[1].t = (hS - lS + texturevpegslope) * glTex->scaleY;
+			wallVerts[1].t = static_cast<float>(hS - lS + texturevpegslope) * glTex->scaleY;
 			wallVerts[2].s = wallVerts[1].s = cliphigh * glTex->scaleX;
 
 			// set top/bottom coords
@@ -1780,10 +1782,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		// Single sided line... Deal only with the middletexture (if one exists)
 		if (gl_midtexture && gl_linedef->special != HORIZONSPECIAL) // Ignore horizon line for OGL
 		{
-			glTex = HWR_GetTexture(gl_midtexture, noencore);
-
 			fixed_t texturevpeg;
 
+			glTex = HWR_GetTexture(gl_midtexture, noencore);
+
 			// PEGGING
 			if ((gl_linedef->flags & (ML_DONTPEGBOTTOM|ML_EFFECT2)) == (ML_DONTPEGBOTTOM|ML_EFFECT2))
 				texturevpeg = gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight + gl_sidedef->rowoffset;
@@ -1792,28 +1794,28 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 			else
 				texturevpeg = gl_sidedef->rowoffset; // top of texture at top
 
-			wallVerts[3].t = wallVerts[2].t = texturevpeg * glTex->scaleY;
-			wallVerts[0].t = wallVerts[1].t = (texturevpeg + gl_frontsector->ceilingheight - gl_frontsector->floorheight) * glTex->scaleY;
+			wallVerts[3].t = wallVerts[2].t = (static_cast<float>(texturevpeg) * glTex->scaleY);
+			wallVerts[0].t = wallVerts[1].t = static_cast<float>(texturevpeg + gl_frontsector->ceilingheight - gl_frontsector->floorheight) * glTex->scaleY;
 			wallVerts[0].s = wallVerts[3].s = cliplow * glTex->scaleX;
 			wallVerts[2].s = wallVerts[1].s = cliphigh * glTex->scaleX;
 
 			// Texture correction for slopes
 			if (gl_linedef->flags & ML_EFFECT2)
 			{
-				wallVerts[3].t += (gl_frontsector->ceilingheight - worldtop) * glTex->scaleY;
-				wallVerts[2].t += (gl_frontsector->ceilingheight - worldtopslope) * glTex->scaleY;
-				wallVerts[0].t += (gl_frontsector->floorheight - worldbottom) * glTex->scaleY;
-				wallVerts[1].t += (gl_frontsector->floorheight - worldbottomslope) * glTex->scaleY;
+				wallVerts[3].t += static_cast<float>(gl_frontsector->ceilingheight - worldtop) * glTex->scaleY;
+				wallVerts[2].t += static_cast<float>(gl_frontsector->ceilingheight - worldtopslope) * glTex->scaleY;
+				wallVerts[0].t += static_cast<float>(gl_frontsector->floorheight - worldbottom) * glTex->scaleY;
+				wallVerts[1].t += static_cast<float>(gl_frontsector->floorheight - worldbottomslope) * glTex->scaleY;
 			}
 			else if (gl_linedef->flags & ML_DONTPEGBOTTOM)
 			{
-				wallVerts[3].t = wallVerts[0].t + (worldbottom - worldtop) * glTex->scaleY;
-				wallVerts[2].t = wallVerts[1].t + ((worldbottomslope - worldtopslope)) * glTex->scaleY;
+				wallVerts[3].t = wallVerts[0].t + static_cast<float>(worldbottom - worldtop) * glTex->scaleY;
+				wallVerts[2].t = wallVerts[1].t + static_cast<float>((worldbottomslope - worldtopslope)) * glTex->scaleY;
 			}
 			else
 			{
-				wallVerts[0].t = wallVerts[3].t - (worldbottom - worldtop) * glTex->scaleY;
-				wallVerts[1].t = wallVerts[2].t - (worldbottomslope - worldtopslope) * glTex->scaleY;
+				wallVerts[0].t = wallVerts[3].t - static_cast<float>(worldbottom - worldtop) * glTex->scaleY;
+				wallVerts[1].t = wallVerts[2].t - static_cast<float>(worldbottomslope - worldtopslope) * glTex->scaleY;
 			}
 
 			//Set textures properly on single sided walls that are sloped
@@ -1870,12 +1872,13 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	//Hurdler: 3d-floors test
 	if (!gl_drawing_stencil && gl_backsector && gl_frontsector->tag != gl_backsector->tag && (gl_backsector->ffloors || gl_frontsector->ffloors))
 	{
-		ffloor_t * rover;
-		fixed_t    highcut = 0, lowcut = 0;
+		ffloor_t *rover;
+		fixed_t highcut = 0, lowcut = 0;
 		fixed_t lowcutslope = 0, highcutslope = 0;
 
 		// Used for height comparisons and etc across FOFs and slopes
 		fixed_t high1, highslope1, low1, lowslope1;
+		fixed_t high2, highslope2, low2, lowslope2;
 
 		INT32 texnum;
 
@@ -1888,19 +1891,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		{
 			for (rover = gl_backsector->ffloors; rover; rover = rover->next)
 			{
-				boolean bothsides = false;
-				// Skip if it exists on both sectors.
-				ffloor_t * r2;
-				for (r2 = gl_frontsector->ffloors; r2; r2 = r2->next)
-					if (rover->master == r2->master)
-					{
-						bothsides = true;
-						break;
-					}
-
-				if (bothsides)
-					continue;
-
 				const ffloortype_e roverflags = rover->flags;
 
 				if (!(roverflags & FF_EXISTS) || !(roverflags & FF_RENDERSIDES) || (roverflags & FF_INVERTSIDES))
@@ -1912,6 +1902,45 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				if ((high1 < lowcut || highslope1 < lowcutslope) || (low1 > highcut || lowslope1 > highcutslope))
 					continue;
 
+				ffloor_t * r2;
+				for (r2 = gl_frontsector->ffloors; r2; r2 = r2->next)
+				{
+					if (r2->master == rover->master) // Skip if same control line.
+						break;
+
+					const ffloortype_e r2flags = r2->flags;
+
+					if (!(r2flags & FF_EXISTS) || !(r2flags & FF_RENDERSIDES))
+						continue;
+
+					if (rover->flags & FF_EXTRA)
+					{
+						if (!(r2flags & FF_CUTEXTRA))
+							continue;
+
+						if (r2flags & FF_EXTRA && (r2flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG)))
+							continue;
+					}
+					else
+					{
+						if (!(r2flags & FF_CUTSOLIDS))
+							continue;
+					}
+
+					SLOPEPARAMS(*r2->t_slope, high2, highslope2, *r2->topheight)
+					SLOPEPARAMS(*r2->b_slope, low2,  lowslope2,  *r2->bottomheight)
+
+					if ((high2 < lowcut || highslope2 < lowcutslope) || (low2 > highcut || lowslope2 > highcutslope))
+						continue;
+					if ((high1 > high2 || highslope1 > highslope2) || (low1 < low2 || lowslope1 < lowslope2))
+						continue;
+
+					break;
+				}
+
+				if (r2)
+					continue;
+
 				side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);
 
 				boolean do_texture_skew;
@@ -1978,24 +2007,24 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 						if (dont_peg_bottom)
 							texturevpeg -= (*rover->topheight - *rover->bottomheight);
 
-						wallVerts[3].t = ((*rover->topheight - h) + texturevpeg) * glTex->scaleY;
-						wallVerts[2].t = ((*rover->topheight - hS) + texturevpeg) * glTex->scaleY;
-						wallVerts[0].t = ((*rover->topheight - l) + texturevpeg) * glTex->scaleY;
-						wallVerts[1].t = ((*rover->topheight - lS) + texturevpeg) * glTex->scaleY;
+						wallVerts[3].t = static_cast<float>((*rover->topheight - h) + texturevpeg) * glTex->scaleY;
+						wallVerts[2].t = static_cast<float>((*rover->topheight - hS) + texturevpeg) * glTex->scaleY;
+						wallVerts[0].t = static_cast<float>((*rover->topheight - l) + texturevpeg) * glTex->scaleY;
+						wallVerts[1].t = static_cast<float>((*rover->topheight - lS) + texturevpeg) * glTex->scaleY;
 					}
 					else
 					{
 						if (!dont_peg_bottom) // skew by top
 						{
-							wallVerts[3].t = wallVerts[2].t = texturevpeg * glTex->scaleY;
-							wallVerts[0].t = ((h - l) + texturevpeg) * glTex->scaleY;
-							wallVerts[1].t = ((hS - lS) + texturevpeg) * glTex->scaleY;
+							wallVerts[3].t = wallVerts[2].t = (static_cast<float>(texturevpeg) * glTex->scaleY);
+							wallVerts[0].t = static_cast<float>((h - l) + texturevpeg) * glTex->scaleY;
+							wallVerts[1].t = static_cast<float>((hS - lS) + texturevpeg) * glTex->scaleY;
 						}
 						else // skew by bottom
 						{
-							wallVerts[0].t = wallVerts[1].t = texturevpeg * glTex->scaleY;
-							wallVerts[3].t = wallVerts[0].t - (h - l) * glTex->scaleY;
-							wallVerts[2].t = wallVerts[1].t - (hS - lS) * glTex->scaleY;
+							wallVerts[0].t = wallVerts[1].t = (static_cast<float>(texturevpeg) * glTex->scaleY);
+							wallVerts[3].t = wallVerts[0].t - static_cast<float>(h - l) * glTex->scaleY;
+							wallVerts[2].t = wallVerts[1].t - static_cast<float>(hS - lS) * glTex->scaleY;
 						}
 					}
 
@@ -2048,19 +2077,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		{
 			for (rover = gl_frontsector->ffloors; rover; rover = rover->next)
 			{
-				boolean bothsides = false;
-				// Skip if it exists on both sectors.
-				ffloor_t * r2;
-				for (r2 = gl_backsector->ffloors; r2; r2 = r2->next)
-					if (rover->master == r2->master)
-					{
-						bothsides = true;
-						break;
-					}
-
-				if (bothsides)
-					continue;
-
 				const ffloortype_e roverflags = rover->flags;
 
 				if (!(roverflags & FF_EXISTS) || !(roverflags & FF_RENDERSIDES) || !(roverflags & FF_ALLSIDES))
@@ -2072,6 +2088,44 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				if ((high1 < lowcut || highslope1 < lowcutslope) || (low1 > highcut || lowslope1 > highcutslope))
 					continue;
 
+				ffloor_t * r2;
+				for (r2 = gl_backsector->ffloors; r2; r2 = r2->next)
+				{
+					if (r2->master == rover->master) // Skip if same control line.
+						break;
+
+					const ffloortype_e r2flags = r2->flags;
+
+					if (!(r2flags & FF_EXISTS) || !(r2flags & FF_RENDERSIDES))
+						continue;
+
+					if (rover->flags & FF_EXTRA)
+					{
+						if (!(r2flags & FF_CUTEXTRA))
+							continue;
+
+						if (r2flags & FF_EXTRA && (r2flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG)))
+							continue;
+					}
+					else
+					{
+						if (!(r2flags & FF_CUTSOLIDS))
+							continue;
+					}
+
+					SLOPEPARAMS(*r2->t_slope, high2, highslope2, *r2->topheight)
+					SLOPEPARAMS(*r2->b_slope, low2,  lowslope2,  *r2->bottomheight)
+
+					if ((high2 < lowcut || highslope2 < lowcutslope) || (low2 > highcut || lowslope2 > highcutslope))
+						continue;
+					if ((high1 > high2 || highslope1 > highslope2) || (low1 < low2 || lowslope1 < lowslope2))
+						continue;
+
+					break;
+				}
+				if (r2)
+					continue;
+
 				side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);
 
 				boolean do_texture_skew;
@@ -2138,24 +2192,24 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 						if (dont_peg_bottom)
 							texturevpeg -= (*rover->topheight - *rover->bottomheight);
 
-						wallVerts[3].t = ((*rover->topheight - h) + texturevpeg) * glTex->scaleY;
-						wallVerts[2].t = ((*rover->topheight - hS) + texturevpeg) * glTex->scaleY;
-						wallVerts[0].t = ((*rover->topheight - l) + texturevpeg) * glTex->scaleY;
-						wallVerts[1].t = ((*rover->topheight - lS) + texturevpeg) * glTex->scaleY;
+						wallVerts[3].t = static_cast<float>((*rover->topheight - h) + texturevpeg) * glTex->scaleY;
+						wallVerts[2].t = static_cast<float>((*rover->topheight - hS) + texturevpeg) * glTex->scaleY;
+						wallVerts[0].t = static_cast<float>((*rover->topheight - l) + texturevpeg) * glTex->scaleY;
+						wallVerts[1].t = static_cast<float>((*rover->topheight - lS) + texturevpeg) * glTex->scaleY;
 					}
 					else
 					{
 						if (!dont_peg_bottom) // skew by top
 						{
-							wallVerts[3].t = wallVerts[2].t = texturevpeg * glTex->scaleY;
-							wallVerts[0].t = ((h - l) + texturevpeg) * glTex->scaleY;
-							wallVerts[1].t = ((hS - lS) + texturevpeg) * glTex->scaleY;
+							wallVerts[3].t = wallVerts[2].t = (static_cast<float>(texturevpeg) * glTex->scaleY);
+							wallVerts[0].t = static_cast<float>((h - l) + texturevpeg) * glTex->scaleY;
+							wallVerts[1].t = static_cast<float>((hS - lS) + texturevpeg) * glTex->scaleY;
 						}
 						else // skew by bottom
 						{
-							wallVerts[0].t = wallVerts[1].t = texturevpeg * glTex->scaleY;
-							wallVerts[3].t = wallVerts[0].t - (h - l) * glTex->scaleY;
-							wallVerts[2].t = wallVerts[1].t - (hS - lS) * glTex->scaleY;
+							wallVerts[0].t = wallVerts[1].t = (static_cast<float>(texturevpeg) * glTex->scaleY);
+							wallVerts[3].t = wallVerts[0].t - static_cast<float>(h - l) * glTex->scaleY;
+							wallVerts[2].t = wallVerts[1].t - static_cast<float>(hS - lS) * glTex->scaleY;
 						}
 					}
 
@@ -2496,8 +2550,10 @@ static boolean HWR_CheckBBox(const fixed_t *bspcoord)
 
 	// Find the corners of the box
 	// that define the edges from current viewpoint.
-	const INT32 boxpos = (viewx <= bspcoord[BOXLEFT] ? 0 : viewx < bspcoord[BOXRIGHT] ? 1 : 2) +
-	(viewy >= bspcoord[BOXTOP] ? 0 : viewy > bspcoord[BOXBOTTOM] ? 4 : 8);
+	const INT32 boxpos = (viewx <= bspcoord[BOXLEFT]   ? 0 :
+						  viewx <  bspcoord[BOXRIGHT]  ? 1 : 2) +
+						 (viewy >= bspcoord[BOXTOP]    ? 0 :
+						  viewy >  bspcoord[BOXBOTTOM] ? 4 : 8);
 
 	if (boxpos == 5)
 		return true;
@@ -2617,6 +2673,7 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	INT32           flatflag;
 	size_t          len;
 	float           scrollx = 0.0f, scrolly = 0.0f;
+	float           anglef  = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
 	angle_t         angle = 0;
 	FSurfaceInfo    Surf;
 	fixed_t         tempxsow, tempytow;
@@ -2638,12 +2695,14 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 		return;
 	}
 
+	const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
+
 	// Allocate plane-vertex buffer if we need to
 	if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
 	{
 		numAllocedPlaneVerts = (UINT16)nrPlaneVerts;
 		Z_Free(planeVerts);
-		Z_Malloc(numAllocedPlaneVerts * sizeof (FOutVector), PU_LEVEL, &planeVerts);
+		Z_Malloc(numAllocedPlaneVerts * sizeof(FOutVector), PU_LEVEL, &planeVerts);
 	}
 
 	height = FixedToFloat(fixedheight);
@@ -2686,72 +2745,51 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	flatxref = FixedToFloat(polysector->origVerts[0].x);
 	flatyref = FixedToFloat(polysector->origVerts[0].y);
 
-	flatxref = (float)(((fixed_t)flatxref & (~flatflag)) / fflatsize);
-	flatyref = (float)(((fixed_t)flatyref & (~flatflag)) / fflatsize);
+	flatxref = static_cast<float>(static_cast<fixed_t>(flatxref) & (~flatflag)) / fflatsize;
+	flatyref = static_cast<float>(static_cast<fixed_t>(flatyref) & (~flatflag)) / fflatsize;
 
-	// transform
-	v3d = planeVerts;
-
-	if (FOFsector != NULL)
+	if (!isceiling) // it's a floor
 	{
-		if (!isceiling) // it's a floor
-		{
-			scrollx = FixedToFloat(FOFsector->floor_xoffs)/fflatsize;
-			scrolly = FixedToFloat(FOFsector->floor_yoffs)/fflatsize;
-			angle = FOFsector->floorpic_angle>>ANGLETOFINESHIFT;
-		}
-		else // it's a ceiling
-		{
-			scrollx = FixedToFloat(FOFsector->ceiling_xoffs)/fflatsize;
-			scrolly = FixedToFloat(FOFsector->ceiling_yoffs)/fflatsize;
-			angle = FOFsector->ceilingpic_angle>>ANGLETOFINESHIFT;
-		}
+		scrollx = FixedToFloat(sec->floor_xoffs)/fflatsize;
+		scrolly = FixedToFloat(sec->floor_yoffs)/fflatsize;
+		angle = sec->floorpic_angle;
 	}
-	else if (gl_frontsector)
+	else // it's a ceiling
 	{
-		if (!isceiling) // it's a floor
-		{
-			scrollx = FixedToFloat(gl_frontsector->floor_xoffs)/fflatsize;
-			scrolly = FixedToFloat(gl_frontsector->floor_yoffs)/fflatsize;
-			angle = gl_frontsector->floorpic_angle>>ANGLETOFINESHIFT;
-		}
-		else // it's a ceiling
-		{
-			scrollx = FixedToFloat(gl_frontsector->ceiling_xoffs)/fflatsize;
-			scrolly = FixedToFloat(gl_frontsector->ceiling_yoffs)/fflatsize;
-			angle = gl_frontsector->ceilingpic_angle>>ANGLETOFINESHIFT;
-		}
+		scrollx = FixedToFloat(sec->ceiling_xoffs)/fflatsize;
+		scrolly = FixedToFloat(sec->ceiling_yoffs)/fflatsize;
+		angle = sec->ceilingpic_angle;
 	}
 
 	if (angle) // Only needs to be done if there's an altered angle
 	{
 		// This needs to be done so that it scrolls in a different direction after rotation like software
-		tempxsow = FloatToFixed(scrollx);
-		tempytow = FloatToFixed(scrolly);
-		scrollx = (FixedToFloat(FixedMul(tempxsow, FINECOSINE(angle)) - FixedMul(tempytow, FINESINE(angle))));
-		scrolly = (FixedToFloat(FixedMul(tempxsow, FINESINE(angle)) + FixedMul(tempytow, FINECOSINE(angle))));
+		tempxsow = flatxref;
+		tempytow = flatyref;
+		anglef   = ANG2RAD(InvAngle(angle));
 
 		// This needs to be done so everything aligns after rotation
 		// It would be done so that rotation is done, THEN the translation, but I couldn't get it to rotate AND scroll like software does
-		tempxsow = FloatToFixed(flatxref);
-		tempytow = FloatToFixed(flatyref);
-		flatxref = (FixedToFloat(FixedMul(tempxsow, FINECOSINE(angle)) - FixedMul(tempytow, FINESINE(angle))));
-		flatyref = (FixedToFloat(FixedMul(tempxsow, FINESINE(angle)) + FixedMul(tempytow, FINECOSINE(angle))));
+		cosangf = cosf(anglef);
+		sinangf = sinf(anglef);
+		flatxref = (tempxsow * cosangf) - (tempytow * sinangf);
+		flatyref = (tempxsow * sinangf) + (tempytow * cosangf);
 	}
 
-	for (i = 0; i < (INT32)nrPlaneVerts; i++,v3d++)
+	for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++, v3d++)
 	{
-		// Hurdler: add scrolling texture on floor/ceiling
-		v3d->s = (float)((FixedToFloat(polysector->origVerts[i].x) / fflatsize) - flatxref + scrollx); // Go from the polysector's original vertex locations
-		v3d->t = (float)(flatyref - (FixedToFloat(polysector->origVerts[i].y) / fflatsize) + scrolly); // Means the flat is offset based on the original vertex locations
+		// Go from the polysector's original vertex locations
+		// Means the flat is offset based on the original vertex locations
+		v3d->s = ((FixedToFloat(polysector->origVerts[i].x) / fflatsize) - flatxref + scrollx);
+		v3d->t = (flatyref - (FixedToFloat(polysector->origVerts[i].y) / fflatsize) + scrolly);
 
 		// Need to rotate before translate
 		if (angle) // Only needs to be done if there's an altered angle
 		{
-			tempxsow = FloatToFixed(v3d->s);
-			tempytow = FloatToFixed(v3d->t);
-			v3d->s = (FixedToFloat(FixedMul(tempxsow, FINECOSINE(angle)) - FixedMul(tempytow, FINESINE(angle))));
-			v3d->t = (FixedToFloat(-FixedMul(tempxsow, FINESINE(angle)) - FixedMul(tempytow, FINECOSINE(angle))));
+			tempxsow = v3d->s;
+			tempytow = v3d->t;
+			v3d->s = (tempxsow * cosangf) - (tempytow * sinangf);
+			v3d->t = (tempxsow * sinangf) + (tempytow * cosangf);
 		}
 
 		v3d->x = FixedToFloat(polysector->vertices[i]->x);
@@ -2906,7 +2944,7 @@ static void HWR_Subsector(size_t num)
 	static sector_t tempsec; //SoM: 4/7/2000
 	INT32 floorlightlevel;
 	INT32 ceilinglightlevel;
-	INT32 locFloorHeight, locCeilingHeight;
+	INT32 locFloorHeight = 0, locCeilingHeight = 0;
 	INT32 cullFloorHeight, cullCeilingHeight;
 	INT32 light = 0;
 	extracolormap_t *floorcolormap;
@@ -2952,11 +2990,12 @@ static void HWR_Subsector(size_t num)
 
 	cullFloorHeight   = P_GetSectorFloorZAt  (gl_frontsector, viewx, viewy);
 	cullCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, viewx, viewy);
-	locFloorHeight    = P_GetSectorFloorZAt  (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
-	locCeilingHeight  = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
 
 	if (gl_frontsector->ffloors)
 	{
+		locFloorHeight    = P_GetSectorFloorZAt  (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
+		locCeilingHeight  = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
+
 		boolean anyMoved = gl_frontsector->moved;
 
 		if (anyMoved == false)
@@ -3011,8 +3050,7 @@ static void HWR_Subsector(size_t num)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false));
 				HWR_RenderPlane(sub, &extrasubsectors[num], false,
-					// Hack to make things continue to work around slopes.
-					locFloorHeight == cullFloorHeight ? locFloorHeight : gl_frontsector->floorheight,
+					gl_frontsector->floorheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap);
 			}
@@ -3027,8 +3065,7 @@ static void HWR_Subsector(size_t num)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true));
 				HWR_RenderPlane(sub, &extrasubsectors[num], true,
-					// Hack to make things continue to work around slopes.
-					locCeilingHeight == cullCeilingHeight ? locCeilingHeight : gl_frontsector->ceilingheight,
+					gl_frontsector->ceilingheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap);
 			}
@@ -3458,13 +3495,13 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 	if (spr->mobj && fabsf(this_scale - 1.0f) > 1.0E-36f)
 	{
 		// Always a pixel above the floor, perfectly flat.
-		swallVerts[0].y = swallVerts[1].y = swallVerts[2].y = swallVerts[3].y = spr->gzt - gpatch->topoffset * this_scale - (floorheight+3);
+		swallVerts[0].y = swallVerts[1].y = swallVerts[2].y = swallVerts[3].y = spr->gzt - static_cast<float>(gpatch->topoffset) * this_scale - static_cast<float>(floorheight+3);
 
 		// Now transform the TOP vertices along the floor in the direction of the camera
-		swallVerts[3].x = spr->x1 + ((gpatch->height * this_scale) + offset) * gl_viewcos;
-		swallVerts[2].x = spr->x2 + ((gpatch->height * this_scale) + offset) * gl_viewcos;
-		swallVerts[3].z = spr->z1 + ((gpatch->height * this_scale) + offset) * gl_viewsin;
-		swallVerts[2].z = spr->z2 + ((gpatch->height * this_scale) + offset) * gl_viewsin;
+		swallVerts[3].x = spr->x1 + ((static_cast<float>(gpatch->height) * this_scale) + offset) * gl_viewcos;
+		swallVerts[2].x = spr->x2 + ((static_cast<float>(gpatch->height) * this_scale) + offset) * gl_viewcos;
+		swallVerts[3].z = spr->z1 + ((static_cast<float>(gpatch->height) * this_scale) + offset) * gl_viewsin;
+		swallVerts[2].z = spr->z2 + ((static_cast<float>(gpatch->height) * this_scale) + offset) * gl_viewsin;
 	}
 	else
 	{
@@ -3472,10 +3509,10 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 		swallVerts[0].y = swallVerts[1].y = swallVerts[2].y = swallVerts[3].y = spr->gzt - gpatch->topoffset - (floorheight+3);
 
 		// Now transform the TOP vertices along the floor in the direction of the camera
-		swallVerts[3].x = spr->x1 + (gpatch->height + offset) * gl_viewcos;
-		swallVerts[2].x = spr->x2 + (gpatch->height + offset) * gl_viewcos;
-		swallVerts[3].z = spr->z1 + (gpatch->height + offset) * gl_viewsin;
-		swallVerts[2].z = spr->z2 + (gpatch->height + offset) * gl_viewsin;
+		swallVerts[3].x = spr->x1 + (static_cast<float>(gpatch->height) + offset) * gl_viewcos;
+		swallVerts[2].x = spr->x2 + (static_cast<float>(gpatch->height) + offset) * gl_viewcos;
+		swallVerts[3].z = spr->z1 + (static_cast<float>(gpatch->height) + offset) * gl_viewsin;
+		swallVerts[2].z = spr->z2 + (static_cast<float>(gpatch->height) + offset) * gl_viewsin;
 	}
 
 	// We also need to move the bottom ones away when shadowoffs is on
@@ -3745,8 +3782,15 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 		blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
 	}
 
-	if (cv_playerfade.value && sprmo->player)
-		Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
+	if (sprmo->player)
+	{
+		// 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 = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
+
+		if (cv_playerfade.value)
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
+	}
 
 	if (HWR_UseShader())
 	{
@@ -4035,8 +4079,15 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 		blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
 	}
 
-	if (cv_playerfade.value && sprmo->player)
-		Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
+	if (sprmo->player)
+	{
+		// 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 = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
+
+		if (cv_playerfade.value)
+			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
+	}
 
 	if (HWR_UseShader())
 	{
@@ -4406,9 +4457,6 @@ static void HWR_RenderDrawNodes(void)
 	// Okay! Let's draw it all! Woo!
 	GL_SetTransform(&atransform);
 
-	if (LIKELY(cv_glbatching.value))
-		HWR_StartBatching();
-
 	for (i = 0; i < numdrawnodes; i++)
 	{
 		gl_drawnode_t *drawnode = &drawnodes[sortindex[i]];
@@ -4462,9 +4510,6 @@ static void HWR_RenderDrawNodes(void)
 
 	PS_STOP_TIMING(ps_hw_nodedrawtime);
 
-	if (LIKELY(cv_glbatching.value))
-		HWR_RenderBatches(false);
-
 	drawnodes.clear(); // clear so our size is 0 again!
 }
 
@@ -5153,6 +5198,8 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 	z2 = tr_y - x2 * rightsin;
 	x1 = tr_x + x1 * rightcos;
 	x2 = tr_x - x2 * rightcos;
+	//y1 = tr_y + y1 * rightcos;
+	//y2 = tr_y - y2 * rightcos;
 
 	//
 	// store information in a vissprite
@@ -5331,7 +5378,7 @@ void HWR_BuildSkyDome(void)
 }
 
 // precompute to save a bit of division
-static constexpr float FINEDEGREE = (360.0f/(float)FINEANGLES);
+static constexpr float FINEDEGREE = (360.0f/static_cast<float>(FINEANGLES));
 
 static void HWR_DrawSkyBackground(void)
 {
@@ -5349,7 +5396,7 @@ static void HWR_DrawSkyBackground(void)
 	//04/01/2000: Hurdler: added for T&L
 	//                     It should replace all other gl_viewxxx when finished
 	HWR_SetTransformAiming(&dometransform);
-	dometransform.angley = (float)((viewangle-ANGLE_270)>>ANGLETOFINESHIFT)*(FINEDEGREE);
+	dometransform.angley = static_cast<float>((viewangle-ANGLE_270) >> ANGLETOFINESHIFT)*(FINEDEGREE);
 
 	HWR_GetTexture(texturetranslation[skytexture], false);
 
@@ -5394,9 +5441,9 @@ static void HWR_SetTransformAiming(FTransform *trans)
 	if (cv_glshearing.value)
 	{
 		fixed_t fixedaiming = AIMINGTODY(aimingangle);
-		trans->viewaiming = FixedToFloat(fixedaiming) * ((float)vid.width / vid.height) / ((float)BASEVIDWIDTH / BASEVIDHEIGHT);
+		trans->viewaiming = FixedToFloat(fixedaiming) * (static_cast<float>(vid.width) / static_cast<float>(vid.height)) / (static_cast<float>(BASEVIDWIDTH) / static_cast<float>(BASEVIDHEIGHT));
 		if (splitscreen == 1) // only for 2 player splitscreen
-			trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
+			trans->viewaiming *= 2.125f; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
 		trans->shearing = true;
 		gl_aimingangle = 0;
 	}
@@ -5406,7 +5453,7 @@ static void HWR_SetTransformAiming(FTransform *trans)
 		gl_aimingangle = aimingangle;
 	}
 
-	trans->anglex = (float)(gl_aimingangle>>ANGLETOFINESHIFT)*(FINEDEGREE);
+	trans->anglex = static_cast<float>(gl_aimingangle >> ANGLETOFINESHIFT)*(FINEDEGREE);
 }
 
 void HWR_SetTransform(float fpov)
@@ -5425,11 +5472,11 @@ void HWR_SetTransform(float fpov)
 	atransform.z = gl_viewz;
 
 	atransform.scalex = 1;
-	atransform.scaley = (float)vid.width/vid.height;
+	atransform.scaley = static_cast<float>(vid.width) / static_cast<float>(vid.height);
 	atransform.scalez = 1;
 
 	HWR_SetTransformAiming(&atransform);
-	atransform.angley = (float)(viewangle>>ANGLETOFINESHIFT)*(FINEDEGREE);
+	atransform.angley = static_cast<float>(viewangle >> ANGLETOFINESHIFT)*(FINEDEGREE);
 
 	yaw = 270.0f - atransform.angley;
 	inv_yaw = 180.0f - yaw;
@@ -5440,8 +5487,8 @@ void HWR_SetTransform(float fpov)
 	// only needed for sprite billboarding
 	if (cv_glspritebillboarding.value && !cv_glshearing.value)
 	{
-		gl_viewludsin = FixedToFloat(FINECOSINE(gl_aimingangle>>ANGLETOFINESHIFT));
-		gl_viewludcos = FixedToFloat(-FINESINE(gl_aimingangle>>ANGLETOFINESHIFT));
+		gl_viewludsin = FixedToFloat(FINECOSINE(gl_aimingangle >> ANGLETOFINESHIFT));
+		gl_viewludcos = FixedToFloat(-FINESINE(gl_aimingangle >> ANGLETOFINESHIFT));
 	}
 
 	atransform.fovangle = fpov; // Tails
@@ -5469,7 +5516,6 @@ void HWR_SetTransform(float fpov)
 void HWR_ClearClipper(void)
 {
 	const angle_t a1 = gld_FrustumAngle(gl_aimingangle);
-
 	gld_clipper_Clear();
 	gld_clipper_SafeAddClipRange(viewangle + a1, viewangle - a1);
 #ifdef HAVE_SPHEREFRUSTRUM
@@ -5502,7 +5548,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	player_t *viewplayer = &players[displayplayers[viewssnum]];
 	const float fpov = FixedToFloat(R_GetPlayerFov(viewplayer));
 
-	auto reset_viewstate = [&](const float fpov)
+	auto reset_viewstate = [&]()
 	{
 		HWR_SetTransform(fpov);
 		HWR_ClearSprites();
@@ -5522,7 +5568,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 			currentportallist = &portallist;
 			HWR_SetPortalState(GLPORTAL_SEARCH);
 
-			reset_viewstate(fpov);
+			reset_viewstate();
 
 			if (rootportal)
 			{
@@ -5548,13 +5594,13 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	// draw normal things in current frame in current incremented stencil buffer area
 	HWR_SetStencilState(HWR_STENCIL_NORMAL, stencil_level);
 
-	reset_viewstate(fpov);
+	reset_viewstate();
 
 	if constexpr (Type == RenderViewpointType::kPortal)
 	{
 		if (allow_portals && rootportal)
 		{
-			HWR_PortalFrame(rootportal); // for portalclipsector, it could have gone null from search
+			HWR_PortalFrame(rootportal);// for portalclipsector, it could have gone null from search
 			HWR_PortalClipping(rootportal);
 		}
 	}
@@ -5604,7 +5650,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	PS_STOP_TIMING(ps_bsptime);
 
 	if (LIKELY(cv_glbatching.value))
-		HWR_RenderBatches(true);
+		HWR_RenderBatches();
 
 	// Check for new console commands.
 	NetUpdate();
@@ -5631,15 +5677,11 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	HWR_SortVisSprites();
 	PS_STOP_TIMING(ps_hw_spritesorttime);
 	PS_START_TIMING(ps_hw_spritedrawtime);
-	if (LIKELY(cv_glbatching.value))
-		HWR_StartBatching();
 	if (UNLIKELY(cv_glmdls.value))
 		HWR_DrawSprites<DrawSpritesType::kModels>();
 	else
 		HWR_DrawSprites<DrawSpritesType::kSprites>();
 	PS_STOP_TIMING(ps_hw_spritedrawtime);
-	if (LIKELY(cv_glbatching.value))
-		HWR_RenderBatches(false);
 
 	ps_numdrawnodes.value.i    = 0;
 	ps_hw_nodesorttime.value.p = 0;
@@ -5707,7 +5749,7 @@ static void HWR_RollTransform(FTransform *tr, angle_t roll)
 {
 	if (roll != 0)
 	{
-		tr->rollangle = roll / (float)ANG1;
+		tr->rollangle = static_cast<float>(roll) / static_cast<float>(ANG1);
 		tr->roll = true;
 		tr->rollx = 1.0f;
 		tr->rollz = 0.0f;
@@ -6068,7 +6110,7 @@ static void HWR_DoPostProcessor(void)
 	const camera_t *thiscam = &camera[0];
 
 	// Not supported in splitscreen - someone want to add support?
-	const boolean screenwave = (!splitscreen && (thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT));
+	const boolean screenwave = (!splitscreen && !cv_reducevfx.value && (thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT));
 
 	// Capture the screen for intermission and screen waving
 	if ((lastdraw || screenwave) && gamestate != GS_INTERMISSION)
@@ -6107,7 +6149,7 @@ static void HWR_DoPostProcessor(void)
 			for (y = 0; y < SCREENVERTS; y++)
 			{
 				// Change X position based on its Y position.
-				v[x][y][0] = x-4.5f + sinf(((disStart+((float)y * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
+				v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
 				v[x][y][1] = y-4.5f; // (y / scale)
 			}
 		}

src/hardware/hw_md2.c

@@ -579,7 +579,7 @@ md2found:
 	fclose(f);
 }
 
-void HWR_AddPlayerMD2(int skin, boolean local) // For MD2's that were added after startup
+void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
 {
 	FILE *f;
 	char name[20], filename[32];
@@ -693,17 +693,15 @@ 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, blendcolor;
+	RGBA_t *image, *blendimage, *cur;
+	RGBA_t 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
-
-	memset(translation, 0, sizeof(translation));
-	memset(cutoff, 0, sizeof(cutoff));
+	UINT8 colorbrightnesses[17] = {};
+	UINT8 color_match_lookup[256] = {}; // optimization attempt
 
 	if (glMipmap->width == 0)
 	{
@@ -716,14 +714,10 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
 		glMipmap->format = GL_TEXFMT_RGBA;
 	}
 
-	if (glMipmap->data)
-	{
-		Z_Free(glMipmap->data);
-		glMipmap->data = NULL;
-	}
+	Z_Free(glMipmap->data);
+	glMipmap->data = NULL;
 
-	cur = Z_Malloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
-	memset(cur, 0x00, size*4);
+	cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
 
 	image = hwrPatch->mipmap->data;
 	blendimage = hwrBlendPatch->mipmap->data;
@@ -1037,7 +1031,6 @@ 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
@@ -1198,8 +1191,15 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 			Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
 		}
 
-		if (cv_playerfade.value && spr->mobj->player)
-			Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(spr->mobj), Surf.PolyColor.s.alpha);
+		if (spr->mobj->player)
+		{
+			// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
+			if (cv_reducevfx.value && spr->mobj->player->kartstuff[k_hyudorotimer] > 0)
+				Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
+
+			if (cv_playerfade.value)
+				Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(spr->mobj), Surf.PolyColor.s.alpha);
+		}
 
 		// dont forget to enabled the depth test because we can't do this like
 		// before: polygons models are not sorted
@@ -1468,4 +1468,116 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	}
 }
 
+// mostly copy paste of HWR_DrawMD2
+// very ugly but our model code kinda sucks
+void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t color, const UINT8 *colormap, fixed_t scale, INT32 frame, angle_t angle)
+{
+	patch_t *gpatch, *blendgpatch;
+	GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
+	FTransform p;
+	FSurfaceInfo Surf;
+
+	if (!md2->model)
+	{
+		char filename[64];
+		CONS_Debug(DBG_RENDER, "Loading model... (%s)\n", md2->filename);
+		sprintf(filename, "mdls/%s", md2->filename);
+		md2->model = md2_readModel(filename);
+
+		if (md2->model)
+		{
+			md2_printModelInfo(md2->model);
+			GL_CreateModelVBOs(md2->model);
+		}
+		else
+		{
+			md2->error = true;
+			return;
+		}
+	}
+
+	if (md2->model->meshes[0].numFrames > 0)
+		frame = frame % md2->model->meshes[0].numFrames;
+	else
+		frame = 0;
+
+	gpatch = (patch_t *)(md2->glpatch);
+	if (gpatch)
+		hwrPatch = ((GLPatch_t *)gpatch->hardware);
+
+	if (!gpatch || !hwrPatch ||
+	    ((!hwrPatch->mipmap->format || !hwrPatch->mipmap->downloaded) && !md2->notexturefile))
+		md2_loadTexture(md2);
+
+	gpatch = (patch_t*)(md2->glpatch);
+	if (gpatch)
+		hwrPatch = ((GLPatch_t *)gpatch->hardware);
+
+	blendgpatch = (patch_t*)(md2->blendglpatch);
+	if (blendgpatch)
+		hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
+
+	if ((gpatch && hwrPatch && hwrPatch->mipmap->format) &&
+		(!blendgpatch || !hwrBlendPatch ||
+		((!hwrBlendPatch->mipmap->format || !hwrBlendPatch->mipmap->downloaded) && !md2->noblendfile)))
+		md2_loadBlendTexture(md2);
+
+	blendgpatch = (patch_t*)(md2->blendglpatch);
+	if (blendgpatch)
+		hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
+
+	memset(&Surf, 0x00, sizeof(FSurfaceInfo));
+	Surf.PolyColor.rgba = 0xFFFFFFFF;
+	Surf.PolyFlags = PF_Occlude | PF_Modulated;
+
+	Surf.LightInfo.light_level = 255;
+	Surf.LightInfo.fade_start = 0;
+	Surf.LightInfo.fade_end = 31;
+
+	if (color != SKINCOLOR_NONE &&
+	    blendgpatch && hwrBlendPatch->mipmap->format &&
+	    gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
+	{
+		INT32 tcskinnum = TC_DEFAULT;
+
+		if (color)
+			tcskinnum = skinnum;
+
+		HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, colormap, color);
+	}
+	else if (hwrPatch && hwrPatch->mipmap->format)
+	{
+		GL_SetTexture(hwrPatch->mipmap);
+	}
+
+	memset(&p, 0x00, sizeof(FTransform));
+
+	p.x = x*vid.dup + (float)(vid.width - BASEVIDWIDTH*vid.dup)/2.f;
+	p.y = -420.f; // push it back to prevent wonky culling, idk lul
+	p.z = y*vid.dup + (float)(vid.height - BASEVIDHEIGHT*vid.dup)/2.f;
+
+	p.angley = FixedToFloat(AngleFixed(angle));
+	p.anglex = 0.f;
+	p.anglez = 0.f;
+
+	p.roll = false;
+	p.fliptype = TRANSFORM_NONE;
+
+	const float fscale = FixedToFloat(scale*vid.dup);
+
+	GL_Draw2DModel(
+			md2->model,
+			frame,
+			0.f,
+			0.f,
+			-1,
+			&p,
+			fscale,
+			fscale,
+			true, // flip it vertically lul
+			false,
+			&Surf
+		);
+}
+
 #endif //HWRENDER

src/hardware/hw_md2.h

@@ -45,6 +45,9 @@ void HWR_InitMD2(void);
 void HWR_DrawMD2(gl_vissprite_t *spr);
 void HWR_AddPlayerMD2(INT32 skin, boolean local);
 void HWR_AddSpriteMD2(size_t spritenum);
+void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum,
+					 skincolors_t color, const UINT8 *colormap,
+					 fixed_t scale, INT32 frame, angle_t angle);
 
 #ifdef __cplusplus
 } // extern "C"

src/hardware/hw_md2load.c

@@ -274,7 +274,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	if (!f)
 		return NULL;
 
-	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
+	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, NULL);
 
 	//size_t fileLen;
 
@@ -288,13 +288,13 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	{
 		texPos++;
 		namelen = strlen(texPos) + 1;
-		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
+		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, NULL);
 		strcpy(texturefilename, texPos);
 	}
 	else
 	{
 		namelen = strlen(fileName) + 1;
-		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
+		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, NULL);
 		strcpy(texturefilename, fileName);
 	}
 
@@ -316,7 +316,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	header = (md2header_t*)buffer;
 
 	retModel->numMeshes = 1; // MD2 only has one mesh
-	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, 0);
+	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, NULL);
 	retModel->meshes[0].numFrames = header->numFrames;
 	// const float WUNITS = 1.0f;
 	// float dataScale = WUNITS;
@@ -332,7 +332,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	if (retModel->numMaterials <= 0) // Always at least one skin, duh
 		retModel->numMaterials = 1;
 
-	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
+	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, NULL);
 
 	// int t;
 	for (t = 0; t < retModel->numMaterials; t++)
@@ -409,9 +409,9 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 		float *uvptr;
 
 		dataScale = 0.015624f; // 1 / 64.0f
-		retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, 0);
+		retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, NULL);
 		retModel->meshes[0].numVertices = header->numXYZ;
-		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL);
 
 		ptr = (char*)frames;
 		for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
@@ -423,12 +423,12 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 			md2vertex_t *vertex;
 
 			md2frame_t *framePtr = (md2frame_t*)ptr;
-			retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, 0);
-			retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, 0);
+			retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, NULL);
+			retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, NULL);
 
 			//			if (retModel->materials[0].lightmap)
 			//				retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
-			retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, 0);
+			retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, NULL);
 
 			vertptr = retModel->meshes[0].tinyframes[i].vertices;
 			normptr = retModel->meshes[0].tinyframes[i].normals;
@@ -484,8 +484,8 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 		char *ptr;
 
 		retModel->meshes[0].numVertices = header->numTris * 3;
-		retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, 0);
-		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+		retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, NULL);
+		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL);
 
 		trisPtr = tris;
 		uvptr = retModel->meshes[0].uvs;
@@ -507,8 +507,8 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
 			md2vertex_t *vertex;
 
 			md2frame_t *framePtr = (md2frame_t*)ptr;
-			retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
-			retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
+			retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL);
+			retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL);
 			//			if (retModel->materials[0].lightmap)
 			//				retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
 			//float *vertptr, *normptr;

src/hardware/hw_md3load.c

@@ -168,7 +168,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	if (!f)
 		return NULL;
 
-	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
+	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, NULL);
 
 	// find length of file
 	fseek(f, 0, SEEK_END);
@@ -201,7 +201,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	if (retModel->numMaterials <= 0) // Always at least one skin, duh
 		retModel->numMaterials = 1;
 
-	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
+	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, NULL);
 
 	for (t = 0; t < retModel->numMaterials; t++)
 	{
@@ -225,7 +225,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 		retModel->materials[t].spheremap = false;
 	}
 
-	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, 0);
+	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, NULL);
 
 	matCount = 0;
 	for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++)
@@ -298,9 +298,9 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 			unsigned short *indexptr;
 			md3Triangle *mdT;
 
-			retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, 0);
+			retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, NULL);
 			retModel->meshes[i].numVertices = mdS->numVerts;
-			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, 0);
+			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, NULL);
 			for (j = 0; j < mdS->numFrames; j++)
 			{
 				short *vertptr;
@@ -308,12 +308,12 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 				// char *tanptr;
 				int k;
 				md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
-				retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, 0);
-				retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, 0);
+				retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, NULL);
+				retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, NULL);
 
 //				if (retModel->materials[0].lightmap)
 //					retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag);
-				retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, 0);
+				retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, NULL);
 				vertptr = retModel->meshes[i].tinyframes[j].vertices;
 				normptr = retModel->meshes[i].tinyframes[j].normals;
 
@@ -374,16 +374,16 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 			int k;
 
 			retModel->meshes[i].numVertices = mdS->numTriangles * 3;//mdS->numVerts;
-			retModel->meshes[i].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*mdS->numFrames, ztag, 0);
-			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, 0);
+			retModel->meshes[i].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*mdS->numFrames, ztag, NULL);
+			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, NULL);
 
 			for (j = 0; j < mdS->numFrames; j++)
 			{
 				float *vertptr;
 				float *normptr;
 				md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
-				retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
-				retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
+				retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL);
+				retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL);
 //				if (retModel->materials[i].lightmap)
 //					retModel->meshes[i].frames[j].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag);
 				vertptr = retModel->meshes[i].frames[j].vertices;

src/hardware/hw_model.c

@@ -189,7 +189,7 @@ model_t *LoadModel(const char *filename, int ztag)
 		return NULL;
 	}
 
-	model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, 0);
+	model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, NULL);
 	strcpy(model->mdlFilename, filename);
 
 	Optimize(model);
@@ -237,7 +237,7 @@ void GenerateVertexNormals(model_t *model)
 		{
 			mdlframe_t *frame = &mesh->frames[j];
 			int memTag = PU_STATIC;
-			float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, 0);
+			float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, NULL);
 			int k;
 			float *vertPtr = frame->vertices;
 			float *oldNormals;
@@ -309,7 +309,7 @@ static boolean AddMaterialToList(materiallist_t **head, material_t *material)
 	}
 
 	// Didn't find it, so add to the list
-	newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, 0);
+	newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, NULL);
 	newMatNode->material = material;
 	ListAdd(newMatNode, (listitem_t**)head);
 	return true;
@@ -351,7 +351,7 @@ void Optimize(model_t *model)
 	}
 
 	memTag = PU_STATIC;
-	newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, 0);
+	newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, NULL);
 
 	i = 0;
 	for (node = matListHead; node; node = node->next)
@@ -377,14 +377,14 @@ void Optimize(model_t *model)
 		newMesh->numFrames = 1;
 		newMesh->numTriangles = numTriangles;
 		newMesh->numVertices = numTriangles * 3;
-		newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
-		newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
+		newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, NULL);
+		newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, NULL);
 		curFrame = &newMesh->frames[0];
 
 		curFrame->material = curMat;
-		curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
-		curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
-		curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, 0);
+		curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, NULL);
+		curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, NULL);
+		curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, NULL);
 
 		// Now traverse the meshes of the model, adding in
 		// vertices/normals/uvs that match the current material

src/hardware/r_opengl/r_opengl.c

@@ -98,10 +98,10 @@ static size_t textureBufferSize = 0;
 static LTListItem *LightTablesTail = NULL;
 static LTListItem *LightTablesHead = NULL;
 
-static RGBA_t screenPalette[256] = {0}; // the palette for the postprocessing step in palette rendering
+static RGBA_t screenPalette[256] = {}; // the palette for the postprocessing step in palette rendering
 static GLuint screenPaletteTex = 0; // 1D texture containing the screen palette
 static GLuint paletteLookupTex = 0; // 3D texture containing RGB -> palette index lookup table
-RGBA_t  myPaletteData[256] = {0}; // the palette for converting textures to RGBA
+RGBA_t myPaletteData[256] = {}; // the palette for converting textures to RGBA
 
 static GLint gltexformat = GL_RGB5_A1;
 GLint   screen_width     = 0;               // used by Draw2DLine()
@@ -127,9 +127,9 @@ GLuint gl_num_extensions;
 int majorGL = 0, minorGL = 0;
 
 //Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
-GLfloat modelMatrix[16] = {0};
-GLfloat projMatrix[16] = {0};
-static GLint   viewport[4];
+GLfloat modelMatrix[16] = {};
+GLfloat projMatrix[16] = {};
+static GLint viewport[4];
 
 #ifdef USE_FBO_OGL
 enum
@@ -171,7 +171,7 @@ boolean supportstencil = false;
 //			flush all of the stored textures, leaving them unavailable at times such as between levels
 //			These need to start at 0 and be set to their number, and be reset to 0 when deleted so that Intel GPUs
 //			can know when the textures aren't there, as textures are always considered resident in their virtual memory
-static GLuint screenTextures[NUMSCREENTEXTURES] = {0};
+static GLuint screenTextures[NUMSCREENTEXTURES] = {};
 
 #define byte2float(byte) (GLfloat)(byte / 255.0f)
 
@@ -404,6 +404,14 @@ static PFNglEnableClientState pglEnableClientState;
 typedef void (APIENTRY * PFNglDisableClientState) (GLenum cap);
 static PFNglDisableClientState pglDisableClientState;
 
+typedef void (APIENTRY * PFNglOrtho) (GLdouble left,
+									  GLdouble right,
+									  GLdouble bottom,
+									  GLdouble top,
+									  GLdouble nearVal,
+									  GLdouble farVal);
+static PFNglOrtho pglOrtho;
+
 /* Lighting */
 typedef void (APIENTRY * PFNglShadeModel) (GLenum mode);
 static PFNglShadeModel pglShadeModel;
@@ -745,7 +753,7 @@ typedef struct gl_shaderstate_s
 static gl_shaderstate_t gl_shaderstate;
 
 // Shader info
-static float shader_leveltime = 0;
+static float shader_leveltime = 0.0f;
 static float shader_light_x = 0.0f;
 static float shader_light_y = 0.0f;
 static float shader_light_z = 0.0f;
@@ -858,6 +866,8 @@ void SetupGLFunc4(void)
 	GetGLfunc(glUniform3fv);
 	GetGLfunc(glGetUniformLocation);
 
+	GetGLfunc(glOrtho);
+
 #ifdef GLDEBUGMESSAGE
 	GetGLfunc(glDebugMessageCallback);
 #endif
@@ -2209,16 +2219,10 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG
 			UNIFORM_1(shader->uniforms[gluniform_light_contrast], shader_light_contrast, pglUniform1f);
 			UNIFORM_1(shader->uniforms[gluniform_light_backlight], shader_light_backlight, pglUniform1f);
 		}
-		else
-		{
-			UNIFORM_3(shader->uniforms[gluniform_light_dir], 0, 0, 0, pglUniform3f);
-			UNIFORM_1(shader->uniforms[gluniform_light_contrast], 0, pglUniform1f);
-			UNIFORM_1(shader->uniforms[gluniform_light_backlight], 0, pglUniform1f);
-		}
 
 		UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f);
 
-		UNIFORM_2(shader->uniforms[gluniform_scr_resolution], vid.width, vid.height, pglUniform2f);
+		UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)vid.width, (GLfloat)vid.height, pglUniform2f);
 
 		#undef UNIFORM_1
 		#undef UNIFORM_2
@@ -3096,6 +3100,39 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
 	pglDisable(GL_NORMALIZE);
 }
 
+void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
+                      FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface)
+{
+	// save our matrix´s
+	pglMatrixMode(GL_PROJECTION);
+	pglPushMatrix();
+	pglMatrixMode(GL_MODELVIEW);
+	pglPushMatrix();
+
+	pglMatrixMode(GL_PROJECTION);
+	pglLoadIdentity();
+
+	// switch to ortho mode to make our lives easier
+	// thisll make sure our coords will be remapped to pixel coords
+	pglOrtho(0.0f, (float)vid.width, (float)vid.height, 0.0f, NZCLIP_PLANE, FAR_ZCLIP_DEFAULT);
+
+	pglMatrixMode(GL_MODELVIEW);
+	pglLoadIdentity();
+
+	pglEnable(GL_DEPTH_TEST);
+	pglDepthMask(GL_TRUE);
+	pglClear(GL_DEPTH_BUFFER_BIT);
+
+	GL_DrawModelEx(model, frameIndex, duration, tics, nextFrameIndex,
+	               pos, hscale, vscale, flipped, hflipped, Surface);
+
+	// restore the matrix´s
+	pglMatrixMode(GL_PROJECTION);
+	pglPopMatrix();
+	pglMatrixMode(GL_MODELVIEW);
+	pglPopMatrix();
+}
+
 // -----------------+
 // SetTransform     :
 // -----------------+
@@ -3554,22 +3591,30 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 		 1.0f, -1.0f, 1.0f
 	};
 
-	xfix = 1/((float)screen_texsizew/(float)screen_width);
-	yfix = 1/((float)screen_texsizeh/(float)screen_height);
-
 	const GLfloat scrwf = (float)screen_width;
 	const GLfloat scrwh = (float)screen_height;
 
+	xfix = 1/((float)screen_texsizew/scrwf);
+	yfix = 1/((float)screen_texsizeh/scrwh);
+
+	GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
+
 	// Slight fuzziness
 	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
 	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
-	const float stride = 2.f/scrwh;
+	uint32_t r = rand();
 
-	for (i = 0; i < 1; i += stride)
+	const float ystep = 2.f/scrwh * (float)vid.udup/4.f;
+
+	for (i = 0; i < 1; i += ystep)
 	{
-		fix[2] = (float)(rand() % 128) / -22000.f * xfix;
+		// avoid calling rand thousands of times
+		r ^= r >> 13;
+		r ^= r >> 11;
+		r ^= r << 21;
+
+		fix[2] = (float)(r & 127) / -22000.f * xfix;
 		fix[0] = fix[2];
 		fix[6] = fix[0] + xfix;
 		fix[4] = fix[2] + xfix;
@@ -3587,8 +3632,8 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 	}
 
 	// Upward bar
-	//GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	//pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
+	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
+	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
 	color[0] = color[1] = color[2] = 190;
 	color[3] = 250;
@@ -3611,13 +3656,14 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 
 	fix[1] = fix[7] += (fix[3] - fix[7])*2;
 	screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
+
 	pglTexCoordPointer(2, GL_FLOAT, 0, fix);
 	pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 	// Downward bar
-	//GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	//pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
+	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
+	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
 	fix[0] = 0.0f;
 	fix[6] = xfix;
@@ -3636,6 +3682,7 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 
 	fix[1] = fix[7] += (fix[3] - fix[7])*2;
 	screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
+
 	pglTexCoordPointer(2, GL_FLOAT, 0, fix);
 	pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
@@ -3675,7 +3722,7 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
 {
 	float xfix, yfix;
 	float origaspect, newaspect;
-	float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen
+	float xoff = 1.0f, yoff = 1.0f; // xoffset and yoffset for the polygon to have black bars around the screen
 
 	static float off[12] =
 	{
@@ -3698,19 +3745,19 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
 	if (origaspect < newaspect)
 	{
 		xoff = origaspect / newaspect;
-		yoff = 1;
+		yoff = 1.0f;
 	}
 	else if (origaspect > newaspect)
 	{
-		xoff = 1;
+		xoff = 1.0f;
 		yoff = newaspect / origaspect;
 	}
 
 	// float off[12];
 	off[0] = off[3]  = -xoff;
 	off[1] = off[10] = -yoff;
-	off[4] = off[7]  = yoff;
-	off[6] = off[9]  = xoff;
+	off[4] = off[7]  =  yoff;
+	off[6] = off[9]  =  xoff;
 
 	// float fix[8];
 	fix[3] = fix[5] = yfix;

src/hardware/r_opengl/r_opengl.h

@@ -27,7 +27,7 @@ extern "C" {
 #ifdef HAVE_SDL
 #define _MATH_DEFINES_DEFINED
 
-#include <SDL3/SDL_opengl.h> //Alam_GBC: Simple, yes?
+#include "SDL_opengl.h" //Alam_GBC: Simple, yes?
 
 #else
 #include <GL/gl.h>

src/http-mserv.c

@@ -189,7 +189,7 @@ HMS_connect (const char *format, ...)
 	seek = strlen(hms_api) + 1;/* + '/' */
 
 	va_start (ap, format);
-	url = malloc(seek + vsnprintf(0, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
+	url = malloc(seek + vsnprintf(NULL, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
 	va_end (ap);
 
 	sprintf(url, "%s/", hms_api);
@@ -225,9 +225,10 @@ 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())
@@ -471,8 +472,8 @@ HMS_fetch_servers (msg_server_t *list, int query_id)
 			*end = '\0';
 
 			address = strtok(p, " ");
-			port    = strtok(0, " ");
-			contact = strtok(0, "");
+			port    = strtok(NULL, " ");
+			contact = strtok(NULL, "");
 
 			if (address && port)
 			{
@@ -539,7 +540,7 @@ HMS_compare_mod_version (char *buffer, size_t buffer_size)
 	if (HMS_do(hms))
 	{
 		version      = strtok(hms->buffer, " ");
-		version_name = strtok(0, "\n");
+		version_name = strtok(NULL, "\n");
 
 		if (version && version_name)
 		{

src/hu_stuff.c

@@ -497,7 +497,9 @@ 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)
@@ -516,6 +518,7 @@ static void Chatlogsize_OnChange(void)
 	if (new_chat_log == NULL)
 	{
         free(chat_log);
+		chat_log = NULL;
 		return;
 	}
 	chat_log = new_chat_log;
@@ -1072,8 +1075,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 
 		HU_AddChatText(va(fmt2, prefix, cstart, dispname, textcolor, msg), cv_chatnotifications.value); // add to chat
 
-		if (tempchar)
-			Z_Free(tempchar);
+		Z_Free(tempchar);
 	}
 #ifdef _DEBUG
 	// I just want to point out while I'm here that because the data is still
@@ -1484,6 +1486,7 @@ static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 			x = 0;
 		}
 	}
+
 	return newstring;
 }
 
@@ -1522,7 +1525,7 @@ static void HU_drawMiniChat(void)
 		emote_t *emote = NULL;
 		int emotelen = 0;
 
-		while(msg[j]) // iterate through msg
+		while (msg[j]) // iterate through msg
 		{
 			if (msg[j] < HU_FONTSTART) // don't draw
 			{
@@ -1554,19 +1557,21 @@ static void HU_drawMiniChat(void)
 			{
 				j++;
 			}
+
 			prev_linereturn = false;
 			dx += charwidth;
+
 			if (dx >= boxw)
 			{
 				dx = 0;
 				linescount += 1;
 			}
 		}
+
 		dy = 0;
 		dx = 0;
 		msglines += linescount+1;
-		if (msg)
-			Z_Free(msg);
+		Z_Free(msg);
 	}
 
 	y = chaty - charheight*(msglines+1);
@@ -1598,7 +1603,7 @@ static void HU_drawMiniChat(void)
 		emote_t *emote = NULL;
 		int emotelen = 0;
 
-		while(msg[j]) // iterate through msg
+		while (msg[j]) // iterate through msg
 		{
 			if (msg[j] < HU_FONTSTART) // don't draw
 			{
@@ -1643,16 +1648,17 @@ static void HU_drawMiniChat(void)
 
 			dx += charwidth;
 			prev_linereturn = false;
+
 			if (dx >= boxw)
 			{
 				dx = 0;
 				dy += charheight;
 			}
 		}
+
 		dy += charheight;
 		dx = 0;
-		if (msg)
-			Z_Free(msg);
+		Z_Free(msg);
 	}
 
 	// decrement addy and make that shit smooth:
@@ -1704,7 +1710,7 @@ static void HU_drawChatLog(INT32 offset)
 
 	V_DrawFillConsoleMap(chatx, chat_topy, boxw, boxh*charheight +2, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT); // log box
 
-	for (i=0; i<chat_nummsg_log; i++) // iterate through our chatlog
+	for (i = 0; i < chat_nummsg_log; i++) // iterate through our chatlog
 	{
 		INT32 clrflag = 0;
 		INT32 j = 0;
@@ -1713,7 +1719,7 @@ static void HU_drawChatLog(INT32 offset)
 		emote_t *emote = NULL;
 		int emotelen = 0;
 
-		while(msg[j]) // iterate through msg
+		while (msg[j]) // iterate through msg
 		{
 			if (msg[j] < HU_FONTSTART) // don't draw
 			{
@@ -1738,7 +1744,7 @@ static void HU_drawChatLog(INT32 offset)
 			{
 				if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
 				{
-					M_DrawEmote(x+dx+2, y+dy, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+					M_DrawEmote(x+dx+2, y+dy+1, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
 					dx += EMOTEWIDTH - charwidth;
 				}
 				j += emotelen;
@@ -1758,10 +1764,10 @@ static void HU_drawChatLog(INT32 offset)
 				dy += charheight;
 			}
 		}
+
 		dy += charheight;
 		dx = 0;
-		if (msg)
-			Z_Free(msg);
+		Z_Free(msg);
 	}
 
 	if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime)) // was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.

src/i_net.h

@@ -80,6 +80,8 @@ typedef struct
 
 #define DOOMCOM_DATA(d) (doomdata_t *)&(d)->data
 
+extern doomcom_t *doomcom;
+
 #ifdef HOLEPUNCH
 typedef struct
 {
@@ -91,8 +93,6 @@ typedef struct
 #define HOLEPUNCH_DATA(d) (holepunch_t *)&(d)->data
 #endif
 
-extern doomcom_t *doomcom;
-
 /**	\brief return packet in doomcom struct
 */
 extern boolean (*I_NetGet)(void);

src/i_sound.h

@@ -158,6 +158,8 @@ UINT32 I_GetSongLoopPoint(void);
 boolean I_SetSongPosition(UINT32 position);
 UINT32 I_GetSongPosition(void);
 
+void I_UpdateSongLagThreshold (void);
+
 /// ------------------------
 //  MUSIC PLAYBACK
 /// ------------------------

src/i_system.h

@@ -29,6 +29,10 @@ extern "C" {
 */
 #define MAX_QUIT_FUNCS     16
 
+void I_GetConsoleEvents(void);
+
+extern boolean consolevent;
+extern boolean framebuffer;
 
 /**	\brief Graphic system had started up
 */

src/i_tcp.c

@@ -568,13 +568,12 @@ void Command_Numnodes(void)
 
 #ifdef HOLEPUNCH
 /* not one of the reserved "local" addresses */
-static boolean
-is_external_address (UINT32 p)
+static boolean is_external_address(UINT32 p)
 {
 	UINT8 a = (p & 255);
 	UINT8 b = ((p >> 8) & 255);
 
-	if (p == (UINT32)~0)/* 255.255.255.255 */
+	if (p == (UINT32)~0) /* 255.255.255.255 */
 		return 0;
 
 	switch (a)
@@ -584,7 +583,7 @@ is_external_address (UINT32 p)
 		case 127:
 			return false;
 		case 172:
-			return (b & ~15) != 16;/* 16 - 31 */
+			return (b & ~15) != 16; /* 16 - 31 */
 		case 192:
 			return b != 168;
 		default:
@@ -763,6 +762,7 @@ static void SOCK_Send(void)
 				if (myfamily[i] == broadcastaddress[j].any.sa_family)
 				{
 					c = SOCK_SendToAddr(mysockets[i], &broadcastaddress[j]);
+
 					if (c == ERRSOCKET)
 					{
 						e = errno;
@@ -780,6 +780,7 @@ static void SOCK_Send(void)
 			if (myfamily[i] == clientaddress[doomcom->remotenode].any.sa_family)
 			{
 				c = SOCK_SendToAddr(mysockets[i], &clientaddress[doomcom->remotenode]);
+
 				if (c == ERRSOCKET)
 				{
 					e = errno;
@@ -792,6 +793,7 @@ static void SOCK_Send(void)
 	else
 	{
 		c = SOCK_SendToAddr(nodesocket[doomcom->remotenode], &clientaddress[doomcom->remotenode]);
+
 		if (c == ERRSOCKET)
 		{
 			e = errno;
@@ -1060,7 +1062,6 @@ static boolean UDP_Socket(void)
 #endif
 	const char *serv;
 
-
 	for (s = 0; s < mysocketses; s++)
 		mysockets[s] = ERRSOCKET;
 	for (s = 0; s < MAXNETNODES+1; s++)
@@ -1509,11 +1510,8 @@ static boolean SOCK_SetBanUsername(const char *username)
 		username = "Direct IP ban";
 	}
 
-	if (banned[numbans - 1].username)
-	{
-		Z_Free(banned[numbans - 1].username);
-		banned[numbans - 1].username = NULL;
-	}
+	Z_Free(banned[numbans - 1].username);
+	banned[numbans - 1].username = NULL;
 
 	banned[numbans - 1].username = Z_StrDup(username);
 
@@ -1527,11 +1525,8 @@ static boolean SOCK_SetBanReason(const char *reason)
 		reason = "No reason given";
 	}
 
-	if (banned[numbans - 1].reason)
-	{
-		Z_Free(banned[numbans - 1].reason);
-		banned[numbans - 1].reason = NULL;
-	}
+	Z_Free(banned[numbans - 1].reason);
+	banned[numbans - 1].reason = NULL;
 
 	banned[numbans - 1].reason = Z_StrDup(reason);
 

src/i_time.c

@@ -21,7 +21,7 @@
 #include "m_fixed.h"
 #include "i_system.h"
 
-timestate_t g_time;
+timestate_t g_time = {};
 
 static CV_PossibleValue_t timescale_cons_t[] = {{FRACUNIT/20, "MIN"}, {20*FRACUNIT, "MAX"}, {0, NULL}};
 consvar_t cv_timescale = {"timescale", "1.0", CV_NETVAR|CV_CHEAT|CV_FLOAT, timescale_cons_t, NULL, FRACUNIT, NULL, NULL, 0, 0, NULL};

src/i_video.h

@@ -95,7 +95,6 @@ INT32 VID_SetMode(INT32 modenum);
 */
 const char *VID_GetModeName(INT32 modenum);
 
-void VID_RefreshModeList(void);
 void VID_PrepareModeList(void);
 
 /**	\brief can video system do fullscreen
@@ -122,13 +121,10 @@ void I_ReadScreen(UINT8 * restrict scr, INT32 scale);
 
 UINT32 I_GetRefreshRate(void);
 
-boolean I_CheckAboveDesktopRes(INT32 width, INT32 height);
 boolean I_CheckNativeRes(void);
 
 void I_SetBorderlessWindow(void);
 
-void I_HandleControllerHatRepeat(void);
-
 #ifdef USE_FBO_OGL
 
 void RefreshOGLSDLSurface(void);
@@ -137,6 +133,15 @@ boolean UseScreenFBO(void);
 extern boolean downsample;
 #endif
 
+// So we can call this from i_video event loop
+void I_ShutdownJoystick(UINT8 index);
+
+// Quick thing to make SDL_JOYDEVICEADDED events less of an abomination
+void I_UpdateJoystickDeviceIndex(UINT8 player);
+void I_UpdateJoystickDeviceIndices(UINT8 excludePlayer);
+
+void I_HandleControllerHatRepeat(void);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/info.h

@@ -19,6 +19,8 @@
 #include "sounds.h"
 #include "m_fixed.h"
 
+#define MAXDOOMEDNUM 4095
+
 // dehacked.c now has lists for the more named enums! PLEASE keep them up to date!
 // For great modding!!
 

src/k_hud.c

@@ -568,7 +568,7 @@ static patch_t *kp_racefinish[6];
 static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES];
 static patch_t *kp_winnernum[NUMPOSFRAMES];
 
-static patch_t *kp_facenum[MAXPLAYERS+1];
+patch_t *kp_facenum[MAXPLAYERS+1] = {};
 static patch_t *kp_facehighlight[8];
 
 static patch_t *kp_rankbumper;
@@ -1065,7 +1065,7 @@ static void K_initKartHUD(void)
 	}
 
 	if (timeinmap > 113 || forceshowhud)
-		hudtrans = cv_translucenthud.value;
+		hudtrans = (UINT8)cv_translucenthud.value;
 	else if (timeinmap > 105)
 		hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105);
 	else
@@ -1122,9 +1122,9 @@ void K_KartPlayerHUDUpdate(player_t *player)
 UINT8 K_GetHudColor(void)
 {
 	if (cv_colorizedhud.value && cv_colorizedhudcolor.value)
-		return cv_colorizedhudcolor.value;
+		return (UINT8)cv_colorizedhudcolor.value;
 
-	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value);
+	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : (UINT8)cv_playercolor.value);
 }
 
 boolean K_UseColorHud(void)
@@ -1415,8 +1415,6 @@ static void K_drawKartStats(void)
 				break;
 		}
 	}
-	else
-		spdoffset = 0;
 
 	if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
 		spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
@@ -1526,7 +1524,7 @@ static void K_drawKartItem(void)
 	{
 		localcolor = K_GetHudColor();
 
-		switch((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3)
+		switch ((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3)
 		{
 			// Each case is handled in threes, to give three frames of in-game time to see the item on the roulette
 			case 0: // Sneaker
@@ -2195,7 +2193,7 @@ static boolean K_drawKartPositionFaces(void)
 		return true;
 
 	if (!LUA_HudEnabled(hud_minirankings))
-		return false;	// Don't proceed but still return true for free play above if HUD is disabled.
+		return false; // Don't proceed but still return true for free play above if HUD is disabled.
 
 	for (j = 0; j < numplayersingame; j++)
 	{

src/k_hud.h

@@ -41,6 +41,9 @@ extern consvar_t cv_battlespeedo;
 extern consvar_t cv_multiitemicon;
 extern consvar_t cv_huditemamount;
 
+// for use in timeattack menu
+extern patch_t *kp_facenum[MAXPLAYERS+1];
+
 #define NUMSPEEDOSTUFF 8
 extern CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF];
 #define NUMDGAUGESTUFF 6

src/k_kart.c

@@ -47,6 +47,8 @@ consvar_t cv_airsparks = {"airdriftsparks", "Off", CV_SAVE, CV_OnOff, NULL, 0, N
 
 consvar_t cv_playerblendeffects = {"playerblendeffects", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+consvar_t cv_reducevfx = {"reducevfx", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 // funn-E streeetch
 static CV_PossibleValue_t stretchfactor_t[] = {{0, "MIN"}, {FRACUNIT, "MAX"}, {0, NULL}};
 consvar_t cv_gravstretch = {"gravstretch", "MIN", CV_SAVE|CV_FLOAT, stretchfactor_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -482,7 +484,8 @@ UINT8 colortranslations[MAXTRANSLATIONS][16] = {
 //
 UINT8 K_RainbowColor(void)
 {
-	return (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1)));
+	const tic_t time = cv_reducevfx.value ? (leveltime >> 3) : leveltime;
+	return (UINT8)(1 + (time % (MAXSKINCOLORS-1)));
 }
 
 // Define for getting accurate color brightness readings according to how the human eye sees them.
@@ -764,6 +767,8 @@ void K_RegisterClientKartStuff(void)
 
 	CV_RegisterVar(&cv_playerblendeffects);
 
+	CV_RegisterVar(&cv_reducevfx);
+
 	CV_RegisterVar(&cv_saltyhop);
 	CV_RegisterVar(&cv_saltyhopsfx);
 	CV_RegisterVar(&cv_saltysquish);
@@ -1475,7 +1480,6 @@ 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);
 
@@ -3103,17 +3107,18 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
 	return NULL;
 }
 
-static UINT16 K_DriftSparkColor(player_t *player, INT32 charge)
+static UINT8 K_DriftSparkColor(player_t *player, INT32 charge)
 {
-	UINT16 color = SKINCOLOR_NONE;
+	UINT8 color = SKINCOLOR_NONE;
+	const INT32 sparkval = K_GetKartDriftSparkValue(player);
 
-	if (charge >= K_GetKartDriftSparkValue(player)*4)
+	if (charge >= sparkval*4)
 	{
 		color = K_RainbowColor();
 	}
-	else if (charge >= K_GetKartDriftSparkValue(player)*2)
+	else if (charge >= sparkval*2)
 	{
-		if (charge <= (K_GetKartDriftSparkValue(player)*2)+(24*3))
+		if (charge <= (sparkval*2)+(24*3))
 			color = SKINCOLOR_RASPBERRY; // transition
 		else
 			color = SKINCOLOR_KETCHUP;
@@ -3594,6 +3599,8 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 	I_Assert(mo != NULL);
 	I_Assert(!P_MobjWasRemoved(mo));
 
+	const boolean shouldblend = (mo->player && K_PlayerEffectsShouldBlend(mo->player));
+
 	for (i = 0; i < 3; i++)
 	{
 		fixed_t newx = mo->x + mo->momx + (P_RandomRange(-rad, rad)<<FRACBITS);
@@ -3611,7 +3618,7 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 
 		sparkle->color = mo->color;
 
-		if (mo->player && K_PlayerEffectsShouldBlend(mo->player))
+		if (shouldblend)
 			sparkle->blendmode = AST_ADD;
 	}
 
@@ -5179,6 +5186,24 @@ player_t *K_FindJawzTarget(mobj_t *actor, player_t *source)
 	return wtarg;
 }
 
+static INT32 K_GetEngineClass(const player_t *player)
+{
+	INT32 speed, weight;
+
+	speed = (player->kartspeed - 1) / 3;
+	weight = (player->kartweight - 1) / 3;
+
+#define LOCKSTAT(stat) \
+	if (stat < 0) { stat = 0; } \
+	if (stat > 2) { stat = 2; }
+	LOCKSTAT(speed);
+	LOCKSTAT(weight);
+#undef LOCKSTAT
+
+	return (speed + (3*weight));
+}
+
+
 // Engine Sounds.
 static void K_UpdateEngineSounds(player_t *player, ticcmd_t *cmd)
 {
@@ -5189,7 +5214,7 @@ static void K_UpdateEngineSounds(player_t *player, ticcmd_t *cmd)
 
 	static const UINT8 dampenval = 48; // 255 * 48 = close enough to FRACUNIT/6
 
-	INT32 class, s, w; // engine class number
+	INT32 class; // engine class number
 
 	UINT8 volume = 255;
 	fixed_t volumedampen = FRACUNIT;
@@ -5225,7 +5250,7 @@ static void K_UpdateEngineSounds(player_t *player, ticcmd_t *cmd)
 		targetsnd = (((6 * cmd->forwardmove) / 25) + ((player->speed / mapobjectscale) / 5)) / 2;
 	}
 
-	if (targetsnd < 0) { targetsnd = 0; }
+	if (targetsnd < 0)  { targetsnd = 0; }
 	if (targetsnd > 12) { targetsnd = 12; }
 
 	if (player->kartstuff[k_enginesnd] < targetsnd) { player->kartstuff[k_enginesnd]++; }
@@ -5302,17 +5327,7 @@ static void K_UpdateEngineSounds(player_t *player, ticcmd_t *cmd)
 		return;
 	}
 
-	s = (player->kartspeed - 1) / 3;
-	w = (player->kartweight - 1) / 3;
-
-#define LOCKSTAT(stat) \
-	if (stat < 0) { stat = 0; } \
-	if (stat > 2) { stat = 2; }
-	LOCKSTAT(s);
-	LOCKSTAT(w);
-#undef LOCKSTAT
-
-	class = s + (3*w);
+	class = K_GetEngineClass(player);
 
 	S_StartSoundAtVolume(player->mo, (sfx_krta00 + player->kartstuff[k_enginesnd]) + (class * numsnds), volume);
 }
@@ -5731,7 +5746,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
 	K_UpdateInvincibilitySounds(player); // Also thanks, VAda!
 
 	// Plays the music during and after the starting countdown.
-	if (P_IsLocalPlayer(player))
+	if ((leveltime <= MUSICSTARTTIME) && P_IsLocalPlayer(player))
 		S_StartMapMusic();
 }
 
@@ -5911,45 +5926,33 @@ static void K_KartDrift(player_t *player, boolean onground)
 	// Holding the Jump button will enable drifting.
 
 	// Drift Release (Moved here so you can't "chain" drifts)
-	if ((player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
-		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& player->kartstuff[k_driftcharge] < dsone
-		&& onground)
+	if (onground && player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
 	{
-		player->kartstuff[k_driftcharge] = 0;
-	}
-	else if ((player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
-		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& (player->kartstuff[k_driftcharge] >= dsone && player->kartstuff[k_driftcharge] < dstwo)
-		&& onground)
-	{
-		if (player->kartstuff[k_driftboost] < 20)
-			player->kartstuff[k_driftboost] = 20;
-		S_StartSound(player->mo, sfx_s23c);
-		//K_SpawnDashDustRelease(player);
-		player->kartstuff[k_driftcharge] = 0;
-	}
-	else if ((player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
-		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& player->kartstuff[k_driftcharge] < dsthree
-		&& onground)
-	{
-		if (player->kartstuff[k_driftboost] < 50)
-			player->kartstuff[k_driftboost] = 50;
-		S_StartSound(player->mo, sfx_s23c);
-		//K_SpawnDashDustRelease(player);
-		player->kartstuff[k_driftcharge] = 0;
-	}
-	else if ((player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
-		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& player->kartstuff[k_driftcharge] >= dsthree
-		&& onground)
-	{
-		if (player->kartstuff[k_driftboost] < 125)
-			player->kartstuff[k_driftboost] = 125;
-		S_StartSound(player->mo, sfx_s23c);
-		//K_SpawnDashDustRelease(player);
-		player->kartstuff[k_driftcharge] = 0;
+		if (player->kartstuff[k_driftcharge] < dsone)
+		{
+			player->kartstuff[k_driftcharge] = 0;
+		}
+		else if (player->kartstuff[k_driftcharge] >= dsone && player->kartstuff[k_driftcharge] < dstwo)
+		{
+			if (player->kartstuff[k_driftboost] < 20)
+				player->kartstuff[k_driftboost] = 20;
+			S_StartSound(player->mo, sfx_s23c);
+			player->kartstuff[k_driftcharge] = 0;
+		}
+		else if (player->kartstuff[k_driftcharge] < dsthree)
+		{
+			if (player->kartstuff[k_driftboost] < 50)
+				player->kartstuff[k_driftboost] = 50;
+			S_StartSound(player->mo, sfx_s23c);
+			player->kartstuff[k_driftcharge] = 0;
+		}
+		else if (player->kartstuff[k_driftcharge] >= dsthree)
+		{
+			if (player->kartstuff[k_driftboost] < 125)
+				player->kartstuff[k_driftboost] = 125;
+			S_StartSound(player->mo, sfx_s23c);
+			player->kartstuff[k_driftcharge] = 0;
+		}
 	}
 
 	// Drifting: left or right?
@@ -6027,8 +6030,8 @@ static void K_KartDrift(player_t *player, boolean onground)
 
 			// Sound whenever you get a different tier of sparks
 			if (driftblue
-				|| driftred
-				|| driftrainbow)
+			 || driftred
+			 || driftrainbow)
 			{
 				//S_StartSound(player->mo, sfx_s3ka2);
 				if (P_IsLocalPlayer(player)) // UGHGHGH...
@@ -6769,7 +6772,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 		{
 			if (splitscreen)
 			{
-				if (leveltime & 1)
+				if (!cv_reducevfx.value && leveltime & 1)
 					player->mo->flags2 |= MF2_DONTDRAW;
 				else
 					player->mo->flags2 &= ~MF2_DONTDRAW;
@@ -6795,7 +6798,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 				if (P_IsDisplayPlayer(player)
 					|| (!P_IsDisplayPlayer(player) && (player->kartstuff[k_hyudorotimer] < (1*TICRATE/2) || player->kartstuff[k_hyudorotimer] > hyudorotime-(1*TICRATE/2))))
 				{
-					if (leveltime & 1)
+					if (!cv_reducevfx.value && leveltime & 1)
 						player->mo->flags2 |= MF2_DONTDRAW;
 					else
 						player->mo->flags2 &= ~MF2_DONTDRAW;

src/k_stats.c

@@ -99,8 +99,7 @@ void K_EraseStats(void)
 	// The only field we want to remember
 	boolean vanilla = kartstats.vanilla;
 
-	if (kartstats.copy)
-		Z_Free(kartstats.copy);
+	Z_Free(kartstats.copy);
 
 	memset(&kartstats, 0, sizeof(kartstats_t));
 

src/lua_baselib.c

@@ -1293,6 +1293,7 @@ static int lib_pPlayRinglossSound(lua_State *L)
 	player_t *player = NULL;
 	mobj_t *damager = NULL;
 	NOHUD
+	LUA_UsageWarning(L, "P_PlayRinglossSound: using this function from lua might cause desynchs, consider using S_StartSound(origin, sfx_khurt1 + P_RandomKey(2)) as workaround");
 	if (!source)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (!lua_isnone(L, 2) && lua_isuserdata(L, 2))

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

@@ -149,7 +149,8 @@ enum cameraf {
 	camera_momx,
 	camera_momy,
 	camera_momz,
-	camera_pnum
+	camera_pnum,
+	camera_freecam,
 };
 
 
@@ -169,6 +170,7 @@ static const char *const camera_opt[] = {
 	"momy",
 	"momz",
 	"pnum",
+	"freecam",
 	NULL};
 
 enum hudpatch {
@@ -387,10 +389,43 @@ static int camera_get(lua_State *L)
 	case camera_pnum:
 		lua_pushinteger(L, camnum);
 		break;
+	case camera_freecam:
+		lua_pushboolean(L, cam->freecam);
+		break;
 	}
 	return 1;
 }
 
+static int lib_getCamera(lua_State *L)
+{
+	// No cameras on dedicated
+	if (dedicated)
+		return 0;
+
+	if (lua_type(L, 2) == LUA_TNUMBER)
+	{
+		int i = lua_tonumber(L, 2);
+
+		if (i < 0 || i > splitscreen)
+			return 0;
+
+		LUA_PushUserdata(L, &camera[i], META_CAMERA);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int lib_lenCamera(lua_State *L)
+{
+	if (dedicated)
+		lua_pushinteger(L, 0);
+	else
+		lua_pushinteger(L, splitscreen+1); // splitscreen == 0 -> 1 active camera, splitscreen == 1 -> 2 cameras and so on
+
+	return 1;
+}
+
 //
 // lib_draw
 //
@@ -1252,22 +1287,32 @@ extern int lib_hudadd(lua_State *L);
 
 static int lib_hudsetvotebackground(lua_State *L)
 {
+	// Reset to default
 	memset(VoteScreen.luaPrefix, 0, sizeof(VoteScreen.luaPrefix));
+	VoteScreen.timePerAnimFrame = 2;
 
-	if (lua_isnoneornil(L, 1))
+	if (!lua_isnoneornil(L, 1))
 	{
-		return 0;
+		const char *prefix = luaL_checkstring(L, 1);
+
+		if (strlen(prefix) != 4)
+		{
+			return luaL_argerror(L, 1, "prefix should 4 characters wide");
+		}
+
+		strncpy(VoteScreen.luaPrefix, prefix, 4);
+		strupr(VoteScreen.luaPrefix);
 	}
 
-	const char *prefix = luaL_checkstring(L, 1);
-
-	if (strlen(prefix) != 4)
+	if (!lua_isnoneornil(L, 2))
 	{
-		return luaL_argerror(L, 1, "prefix should 4 characters wide");
-	}
+		INT32 time_per_frame = luaL_checkinteger(L, 2);
 
-	strncpy(VoteScreen.luaPrefix, prefix, 4);
-	strupr(VoteScreen.luaPrefix);
+		if (time_per_frame <= 0)
+			return luaL_argerror(L, 2, "time per frame should be 1 or more");
+
+		VoteScreen.timePerAnimFrame = time_per_frame;
+	}
 
 	// Update background if we're already on vote screen
 	if (gamestate == GS_VOTING)
@@ -1371,6 +1416,16 @@ int LUA_HudLib(lua_State *L)
 		lua_setfield(L, -2, "__index");
 	lua_pop(L,1);
 
+	lua_newuserdata(L, 0);
+		lua_createtable(L, 0, 2);
+			lua_pushcfunction(L, lib_getCamera);
+			lua_setfield(L, -2, "__index");
+
+			lua_pushcfunction(L, lib_lenCamera);
+			lua_setfield(L, -2, "__len");
+		lua_setmetatable(L, -2);
+	lua_setglobal(L, "cameras");
+
 	camera_fields_ref = Lua_CreateFieldTable(L, camera_opt);
 
 	luaL_register(L, "hud", lib_hud);

src/lua_hudlib_drawlist.c

@@ -136,18 +136,9 @@ void LUA_HUD_DestroyDrawList(huddrawlist_h list)
 {
 	if (list == NULL) return;
 
-	if (list->items)
-	{
-		Z_Free(list->items);
-	}
-	if (list->olditems)
-	{
-		Z_Free(list->olditems);
-	}
-	if (list->strbuf)
-	{
-		Z_Free(list->strbuf);
-	}
+	Z_Free(list->items);
+	Z_Free(list->olditems);
+	Z_Free(list->strbuf);
 	Z_Free(list);
 }
 

src/lua_infolib.c

@@ -25,7 +25,7 @@
 #include "lua_hook.h"	// cmd errors
 
 boolean LUA_CallAction(enum actionnum actionnum, mobj_t *actor);
-state_t *astate;
+state_t *astate = NULL;
 
 boolean actionsoverridden[NUMACTIONS] = {false};
 

src/lua_mobjlib.c

@@ -475,7 +475,7 @@ int mobj_localskin_setter(lua_State *L)
 		}
 		else
 		{
-			mo->localskin = 0;
+			mo->localskin = NULL;
 			mo->skinlocal = false;
 		}
 	}

src/lua_script.c

@@ -45,20 +45,20 @@ int hook_defrosting = 0;
 
 // List of internal libraries to load from SRB2
 static lua_CFunction liblist[] = {
-	LUA_EnumLib, // global metatable for enums
-	LUA_SOCLib, // A_Action functions, freeslot
-	LUA_BaseLib, // string concatination by +, CONS_Printf, p_local.h stuff (P_InstaThrust, P_Move), etc.
-	LUA_MathLib, // fixed_t and angle_t math functions
-	LUA_HookLib, // hookAdd and hook-calling functions
-	LUA_ConsoleLib, // console command/variable functions and structs
-	LUA_InfoLib, // info.h stuff: mobjinfo_t, mobjinfo[], state_t, states[]
-	LUA_MobjLib, // mobj_t, mapthing_t
-	LUA_PlayerLib, // player_t
-	LUA_SkinLib, // skin_t, skins[]
-	LUA_ThinkerLib, // thinker_t
-	LUA_MapLib, // line_t, side_t, sector_t, subsector_t
-	LUA_BlockmapLib, // blockmap stuff
-	LUA_HudLib, // HUD stuff
+	LUA_EnumLib, 		// global metatable for enums
+	LUA_SOCLib, 		// A_Action functions, freeslot
+	LUA_BaseLib, 		// string concatination by +, CONS_Printf, p_local.h stuff (P_InstaThrust, P_Move), etc.
+	LUA_MathLib, 		// fixed_t and angle_t math functions
+	LUA_HookLib, 		// hookAdd and hook-calling functions
+	LUA_ConsoleLib, 	// console command/variable functions and structs
+	LUA_InfoLib, 		// info.h stuff: mobjinfo_t, mobjinfo[], state_t, states[]
+	LUA_MobjLib, 		// mobj_t, mapthing_t
+	LUA_PlayerLib, 		// player_t
+	LUA_SkinLib, 		// skin_t, skins[]
+	LUA_ThinkerLib, 	// thinker_t
+	LUA_MapLib, 		// line_t, side_t, sector_t, subsector_t
+	LUA_BlockmapLib, 	// blockmap stuff
+	LUA_HudLib, 		// HUD stuff
 	NULL
 };
 
@@ -66,12 +66,8 @@ static lua_CFunction liblist[] = {
 static void *LUA_Alloc(void *ud, void *ptr, size_t osize, size_t nsize)
 {
 	(void)ud;
-	if (nsize == 0) {
-		if (osize != 0)
-			Z_Free(ptr);
-		return NULL;
-	} else
-		return Z_Realloc(ptr, nsize, PU_LUA, NULL);
+	(void)osize;
+	return Z_Realloc(ptr, nsize, PU_LUA, NULL);
 }
 
 // Panic function Lua calls when there's an unprotected error.
@@ -213,7 +209,8 @@ void LUA_ClearState(void)
 	lua_setfield(L, LUA_REGISTRYINDEX, LREG_VALID);
 
 	// open srb2 libraries
-	for(i = 0; liblist[i]; i++) {
+	for (i = 0; liblist[i]; i++)
+	{
 		lua_pushcfunction(L, liblist[i]);
 		lua_call(L, 0, 0);
 	}
@@ -1064,9 +1061,13 @@ static void ArchiveTables(UINT8 **p)
 		{
 			// Write key
 			e = ArchiveValue(p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
-			if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
+			if (e == 1)
+				n++; // the table contained a new table we'll have to archive. :(
+			else if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
 			{
 				CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i);
+				lua_pop(gL, 1);
+				continue;
 			}
 			else if (e == 3) // nil key due to invalid userdata. NOT an error.
 			{
@@ -1077,15 +1078,12 @@ static void ArchiveTables(UINT8 **p)
 			// Write value
 			e = ArchiveValue(p, TABLESINDEX, -1);
 			if (e == 1)
-			{
 				n++; // the table contained a new table we'll have to archive. :(
-			}
 			else if (e == 2) // invalid value type
-			{
 				CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -2), luaL_typename(gL, -1));
-			}
 
 			lua_pop(gL, 1);
+
 		}
 		lua_pop(gL, 1);
 		WRITEUINT8(*p, ARCH_TEND);
@@ -1276,13 +1274,21 @@ static void UnArchiveTables(UINT8 **p, boolean network)
 			UINT8 ret;
 
 			ret = UnArchiveValue(p, TABLESINDEX, network);
-			if (ret == 3)
+			if (ret == 1) // End of table
+				break;
+			else if (ret == 2) // Key contains a new table
+				n++;
+			else if (ret == 3)
 			{
 				//CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
 				lua_pushnil(gL);
 			}
-			else if (ret == 1) // read key
-				break;
+
+			if (lua_isnil(gL, -1)) // If key is nil, skip this entry
+			{
+				lua_pop(gL, 1);
+				continue;
+			}
 
 			ret = UnArchiveValue(p, TABLESINDEX, network);
 			if (ret == 1)
@@ -1291,21 +1297,15 @@ static void UnArchiveTables(UINT8 **p, boolean network)
 				lua_pop(gL, 1); // Pop key
 				break;
 			}
+			else if (ret == 2) // read value
+				n++;
 			else if (ret == 3)
 			{
 				//CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
 				lua_pushnil(gL);
 			}
-			else if (ret == 2) // read value
-				n++;
 
-			if (lua_isnil(gL, -2)) // if key is nil (if a function etc was accidentally saved)
-			{
-				CONS_Alert(CONS_ERROR, "A nil key in table %d was found! (Invalid key type or corrupted save?)\n", i);
-				lua_pop(gL, 2); // pop key and value instead of setting them in the table, to prevent Lua panic errors
-			}
-			else
-				lua_rawset(gL, -3);
+			lua_rawset(gL, -3);
 		}
 
 		lua_pop(gL, 1);

src/m_anigif.c

@@ -556,7 +556,7 @@ static void GIF_framewrite(void)
 		}
 		else if (gif_dynamicdelay ==(UINT8) 1)
 		{
-			float delayf = ceil(100.0f/NEWTICRATE);
+			float delayf = ceilf(100.0f/NEWTICRATE);
 
 			delay = (UINT16)((I_GetPreciseTime() - gif_prevframetime)) / (I_GetPrecisePrecision() / 1000000) /10/1000;
 
@@ -695,16 +695,13 @@ INT32 GIF_close(void)
 	fclose(gif_out);
 	gif_out = NULL;
 
-	if (gifbwr_buf)
-		Z_Free(gifbwr_buf);
+	Z_Free(gifbwr_buf);
 	gifbwr_buf = gifbwr_cur = NULL;
 
-	if (gifframe_data)
-		Z_Free(gifframe_data);
+	Z_Free(gifframe_data);
 	gifframe_data = NULL;
 
-	if (giflzw_hashTable)
-		Z_Free(giflzw_hashTable);
+	Z_Free(giflzw_hashTable);
 	giflzw_hashTable = NULL;
 
 	Z_Free(scrbuf_screens);

src/m_cheat.c

@@ -80,7 +80,7 @@ static UINT8 cheatf_warp(void)
 	if (success)
 	{
 		G_SaveGameData(true); //G_SetGameModified(false);
-		S_StartSound(0, sfx_kc42);
+		S_StartSound(NULL, sfx_kc42);
 	}
 
 	// Refresh secrets menu existing.
@@ -117,13 +117,13 @@ static UINT8 cheatf_devmode(void)
 #endif
 
 static cheatseq_t cheat_warp = {
-	0, cheatf_warp,
+	NULL, cheatf_warp,
 	//{ SCRAMBLE('r'), SCRAMBLE('e'), SCRAMBLE('d'), SCRAMBLE('x'), SCRAMBLE('v'), SCRAMBLE('i'), 0xff }
 	{ SCRAMBLE('b'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), 0xff }
 };
 
 static cheatseq_t cheat_warp_joy = {
-	0, cheatf_warp,
+	NULL, cheatf_warp,
 	/*{ SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW),
 	  SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_UPARROW),
 	  SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW),
@@ -136,7 +136,7 @@ static cheatseq_t cheat_warp_joy = {
 
 #ifdef DEVELOP
 static cheatseq_t cheat_devmode = {
-	0, cheatf_devmode,
+	NULL, cheatf_devmode,
 	{ SCRAMBLE('d'), SCRAMBLE('e'), SCRAMBLE('v'), SCRAMBLE('m'), SCRAMBLE('o'), SCRAMBLE('d'), SCRAMBLE('e'), 0xff }
 };
 #endif
@@ -301,7 +301,7 @@ void Command_CheatNoTarget_f(void)
 void Command_Scale_f(void)
 {
 	const double scaled = atof(COM_Argv(1));
-	fixed_t scale = FLOAT_TO_FIXED(scaled);
+	fixed_t scale = DoubleToFixed(scaled);
 
 	REQUIRE_DEVMODE;
 	REQUIRE_INLEVEL;
@@ -908,7 +908,7 @@ void OP_ObjectplaceMovement(player_t *player)
 	ticcmd_t *cmd = &player->cmd;
 
 	if (!player->climbing && (netgame || (player->pflags & PF_SPINNING)))
-		player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
+		player->mo->angle = (cmd->angleturn << TICCMD_REDUCE);
 
 	ticruned++;
 	if (!(cmd->angleturn & TICCMD_RECEIVED))

src/m_cond.c

@@ -235,7 +235,7 @@ void M_AddRawCondition(UINT8 set, UINT8 id, conditiontype_t c, INT32 r, INT16 x1
 	wnum = conditionSets[set - 1].numconditions;
 	num = ++conditionSets[set - 1].numconditions;
 
-	conditionSets[set - 1].condition = Z_Realloc(conditionSets[set - 1].condition, sizeof(condition_t)*num, PU_STATIC, 0);
+	conditionSets[set - 1].condition = Z_Realloc(conditionSets[set - 1].condition, sizeof(condition_t)*num, PU_STATIC, NULL);
 
 	cond = conditionSets[set - 1].condition;
 
@@ -248,12 +248,9 @@ void M_AddRawCondition(UINT8 set, UINT8 id, conditiontype_t c, INT32 r, INT16 x1
 
 void M_ClearConditionSet(UINT8 set)
 {
-	if (conditionSets[set - 1].numconditions)
-	{
-		Z_Free(conditionSets[set - 1].condition);
-		conditionSets[set - 1].condition = NULL;
-		conditionSets[set - 1].numconditions = 0;
-	}
+	Z_Free(conditionSets[set - 1].condition);
+	conditionSets[set - 1].condition = NULL;
+	conditionSets[set - 1].numconditions = 0;
 	conditionSets[set - 1].achieved = false;
 }