Use case insensitive string hashing and compare functions for cvar hashtable

oftentimes lua scripts call CV_FindVar a fuckton of times during runtime, with many cvars this can actually tank performance more than one might think
ideally lua scripts should cache the result, but with so much stuff and servers we cant expect everyone to go through all scripts to do that
using a hashtable for CV_FindNetVar might improve join times aswell, but needs further testing to confirm

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,13 +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.
-
+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 "")

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
+	w_wad.cpp
 	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

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

src/Makefile.d/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/sdl.mk

@@ -30,7 +30,7 @@ sources+=sdl/ogl_sdl.c
 endif
 
 ifdef NOMIXER
-sources+=sdl/sdl_sound.c
+sources+=sdl/dummy_sound.c
 else
 opts+=-DHAVE_MIXER
 sources+=sdl/mixer_sound.c

src/Makefile.d/versions.mk

@@ -20,7 +20,11 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wno-trigraphs
+WFLAGS:=-Wall -Wnull-dereference
+#WFLAGS+=-Wno-trigraphs
+ifdef GCC152
+WFLAGS+=-Wzero-as-null-pointer-constant
+endif
 ifndef GCC295
 #WFLAGS+=-Wno-packed
 endif
@@ -28,7 +32,7 @@ ifndef RELAXWARNINGS
  WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
- WFLAGS+=-Wno-div-by-zero
+# WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -59,7 +63,7 @@ endif
 endif
  WFLAGS+=-Wsign-compare
 ifdef GCC91
- WFLAGS+=-Wno-error=address-of-packed-member
+# WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
  WFLAGS+=-Wlogical-op
@@ -102,14 +106,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-WFLAGS+=-Wno-error=format-overflow=2
+#WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-WFLAGS+=-Wno-suggest-attribute=noreturn
+#WFLAGS+=-Wno-suggest-attribute=noreturn
 endif
 
 ifdef NOLDWARNING
@@ -127,25 +131,27 @@ ifdef GCC44
 #WFLAGS+=-Wno-error=array-bounds
 endif
 ifdef GCC46
- WFLAGS+=-Wno-error=suggest-attribute=noreturn
+# WFLAGS+=-Wno-error=suggest-attribute=noreturn
 endif
 ifdef GCC54
- WFLAGS+=-Wno-logical-op -Wno-error=logical-op
+# WFLAGS+=-Wno-logical-op -Wno-error=logical-op
 endif
 ifdef GCC61
- WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
+# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
 endif
 ifdef GCC71
  WFLAGS+=-Wimplicit-fallthrough=4
 endif
 ifdef GCC81
- WFLAGS+=-Wno-error=format-overflow
- WFLAGS+=-Wno-format-overflow
- WFLAGS+=-Wno-error=multistatement-macros
+# WFLAGS+=-Wno-error=format-overflow
+# WFLAGS+=-Wno-format-overflow
+# WFLAGS+=-Wno-error=multistatement-macros
 endif
 
-ifeq ($(CC),clang)
- WFLAGS+= -Wno-unknown-pragmas -Wno-cast-align
+ifneq (,$(filter $(CC) $(CXX),clang clang++))
+ WFLAGS+= -Wno-unknown-pragmas
+ WFLAGS+= -Wno-cast-align
+ WFLAGS+= -Wno-cast-qual # not a fan, but clang really hates our read macros
 endif
 
 ifdef NONX86
@@ -178,6 +184,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-WFLAGS+=-Wno-logical-op
+#WFLAGS+=-Wno-logical-op
 endif
 endif

src/Sourcefile

@@ -1,3 +1,4 @@
+string.c
 am_map.c
 b_bot.c
 command.c
@@ -42,19 +43,18 @@ s_sound.c
 screen.c
 sounds.c
 st_stuff.c
-string.c
 tables.c
 v_video.c
 w_wad.c
 y_inter.c
 z_zone.cpp
-r_bsp.c
+r_bsp.cpp
 r_data.c
-r_draw.c
+r_draw.cpp
 r_fps.cpp
 r_main.cpp
 r_patch.cpp
-r_patchrotation.c
+r_patchrotation.cpp
 r_plane.cpp
 r_segs.cpp
 r_skins.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/android/i_video.c

@@ -50,25 +50,15 @@ const char *VID_GetModeName(INT32 modenum)
   return "A320x240";
 }
 
-void I_UpdateNoBlit(void){}
-
-void I_FinishUpdate(void) {
+void I_FinishUpdate(void)
+{
   LOGD("FRAME!");
   (*jni_env)->CallVoidMethod(jni_env, androidVideo, videoFrameCB);
 }
 
 void I_UpdateNoVsync(void) {}
 
-void I_WaitVBL(INT32 count)
-{
-  (void)count;
-}
-
 void I_ReadScreen(UINT8 * restrict scr, INT32 scale)
 {
   (void)scr;
 }
-
-void I_BeginRead(void){}
-
-void I_EndRead(void){}

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

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

src/blua/lauxlib.c

@@ -93,6 +93,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) :

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

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/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/byteptr.h

@@ -1,7 +1,8 @@
-// SONIC ROBO BLAST 2
+// SONIC ROBO BLAST 2 KART
 //-----------------------------------------------------------------------------
-// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2025 by Sonic Team Junior.
+// Copyright (C) 2025 by Kart Krew.
+// Copyright (C) 2020 by Sonic Team Junior.
+// Copyright (C) 2000 by DooM Legacy Team.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -24,8 +25,9 @@ extern "C" {
 //
 // Little-endian machines
 //
+
 #define WRITEUINT8(p,b)     do {   UINT8 *p_tmp = (  UINT8 *)p; const   UINT8 tv = (  UINT8)(b); memcpy(p, &tv, sizeof(  UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
-#define WRITESINT8(p,b)     do {   SINT8 *p_tmp = (  SINT8 *)p; const   SINT8 tv = (  UINT8)(b); memcpy(p, &tv, sizeof(  UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
+#define WRITESINT8(p,b)     do {   SINT8 *p_tmp = (  SINT8 *)p; const   SINT8 tv = (  SINT8)(b); memcpy(p, &tv, sizeof(  SINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
 #define WRITEINT16(p,b)     do {   INT16 *p_tmp = (  INT16 *)p; const   INT16 tv = (  INT16)(b); memcpy(p, &tv, sizeof(  INT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
 #define WRITEUINT16(p,b)    do {  UINT16 *p_tmp = ( UINT16 *)p; const  UINT16 tv = ( UINT16)(b); memcpy(p, &tv, sizeof( UINT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
 #define WRITEINT32(p,b)     do {   INT32 *p_tmp = (  INT32 *)p; const   INT32 tv = (  INT32)(b); memcpy(p, &tv, sizeof(  INT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
@@ -36,25 +38,25 @@ extern "C" {
 
 // what is this?
 #if defined (__GNUC__)
-#define READUINT8(p)        ({   UINT8 *p_tmp = (UINT8   *)p;   UINT8 b; memcpy(&b, p, sizeof(  UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READSINT8(p)        ({   SINT8 *p_tmp = (SINT8   *)p;   SINT8 b; memcpy(&b, p, sizeof(  SINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READINT16(p)        ({   INT16 *p_tmp = (INT16   *)p;   INT16 b; memcpy(&b, p, sizeof(  INT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READUINT16(p)       ({  UINT16 *p_tmp = (UINT16  *)p;  UINT16 b; memcpy(&b, p, sizeof( UINT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READINT32(p)        ({   INT32 *p_tmp = (INT32   *)p;   INT32 b; memcpy(&b, p, sizeof(  INT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READUINT32(p)       ({  UINT32 *p_tmp = (UINT32  *)p;  UINT32 b; memcpy(&b, p, sizeof( UINT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READCHAR(p)         ({    char *p_tmp = (char    *)p;    char b; memcpy(&b, p, sizeof(   char)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READFIXED(p)        ({ fixed_t *p_tmp = (fixed_t *)p; fixed_t b; memcpy(&b, p, sizeof(fixed_t)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
-#define READANGLE(p)        ({ angle_t *p_tmp = (angle_t *)p; angle_t b; memcpy(&b, p, sizeof(angle_t)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
+#define READUINT8(p)        ({   const UINT8 *p_tmp = (const UINT8   *)p;   UINT8 b; memcpy(&b, p, sizeof(  UINT8)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READSINT8(p)        ({   const SINT8 *p_tmp = (const SINT8   *)p;   SINT8 b; memcpy(&b, p, sizeof(  SINT8)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READINT16(p)        ({   const INT16 *p_tmp = (const INT16   *)p;   INT16 b; memcpy(&b, p, sizeof(  INT16)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READUINT16(p)       ({  const UINT16 *p_tmp = (const UINT16  *)p;  UINT16 b; memcpy(&b, p, sizeof( UINT16)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READINT32(p)        ({   const INT32 *p_tmp = (const INT32   *)p;   INT32 b; memcpy(&b, p, sizeof(  INT32)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READUINT32(p)       ({  const UINT32 *p_tmp = (const UINT32  *)p;  UINT32 b; memcpy(&b, p, sizeof( UINT32)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READCHAR(p)         ({    const char *p_tmp = (const char    *)p;    char b; memcpy(&b, p, sizeof(   char)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READFIXED(p)        ({ const fixed_t *p_tmp = (const fixed_t *)p; fixed_t b; memcpy(&b, p, sizeof(fixed_t)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
+#define READANGLE(p)        ({ const angle_t *p_tmp = (const angle_t *)p; angle_t b; memcpy(&b, p, sizeof(angle_t)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
 #else
-#define READUINT8(p)        ((UINT8*)(*(void**)(&(p)) = (void*)&((UINT8*)(p))[1]))[-1]
-#define READSINT8(p)        ((SINT8*)(*(void**)(&(p)) = (void*)&((SINT8*)(p))[1]))[-1]
-#define READINT16(p)        ((INT16*)(*(void**)(&(p)) = (void*)&((INT16*)(p))[1]))[-1]
-#define READUINT16(p)       ((UINT16*)(*(void**)(&(p)) = (void*)&((UINT16*)(p))[1]))[-1]
-#define READINT32(p)        ((INT32*)(*(void**)(&(p)) = (void*)&((INT32*)(p))[1]))[-1]
-#define READUINT32(p)       ((UINT32*)(*(void**)(&(p)) = (void*)&((UINT32*)(p))[1]))[-1]
-#define READCHAR(p)         ((char*)(*(void**)(&(p)) = (void*)&((char*)(p))[1]))[-1]
-#define READFIXED(p)        ((fixed_t*)(*(void**)(&(p)) = (void*)&((fixed_t*)(p))[1]))[-1]
-#define READANGLE(p)        ((angle_t*)(*(void**)(&(p)) = (void*)&((angle_t*)(p))[1]))[-1]
+#define READUINT8(p)        ((const UINT8*)  (*(const void**)(&(p)) = (const void*)&((const UINT8*)  (p))[1]))[-1]
+#define READSINT8(p)        ((const SINT8*)  (*(const void**)(&(p)) = (const void*)&((const SINT8*)  (p))[1]))[-1]
+#define READINT16(p)        ((const INT16*)  (*(const void**)(&(p)) = (const void*)&((const INT16*)  (p))[1]))[-1]
+#define READUINT16(p)       ((const UINT16*) (*(const void**)(&(p)) = (const void*)&((const UINT16*) (p))[1]))[-1]
+#define READINT32(p)        ((const INT32*)  (*(const void**)(&(p)) = (const void*)&((const INT32*)  (p))[1]))[-1]
+#define READUINT32(p)       ((const UINT32*) (*(const void**)(&(p)) = (const void*)&((const UINT32*) (p))[1]))[-1]
+#define READCHAR(p)         ((const char*)   (*(const void**)(&(p)) = (const void*)&((const char*)   (p))[1]))[-1]
+#define READFIXED(p)        ((const fixed_t*)(*(const void**)(&(p)) = (const void*)&((const fixed_t*)(p))[1]))[-1]
+#define READANGLE(p)        ((const angle_t*)(*(const void**)(&(p)) = (const void*)&((const angle_t*)(p))[1]))[-1]
 #endif
 
 #else //SRB2_BIG_ENDIAN
@@ -117,15 +119,15 @@ FUNCINLINE static ATTRINLINE UINT32 readulong(void *ptr)
 	return (ucp[3] << 24) | (ucp[2] << 16) | (ucp[1] << 8) | ucp[0];
 }
 
-#define READUINT8(p)        ((UINT8*)(p = (void*)&((UINT8*)p)[1]))[-1]
-#define READSINT8(p)        ((SINT8*)(p = (void*)&((SINT8*)p)[1]))[-1]
-#define READINT16(p)        readshort(&((INT16*)(p = (void*)&((INT16*)p)[1]))[-1])
-#define READUINT16(p)       readushort(&((UINT16*)(p = (void*)&((UINT16*)p)[1]))[-1])
-#define READINT32(p)        readlong(&((INT32*)(p = (void*)&((INT32*)p)[1]))[-1])
-#define READUINT32(p)       readulong(&((UINT32*)(p = (void*)&((UINT32*)p)[1]))
-#define READCHAR(p)         ((char*)(p = (void*)&((char*)p)[1]))[-1]
-#define READFIXED(p)        readlong(&((fixed_t*)(p = (void*)&((fixed_t*)p)[1]))[-1])
-#define READANGLE(p)        readulong(&((angle_t*)(p = (void*)&((angle_t*)p)[1]))[-1])
+#define READUINT8(p)        ((const UINT8*)(p = (const void*)&((const UINT8*)p)[1]))[-1]
+#define READSINT8(p)        ((const SINT8*)(p = (const void*)&((const SINT8*)p)[1]))[-1]
+#define READINT16(p)        readshort(&((const INT16*)(p = (const void*)&((const INT16*)p)[1]))[-1])
+#define READUINT16(p)       readushort(&((const UINT16*)(p = (const void*)&((const UINT16*)p)[1]))[-1])
+#define READINT32(p)        readlong(&((const INT32*)(p = (const void*)&((const INT32*)p)[1]))[-1])
+#define READUINT32(p)       readulong(&((const UINT32*)(p = (const void*)&((const UINT32*)p)[1]))[-1])
+#define READCHAR(p)         ((const char*)(p = (const void*)&((const char*)p)[1]))[-1]
+#define READFIXED(p)        readlong(&((const fixed_t*)(p = (const void*)&((const fixed_t*)p)[1]))[-1])
+#define READANGLE(p)        readulong(&((const angle_t*)(p = (const void*)&((const angle_t*)p)[1]))[-1])
 #endif //SRB2_BIG_ENDIAN
 
 #define WRITESTRINGN(p, s, n) do {                          \

src/command.c

@@ -57,7 +57,6 @@ static void CV_EnforceExecVersion(void);
 static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr);
 
 static boolean CV_Command(void);
-consvar_t *CV_FindVar(const char *name);
 static const char *CV_StringValue(const char *var_name);
 static consvar_t *consvar_vars; // list of registered console variables
 
@@ -142,7 +141,7 @@ void COM_BufInsertText(const char *ptext)
 	templen = com_text.cursize;
 	if (templen)
 	{
-		temp = M_Memcpy(ZZ_Alloc(templen), com_text.data, templen);
+		temp = memcpy(ZZ_Alloc(templen), com_text.data, templen);
 		VS_Clear(&com_text);
 	}
 
@@ -199,7 +198,7 @@ void COM_BufExecute(void)
 				break;
 		}
 
-		M_Memcpy(line, ptext, i);
+		memcpy(line, ptext, i);
 		line[i] = 0;
 
 		// flush the command text from the command buffer, _BEFORE_
@@ -238,10 +237,13 @@ void COM_ImmedExecute(const char *ptext)
 	char line[1024] = "";
 	INT32 quotes;
 
-	while (i < strlen(ptext))
+	const size_t txtlength = strlen(ptext);
+
+	while (i < txtlength)
 	{
 		quotes = 0;
-		for (j = 0; i < strlen(ptext); i++,j++)
+
+		for (j = 0; i < txtlength; i++,j++)
 		{
 			if (ptext[i] == '\"' && !quotes && i > 0 && ptext[i-1] != ' ') // Malformed command
 				return;
@@ -277,11 +279,11 @@ static xcommand_t *com_commands = NULL; // current commands
 
 #define MAX_ARGS 80
 static size_t com_argc;
-char *com_argv[MAX_ARGS];
+char *com_argv[MAX_ARGS] = {};
 static const char *com_null_string = "";
 static char *com_args = NULL; // current command args or NULL
 
-static void Got_NetVar(UINT8 **p, INT32 playernum);
+static void Got_NetVar(const UINT8 **p, INT32 playernum);
 
 /** Initializes command buffer and adds basic commands.
   */
@@ -653,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)
 			{
@@ -674,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);
 		}
@@ -1129,7 +1131,7 @@ void *VS_GetSpace(vsbuf_t *buf, size_t length)
   */
 void VS_Write(vsbuf_t *buf, const void *data, size_t length)
 {
-	M_Memcpy(VS_GetSpace(buf, length), data, length);
+	memcpy(VS_GetSpace(buf, length), data, length);
 }
 
 /** Prints text in a variable buffer. Like VS_Write() plus a
@@ -1146,9 +1148,9 @@ void VS_Print(vsbuf_t *buf, const char *data)
 	len = strlen(data) + 1;
 
 	if (buf->data[buf->cursize-1])
-		M_Memcpy((UINT8 *)VS_GetSpace(buf, len), data, len); // no trailing 0
+		memcpy((UINT8 *)VS_GetSpace(buf, len), data, len); // no trailing 0
 	else
-		M_Memcpy((UINT8 *)VS_GetSpace(buf, len-1) - 1, data, len); // write over trailing 0
+		memcpy((UINT8 *)VS_GetSpace(buf, len-1) - 1, data, len); // write over trailing 0
 }
 
 // =========================================================================
@@ -1163,6 +1165,39 @@ void VS_Print(vsbuf_t *buf, const char *data)
 //
 // =========================================================================
 
+#define NAME      cvar_map_t
+#define KEY_TY    const char *
+#define VAL_TY    consvar_t *
+#define HASH_FN   FNV1a_HashLowercaseString
+#define CMPR_FN   vt_cmpr_casestring
+#include "verstable.h"
+
+#define NAME      netvar_map_t
+#define KEY_TY    UINT16
+#define VAL_TY    consvar_t *
+#define HASH_FN   vt_hash_integer
+#define CMPR_FN   vt_cmpr_integer
+#include "verstable.h"
+
+static cvar_map_t cvar_map;
+static netvar_map_t netvar_map;
+
+CONSTRUCTOR static void CV_InitMap(void)
+{
+	// ensure the map is initialized
+	cvar_map_t_init(&cvar_map);
+	cvar_map_t_reserve(&cvar_map, 512);
+
+	netvar_map_t_init(&netvar_map);
+	netvar_map_t_reserve(&netvar_map, 256);
+}
+
+DESTRUCTOR static void CV_DestroyMap(void)
+{
+	cvar_map_t_cleanup(&cvar_map);
+	netvar_map_t_cleanup(&netvar_map);
+}
+
 static const char *cv_null_string = "";
 
 /** Searches if a variable has been registered.
@@ -1173,11 +1208,17 @@ static const char *cv_null_string = "";
   */
 consvar_t *CV_FindVar(const char *name)
 {
-	consvar_t *cvar;
+	cvar_map_t_itr it = cvar_map_t_get(&cvar_map, name);
+	if (!cvar_map_t_is_end(it))
+		return it.data->val;
 
+	// fallback linear search
+	/*
+	consvar_t *cvar;
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
-		if (fasticmp(name,cvar->name))
+		if (fasticmp(name, cvar->name))
 			return cvar;
+	*/
 
 	return NULL;
 }
@@ -1211,11 +1252,17 @@ static inline UINT16 CV_ComputeNetid(const char *s)
   */
 static consvar_t *CV_FindNetVar(UINT16 netid)
 {
+	netvar_map_t_itr it = netvar_map_t_get(&netvar_map, netid);
+	if (!netvar_map_t_is_end(it))
+		return it.data->val;
+
+	/*
 	consvar_t *cvar;
 
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
 		if (cvar->netid == netid)
 			return cvar;
+	*/
 
 	if (netid == 44542) // ouch this hack
 		return &cv_karteliminatelast;
@@ -1281,6 +1328,11 @@ void CV_RegisterVar(consvar_t *variable)
 
 	// the SetValue will set this bit
 	variable->flags &= ~CV_MODIFIED;
+
+	cvar_map_t_insert(&cvar_map, variable->name, variable);
+
+	if (variable->flags & CV_NETVAR)
+		netvar_map_t_insert(&netvar_map, variable->netid, variable);
 }
 
 /** Finds the string value of a console variable.
@@ -1474,7 +1526,7 @@ finish:
 	var->flags |= CV_MODIFIED;
 
 	// raise 'on change' code
-	LUA_CVarChanged(var->name); // let consolelib know what cvar this is.
+	LUA_CVarChanged(var); // let consolelib know what cvar this is.
 
 	if (var->flags & CV_CALL && !stealth)
 		var->func();
@@ -1500,11 +1552,11 @@ badinput:
 
 static boolean serverloading = false;
 
-static void Got_NetVar(UINT8 **p, INT32 playernum)
+static void Got_NetVar(const UINT8 **p, INT32 playernum)
 {
 	consvar_t *cvar;
 	UINT16 netid;
-	char *svalue;
+	const char *svalue;
 	UINT8 stealth = false;
 
 	if (playernum != serverplayer && !IsPlayerAdmin(playernum) && !serverloading)
@@ -1518,9 +1570,10 @@ static void Got_NetVar(UINT8 **p, INT32 playernum)
 		}
 		return;
 	}
+
 	netid = READUINT16(*p);
 	cvar = CV_FindNetVar(netid);
-	svalue = (char *)*p;
+	svalue = (const char *)*p;
 	SKIPSTRING(*p);
 	stealth = READUINT8(*p);
 
@@ -1576,23 +1629,38 @@ void CV_SaveNetVars(UINT8 **p, boolean isdemorecording)
 	WRITEUINT16(count_p, count);
 }
 
-void CV_LoadNetVars(UINT8 **p)
+size_t CV_LoadNetVars(const UINT8 *bufstart)
 {
+	const UINT8 *p = bufstart;
 	consvar_t *cvar;
 	UINT16 count;
 
 	// prevent "invalid command received"
 	serverloading = true;
 
+	// we can use our netvar map instead of going through all cvars each time
+	netvar_map_t_itr it;
+	for (it = netvar_map_t_first(&netvar_map);
+		 !netvar_map_t_is_end(it);
+		 it = netvar_map_t_next(it))
+	{
+		cvar = it.data->val;
+		Setvalue(cvar, cvar->defaultvalue, true);
+	}
+
+	/*
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
 		if (cvar->flags & CV_NETVAR)
 			Setvalue(cvar, cvar->defaultvalue, true);
+	*/
 
-	count = READUINT16(*p);
+	count = READUINT16(p);
 	while (count--)
-		Got_NetVar(p, 0);
+		Got_NetVar(&p, 0);
 
 	serverloading = false;
+
+	return p - bufstart;
 }
 
 static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth);
@@ -1787,7 +1855,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
 //===================================
@@ -182,7 +182,7 @@ void CV_SaveVariables(FILE *f);
 
 // load/save gamesate (load and save option and for network join in game)
 void CV_SaveNetVars(UINT8 **p, boolean isdemorecording);
-void CV_LoadNetVars(UINT8 **p);
+size_t CV_LoadNetVars(const UINT8 *p);
 
 // reset cheat netvars after cheats is deactivated
 void CV_ResetCheatNetVars(void);

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

@@ -33,6 +33,8 @@
 #include "d_main.h"
 #include "m_menu.h"
 #include "m_textinput.h"
+#include "m_emotes.h"
+#include "i_time.h"
 #include "filesrch.h"
 
 #ifdef HWRENDER
@@ -44,21 +46,21 @@
 #ifdef HAVE_THREADS
 I_mutex con_mutex;
 
-// g_in_exiting_signal_handler is an evil hack
+// I_In_Exiting_Signal_Handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
-#else/*HAVE_THREADS*/
+#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
+#else /*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif/*HAVE_THREADS*/
+#endif /*HAVE_THREADS*/
 
 static boolean con_started = false; // console has been initialised
        boolean con_startup = false; // true at game startup, screen need refreshing
 static boolean con_forcepic = true; // at startup toggle console translucency when first off
-       boolean con_recalc;          // set true when screen size has changed
+       boolean con_recalc = false;  // set true when screen size has changed
 
 static tic_t con_tick; // console ticker for anim or blinking prompt cursor
                         // con_scrollup should use time (currenttime - lasttime)..
@@ -66,8 +68,8 @@ static tic_t con_tick; // console ticker for anim or blinking prompt cursor
 static boolean consoletoggle; // true when console key pushed, ticker will handle
 static boolean consoleready;  // console prompt is ready
 
-       INT32 con_destlines; // vid lines used by console at final position
-static INT32 con_curlines;  // vid lines currently used by console
+       INT32 con_destlines = 0; // vid lines used by console at final position
+static INT32 con_curlines;      // vid lines currently used by console
 
 static UINT8  con_hudlines;             // number of console heads up message lines
 static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
@@ -83,7 +85,7 @@ static size_t con_totallines;      // lines of console text into the console buf
 static size_t con_width;           // columns of chars, depend on vid mode width
 
 static size_t con_scrollup;        // how many rows of text to scroll up (pgup/pgdn)
-UINT32 con_scalefactor;            // text size scale factor
+UINT32 con_scalefactor = 0;        // text size scale factor
 
 // hold 32 last lines of input for history
 #define CON_MAXPROMPTCHARS 256
@@ -167,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);
 
 //
@@ -424,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
@@ -521,7 +526,7 @@ static void CON_RecalcSize(void)
 	oldcon_width = con_width;
 	oldnumlines = con_totallines;
 	oldcon_cy = con_cy;
-	M_Memcpy(tmp_buffer, con_buffer, CON_BUFFERSIZE);
+	memcpy(tmp_buffer, con_buffer, CON_BUFFERSIZE);
 
 	if (conw < 1)
 		con_width = (BASEVIDWIDTH>>3) - 2;
@@ -547,7 +552,7 @@ static void CON_RecalcSize(void)
 		{
 			if (tmp_buffer[(i%oldnumlines)*oldcon_width])
 			{
-				M_Memcpy(string, &tmp_buffer[(i%oldnumlines)*oldcon_width], oldcon_width);
+				memcpy(string, &tmp_buffer[(i%oldnumlines)*oldcon_width], oldcon_width);
 				conw = oldcon_width - 1;
 				while (string[conw] == ' ' && conw)
 					conw--;
@@ -584,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)
 	{
@@ -627,68 +638,28 @@ INT32 CON_ShiftChar(INT32 ch)
 	if (I_UseNativeKeyboard())
 		return ch;
 
-	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
-	{
-		if (cv_keyboardlayout.value == 3)
-		{
-			if (shiftdown ^ capslock)
-				ch = shiftxform[ch];
-			else if (altdown & 0x2)
-				ch = french_altgrxform[ch];
-			else
-				ch = HU_FallBackFrSpecialLetter(ch);
-		}
-		else
-		{
-			if (shiftdown ^ capslock)
-				ch = shiftxform[ch];
-		}
-	}
-	else	// if we're holding shift we should still shift non letter symbols
-	{
-		if (cv_keyboardlayout.value == 3)
-		{
-			if (shiftdown)
-				ch = shiftxform[ch];
-			else if (altdown & 0x2)
-				ch = french_altgrxform[ch];
-			else
-				ch = HU_FallBackFrSpecialLetter(ch);
-		}
-		else
-		{
-			if (shiftdown)
-				ch = shiftxform[ch];
-		}
-	}
-
-	return ch;
-}
-
-INT32 CON_ShitAndAltGrChar(INT32 ch)
-{
 	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
 	{
 		if (shiftdown ^ capslock)
 			ch = shiftxform[ch];
 	}
-	else	// if we're holding shift we should still shift non letter symbols
+	else // if we're holding shift we should still shift non letter symbols
 	{
 		if (shiftdown)
 			ch = shiftxform[ch];
-		else if (altdown & 0x2)
+		else if (cv_keyboardlayout.value == 3)
 		{
-			ch = french_altgrxform[ch];
-		}
-		else
-		{
-			ch = HU_FallBackFrSpecialLetter(ch);
+			if (altdown & 0x2)
+				ch = french_altgrxform[ch];
+			else
+				ch = HU_FallBackFrSpecialLetter(ch);
 		}
 	}
 
 	return ch;
 }
 
+
 // Clear time of console heads up messages
 //
 void CON_ClearHUD(void)
@@ -881,7 +852,7 @@ boolean CON_Responder(event_t *ev)
 		return true;
 
 	// ctrl modifier -- changes behavior, adds shortcuts
-	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
+	if (ctrldown && (cv_keyboardlayout.value != 3 || (cv_keyboardlayout.value == 3 && !altdown)))
 	{
 		// show all cvars/commands that match what we have inputted
 		if (key == KEY_TAB)
@@ -1211,19 +1182,10 @@ void CON_LogMessage(const char *msg)
 // Console print! Wahooo! Lots o fun!
 //
 
-void CONS_Printf(const char *fmt, ...)
+static inline void CONS_PrintMsg(char *txt)
 {
-	va_list argptr;
-	static char *txt = NULL;
 	boolean startup;
 
-	if (txt == NULL)
-		txt = malloc(8192);
-
-	va_start(argptr, fmt);
-	vsnprintf(txt, 8192, fmt, argptr);
-	va_end(argptr);
-
 	// echo console prints to log file
 	DEBFILE(txt);
 
@@ -1249,6 +1211,21 @@ void CONS_Printf(const char *fmt, ...)
 	}
 }
 
+void CONS_Printf(const char *fmt, ...)
+{
+	va_list argptr;
+	static char *txt = NULL;
+
+	if (txt == NULL)
+		txt = malloc(8192);
+
+	va_start(argptr, fmt);
+	vsnprintf(txt, 8192, fmt, argptr);
+	va_end(argptr);
+
+	CONS_PrintMsg(txt);
+}
+
 void CONS_Alert(alerttype_t level, const char *fmt, ...)
 {
 	va_list argptr;
@@ -1277,9 +1254,7 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
 			break;
 	}
 
-	// I am lazy and I feel like just letting CONS_Printf take care of things.
-	// Is that okay?
-	CONS_Printf("%s", txt);
+	CONS_PrintMsg(txt);
 }
 
 void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1297,11 +1272,9 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 	vsnprintf(txt, 8192, fmt, argptr);
 	va_end(argptr);
 
-	// Again I am lazy, oh well
-	CONS_Printf("%s", txt);
+	CONS_PrintMsg(txt);
 }
 
-
 // Print an error message, and wait for ENTER key to continue.
 // To make sure the user has seen the message
 //
@@ -1453,7 +1426,18 @@ static void CON_DrawHudlines(void)
 			}
 			if (c >= con_width)
 				break;
-			if (*p < HU_FONTSTART)
+
+			int emotelen;
+			emote_t *emote;
+
+			if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
+			{
+				M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
+				p += emotelen-1;
+				c += emotelen-1;
+				continue;
+			}
+			else if (*p < HU_FONTSTART)
 				;//charwidth = 4 * con_scalefactor;
 			else
 			{
@@ -1485,7 +1469,7 @@ static void CON_DrawConsole(void)
 	// draw console background
 	if (cons_backpic.value || con_forcepic)
 	{
-		patch_t *con_backpic = W_CachePatchName("KARTKREW", PU_PATCH_LOWPRIORITY);
+		patch_t *con_backpic = W_CachePatchName("KARTKREW", PU_PATCH);
 
 		// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
 		V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, con_backpic, NULL);
@@ -1527,8 +1511,20 @@ static void CON_DrawConsole(void)
 				p++;
 				c++;
 			}
+
 			if (c >= con_width)
 				break;
+
+			int emotelen;
+			emote_t *emote;
+
+			if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
+			{
+				M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
+				p += emotelen-1;
+				c += emotelen-1;
+				continue;
+			}
 			V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
 		}
 	}
@@ -1559,13 +1555,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

@@ -13,6 +13,10 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -36,6 +40,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;
@@ -44,13 +49,13 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
 extern UINT8 *consolebgmap;
 
 INT32 CON_ShiftChar(INT32 ch);
-INT32 CON_ShitAndAltGrChar(INT32 ch);
 
 void CON_SetupBackColormap(void);
 void CON_ClearHUD(void); // clear heads up messages
 
 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
@@ -61,4 +66,8 @@ boolean CON_Ready(void);
 
 void CON_LogMessage(const char *msg);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

src/cxxutil.hpp

@@ -147,6 +147,51 @@ public:
 template <class T>
 NotNull(T) -> NotNull<T>;
 
+// does a super safe cast from floating point to interger types
+// this prob could be better since i suck at ceepeepee
+// but atleast we can just template shit to our desired types
+template <typename FloatT, typename IntT>
+static inline IntT floattoint(FloatT val)
+{
+	// :chaosleep:
+	static_assert(std::is_floating_point_v<FloatT>, "Input must be a floating-point type");
+	static_assert(std::is_integral_v<IntT>, "Output must be a integer type");
+
+	if (std::fpclassify(val) == FP_NAN)
+		return 0; // if stuffs not a number we sure screwed up lmao
+
+	// treat inifinity as "int min/max"
+	if (std::fpclassify(val) == FP_INFINITE)
+	{
+		// yes infinity can be signed kek
+		if (std::signbit(val))
+			return std::numeric_limits<IntT>::min(); // negative infinity, so return min
+		else
+			return std::numeric_limits<IntT>::max();
+	}
+
+	// make sure we fit into our targettype uwu
+	if (val > static_cast<FloatT>(std::numeric_limits<IntT>::max()))
+		return std::numeric_limits<IntT>::max();
+	else if (val < static_cast<FloatT>(std::numeric_limits<IntT>::min()))
+		return std::numeric_limits<IntT>::min();
+
+	return static_cast<IntT>(val);
+}
+
+// safe float to fixed
+// which handles nan and inf
+// pretty much the same stuff as the above, but uh, idk how id use the above with this
+template <typename FloatT> // can use both float and doubles yay
+static inline int32_t floattofixed(FloatT val)
+{
+	// :chaosleep:
+	static_assert(std::is_floating_point_v<FloatT>, "Input must be a floating-point type");
+
+	// fixed_t is just an int32_t, i dont wanna include doomtype here if it can be avoided
+	return floattoint<FloatT, int32_t>(val * 65535.);
+}
+
 } // namespace srb2
 
 #endif // __SRB2_CXXUTIL_HPP__

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
@@ -582,6 +581,8 @@ extern tic_t simulated_lag;
 extern tic_t lowest_lag;
 extern consvar_t cv_mindelay, cv_gentlemens;
 
+extern consvar_t cv_usefakeseed, cv_fakeseedname;
+
 extern consvar_t
 	cv_netticbuffer, cv_allownewplayer,
 #ifdef SATURNJOIN
@@ -604,7 +605,7 @@ extern consvar_t cv_serverinfoscreen;
 void D_ClientServerInit(void);
 
 // Initialise the other field
-void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum));
+void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(const UINT8 **p, INT32 playernum));
 void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_t nparam);
 #define SendNetXCmd(id, param, nparam) SendNetXCmdForPlayer(0, id, param, nparam) // Shortcut for P1
 void SendKick(UINT8 playernum, UINT8 msg);
@@ -625,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);
 
@@ -654,15 +654,17 @@ void D_ResetTiccmds(void);
 
 tic_t GetLag(INT32 node);
 
-extern UINT8 hu_resynching;
+extern boolean hu_resynching;
 #ifdef SATURNPAK
-extern UINT8 hu_redownloadinggamestate;
+extern boolean hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 
+#define SAVEGAMESIZE (768*1024)
+
 typedef struct rewind_s
 {
-	UINT8 savebuffer[(768*1024)];
+	UINT8 savebuffer[SAVEGAMESIZE];
 	tic_t leveltime;
 	size_t demopos;
 

src/d_main.c

@@ -46,6 +46,7 @@
 #include "i_time.h"
 #include "i_threads.h"
 #include "i_video.h"
+#include "hu_stuff.h"
 #include "m_argv.h"
 #include "m_menu.h"
 #include "m_misc.h"
@@ -69,7 +70,7 @@
 #include "fastcmp.h"
 #include "r_fps.h" // Frame interpolation/uncapped
 #include "keys.h"
-#include "filesrch.h" // refreshdirmenu, pathisdirectory
+#include "filesrch.h" // pathisdirectory
 #include "d_protocol.h"
 #include "m_perfstats.h"
 #include "k_kart.h"
@@ -79,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
@@ -104,8 +130,8 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadcount = 0;
-static size_t postloadcount = 0;
+static size_t autoloadwadcount = 0;
+static size_t postloadwadcount = 0;
 //
 
 boolean devparm = false; // started game with -devparm
@@ -142,8 +168,8 @@ static char addonsdir[MAX_WADPATH];
 // Events can be discarded if no responder claims them
 // referenced from i_system.c for I_GetKey()
 
-event_t events[MAXEVENTS];
-INT32 eventhead, eventtail;
+event_t events[MAXEVENTS] = {};
+INT32 eventhead = 0, eventtail = 0;
 
 boolean dedicated = false;
 
@@ -161,93 +187,10 @@ void D_PostEvent(const event_t *ev)
 
 // modifier keys
 // Now handled in I_OsPolling
-UINT8 shiftdown = 0; // 0x1 left, 0x2 right
-UINT8 ctrldown = 0; // 0x1 left, 0x2 right
-UINT8 altdown = 0; // 0x1 left, 0x2 right
-boolean capslock = 0;	// gee i wonder what this does.
-
-static void D_PadMenuScrollInput(UINT8 input)
-{
-	event_t dpadev;
-	memset(&dpadev, 0, sizeof(event_t));
-	dpadev.type = ev_keydown;
-
-	switch (input)
-	{
-		case DPAD_UP:
-			dpadev.data1 = KEY_UPARROW;
-			break;
-		case DPAD_DOWN:
-			dpadev.data1 = KEY_DOWNARROW;
-			break;
-		case DPAD_LEFT:
-			dpadev.data1 = KEY_LEFTARROW;
-			break;
-		case DPAD_RIGHT:
-			dpadev.data1 = KEY_RIGHTARROW;
-			break;
-	}
-
-	D_PostEvent(&dpadev); // put into eventlist
-}
-
-#define SCROLLDELAY 19
-
-// Check if any dpad button is held
-// and pass it to the eventlist
-static void D_GamePadMenuScrollTicker(void)
-{
-	UINT8 i;
-	static UINT8 menuInputDelayTimer = 0;
-
-	for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
-	{
-		if (dpadscrollstate[i])
-		{
-			if (menuInputDelayTimer < SCROLLDELAY)
-				menuInputDelayTimer++;
-			else if (menuInputDelayTimer == SCROLLDELAY)
-				D_PadMenuScrollInput(i);
-
-			return;
-		}
-	}
-
-	menuInputDelayTimer = 0;
-}
-#undef SCROLLDELAY
-
-static UINT16 curcolor[MAXSPLITSCREENPLAYERS] = {0};
-
-static void D_DeviceLEDTick(void)
-{
-	UINT8 i;
-	static UINT16 color[MAXSPLITSCREENPLAYERS] = {0};
-
-	if (numcontrollers == 0)
-	{
-		return;
-	}
-
-	for (i = 0; i <= splitscreen; i++)
-	{
-		if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
-			continue;
-
-		color[i] = G_GetSkinColor(i);
-
-		if (curcolor[i] == color[i]) // dont update if same colour
-			continue;
-
-		G_SetPlayerGamepadIndicatorColor(i, color[i]);
-		curcolor[i] = color[i];
-	}
-}
-
-void D_ResetDeviceLED(void)
-{
-	memset(curcolor, 0, sizeof(curcolor));
-}
+UINT8 shiftdown = 0;   // 0x1 left, 0x2 right
+UINT8 ctrldown = 0;   // 0x1 left, 0x2 right
+UINT8 altdown = 0;    // 0x1 left, 0x2 right
+boolean capslock = 0; // gee i wonder what this does.
 
 //
 // D_ProcessEvents
@@ -331,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);
 		}
 	}
 
@@ -379,7 +318,6 @@ static void D_Renderview(void)
 					break;
 				default: // Initialize for P1
 					viewwindowy = viewwindowx = 0;
-					objectsdrawn = 0;
 					break;
 			}
 
@@ -390,20 +328,17 @@ static void D_Renderview(void)
 			}
 			else if (rendermode == render_soft)
 #endif
+			{
+				R_RenderPlayerView(&players[displayplayers[i]]);
 
-			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
+			}
 		}
 	}
 
@@ -411,13 +346,12 @@ static void D_Renderview(void)
 	if (splitscreen == 2)
 	{
 		// V_DrawPatchFill, but for the fourth screen only
-		patch_t *pat = W_CachePatchName("SRB2BACK", PU_PATCH);
-		INT32 x, y, pw = SHORT(pat->width) * vid.dup, ph = SHORT(pat->height) * vid.dup;
+		INT32 x, y, pw = SHORT(srb2back->width) * vid.dup, ph = SHORT(srb2back->height) * vid.dup;
 
 		for (x = vid.width>>1; x < vid.width; x += pw)
 		{
 			for (y = vid.height>>1; y < vid.height; y += ph)
-				V_DrawScaledPatch(x, y, V_NOSCALESTART, pat);
+				V_DrawScaledPatch(x, y, V_NOSCALESTART, srb2back);
 		}
 	}
 
@@ -459,10 +393,6 @@ static boolean D_Display(void)
 			R_ExecuteSetViewSize();
 			forcerefresh = true; // force background redraw
 		}
-
-		// draw buffered stuff to screen
-		// Used only by linux GGI version
-		I_UpdateNoBlit();
 	}
 
 	// save the current screen if about to wipe
@@ -720,13 +650,14 @@ static boolean D_Display(void)
 // D_SRB2Loop
 // =========================================================================
 
-tic_t rendergametic;
+tic_t rendergametic = 0;
 
 void D_SRB2Loop(void)
 {
 	tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
 	double deltatics = 0.0;
 	double deltasecs = 0.0;
+	UINT64 precision = 0;
 
 	boolean interp = false;
 	boolean doDisplay = false;
@@ -759,21 +690,31 @@ void D_SRB2Loop(void)
 	COM_ImmedExecute("cls;version");
 
 	if (rendermode == render_soft)
-		V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, W_CachePatchNum(W_GetNumForName("KARTKREW"), PU_PATCH_LOWPRIORITY), NULL);
+		V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, W_CachePatchNum(W_GetNumForName("KARTKREW"), PU_PATCH), NULL);
 	I_FinishUpdate(); // page flip or blit buffer
 
+	precision = I_GetPrecisePrecision();
+
 	for (;;)
 	{
+		if (I_Interrupted())
+		{
+			I_Quit();
+		}
+
 		// capbudget is the minimum precise_t duration of a single loop iteration
 		precise_t capbudget;
-		precise_t enterprecise = I_GetPreciseTime();
+		precise_t elapsed;
+		precise_t enterprecise, finishprecise;
+
+		enterprecise = I_GetPreciseTime();
 
 		memset(&g_dc, 0, sizeof(g_dc));
 		Z_Frame_Reset();
 
 		// Casting the return value of a function is bad practice (apparently)
-		double budget = ((R_GetFramerateCap() == 0) ? 0.0 : round((1.0 / R_GetFramerateCap()) * I_GetPrecisePrecision()));
-		capbudget = (precise_t)budget;
+		const UINT32 framecap = R_GetFramerateCap();
+		capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round
 
 		boolean ranwipe = false;
 
@@ -807,8 +748,6 @@ void D_SRB2Loop(void)
 
 		renderisnewtic = (realtics > 0 || singletics);
 
-		refreshdirmenu = 0; // not sure where to put this, here as good as any?
-
 		if (renderisnewtic)
 		{
 			// don't skip more than 10 frames at a time
@@ -842,21 +781,11 @@ void D_SRB2Loop(void)
 
 				doDisplay = true;
 			}
-
-			if (!dedicated)
-			{
-				if (menuactive)
-				{
-					D_GamePadMenuScrollTicker();
-				}
-
-				D_DeviceLEDTick();
-			}
 		}
 
 		if (interp)
 		{
-			renderdeltatics = FloatToFixed(deltatics);
+			renderdeltatics = DoubleToFixed(deltatics);
 
 			// I looked at the possibility of putting in a float drawer for
 			// perfstats and it's very complicated, so we'll just do this instead...
@@ -881,9 +810,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();
 			}
 		}
 
@@ -893,6 +822,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
 
@@ -905,12 +841,13 @@ void D_SRB2Loop(void)
 		}
 #endif
 		// Fully completed frame made.
-		precise_t finishprecise = I_GetPreciseTime();
+		finishprecise = I_GetPreciseTime();
 
 		// Use the time before sleep for frameskip calculations:
 		// post-sleep time is literally being intentionally wasted
-		deltasecs = (double)((INT64)(finishprecise - enterprecise)) / I_GetPrecisePrecision();
-		deltatics = deltasecs * NEWTICRATE;
+		elapsed = finishprecise - enterprecise;
+		deltasecs = (double)elapsed / (double)precision;
+		deltatics = deltasecs * (double)NEWTICRATE;
 
 		// If time spent this game loop exceeds a single tic,
 		// it's probably because of rendering.
@@ -938,12 +875,10 @@ void D_SRB2Loop(void)
 
 		if (!singletics)
 		{
-			INT64 elapsed = (INT64)(finishprecise - enterprecise);
-
 			// in the case of "match refresh rate" + vsync, don't sleep at all
 			const boolean vsync_with_match_refresh = cv_vidwait.value && cv_fpscap.value == 0;
 
-			if ((elapsed > 0) && ((INT64)capbudget > elapsed) && !vsync_with_match_refresh)
+			if ((elapsed > 0) && (capbudget > elapsed) && !vsync_with_match_refresh)
 			{
 				I_SleepDuration(capbudget - elapsed);
 			}
@@ -951,8 +886,9 @@ void D_SRB2Loop(void)
 
 		// Capture the time once more to get the real delta time.
 		finishprecise = I_GetPreciseTime();
-		deltasecs = (double)((INT64)(finishprecise - enterprecise)) / I_GetPrecisePrecision();
-		deltatics = deltasecs * NEWTICRATE;
+		elapsed = finishprecise - enterprecise;
+		deltasecs = (double)elapsed / (double)precision;
+		deltatics = deltasecs * (double)NEWTICRATE;
 	}
 }
 
@@ -971,10 +907,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);
@@ -1028,7 +965,7 @@ void D_ClearState(void)
 	M_ClearMenus(true);
 
 	// map palettes affect this
-	D_ResetDeviceLED();
+	G_ResetDeviceLED();
 }
 
 //
@@ -1036,6 +973,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();
@@ -1097,25 +1037,38 @@ static INT32 D_DetectFileType(const char* filename)
 }
 
 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);
 
+	if (*index >= MAX_WADFILES)
+	{
+		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
+		return;
+	}
+
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}
 
+	if (fileType == 1)
+	{
+		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
+		return;
+	}
+
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("No more free memory to AutoloadFile %s",file);
+			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
 
 		strcpy(newfile, file);
-		filearray[index] = newfile;
+		filearray[*index] = newfile;
+		(*index)++;
 	}
 	else
 	{
@@ -1158,7 +1111,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}
 
@@ -1184,27 +1137,34 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';
 
+		// ok so theres still issues with players adding stuff to autoload by accident
+		// sometimes this stuff contains maps
+		// you can probably imagine how that goes in a netgame....
+		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
+		{
+			CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
+			continue;
+		}
+
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}
 
 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
-			autoloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
-			postloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
 		}
 	}
 
-	autoloadwadfiles[autoloadcount] = NULL;
-	autoloadwadfilespost[postloadcount] = NULL;
+	autoloadwadfiles[autoloadwadcount] = NULL;
+	autoloadwadfilespost[postloadwadcount] = NULL;
 
 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1213,7 +1173,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadcount == 0)
+	if (autoloadwadcount == 0)
 		return;
 
 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1221,15 +1181,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfiles, autoloadcount);
+	D_CleanFile(autoloadwadfiles, autoloadwadcount);
 
-	autoloadcount = 0;
+	autoloadwadcount = 0;
 }
 
 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadcount == 0 || !netgame)
+	if (postloadwadcount == 0 || !netgame)
 		return;
 
 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1237,9 +1197,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfilespost, postloadcount);
+	D_CleanFile(autoloadwadfilespost, postloadwadcount);
 
-	postloadcount = 0;
+	postloadwadcount = 0;
 }
 
 // ==========================================================================
@@ -1248,7 +1208,7 @@ void D_AddPostloadFiles(void)
 
 static boolean AddIWAD(const char * file, const char *dir)
 {
-	char * path = va(pandf, dir, file);
+	char *path = va(pandf, dir, file);
 
 	if (FIL_ReadFileOK(path))
 	{
@@ -1269,22 +1229,20 @@ static void IdentifyVersion(void)
 	const char *srb2waddir = NULL;
 
 #if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
+	CLEANUP(pfree) const char *allocwaddir = NULL; // here so we dont potentially free stack memory
 	// change to the directory where 'srb2.srb' is found
-	srb2waddir = I_LocateWad();
+	allocwaddir = I_LocateWad();
+	srb2waddir = allocwaddir;
 #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
@@ -1705,12 +1663,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"));
 
@@ -1957,7 +1909,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
@@ -1977,6 +1930,10 @@ void D_SRB2Main(void)
 	CONS_Printf("R_Init(): Init SRB2 refresh daemon.\n");
 	R_Init();
 
+#if SOUND==SOUND_DUMMY
+	sound_disabled = true;
+	music_disabled = true;
+#else
 	// setting up sound
 	if (dedicated || M_CheckParm("-noaudio")) // combines -nosound and -nomusic
 	{
@@ -1998,6 +1955,7 @@ void D_SRB2Main(void)
 		I_InitMusic();
 		S_InitSfxChannels(cv_soundvolume.value);
 	}
+#endif
 
 	S_InitMusicDefs();
 
@@ -2085,7 +2043,7 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
-		char *replayname = strrchr(replayurl, '/');
+		gconst char *replayname = strrchr(replayurl, '/');
 
 		if (!replayname || !replayurl)
 			I_Error("REPLAY: Invalid URL.");

src/d_main.h

@@ -80,8 +80,6 @@ void D_ProcessEvents(void);
 
 const char *D_Home(void);
 
-void D_ResetDeviceLED(void);
-
 //
 // BASE LEVEL
 //

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;
@@ -95,9 +95,9 @@ static INT32 sendackpacket = 0, getackpacket = 0;
 INT32 ticruned = 0, ticmiss = 0;
 
 // globals
-INT32 getbps, sendbps;
-float lostpercent, duppercent, gamelostpercent;
-INT32 packetheaderlength;
+INT32 getbps = 0, sendbps = 0;
+float lostpercent = 0.0f, duppercent = 0.0f, gamelostpercent = 0.0f;
+INT32 packetheaderlength = 0;
 
 boolean Net_GetNetStat(void)
 {
@@ -243,7 +243,7 @@ static boolean GetFreeAcknum(UINT8 *freeack)
 			ackpak[i].length = doomcom->datalength;
 			ackpak[i].senttime = I_GetTime();
 			ackpak[i].resentnum = 0;
-			M_Memcpy(ackpak[i].pak.raw, netbuffer, ackpak[i].length);
+			memcpy(ackpak[i].pak.raw, netbuffer, ackpak[i].length);
 
 			*freeack = ackpak[i].acknum;
 
@@ -412,7 +412,7 @@ void Net_SendAcks(INT32 node)
 {
 	doomdata_t *netbuffer = DOOMCOM_DATA(doomcom);
 	netbuffer->packettype = PT_NOTHING;
-	M_Memcpy(netbuffer->u.textcmd, nodes[node].acktosend, MAXACKTOSEND);
+	memcpy(netbuffer->u.textcmd, nodes[node].acktosend, MAXACKTOSEND);
 	HSendPacket(node, false, 0, MAXACKTOSEND);
 }
 
@@ -492,9 +492,10 @@ 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()));
-			M_Memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
+			memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
 			ackpak[i].senttime = I_GetTime();
 			ackpak[i].resentnum++;
 			ackpak[i].nextacknum = node->nextacknum;
@@ -611,12 +612,8 @@ void Net_WaitAllAckReceived(UINT32 timeout)
 
 static void InitNode(node_t *node)
 {
-	node->acktosend_head = node->acktosend_tail = 0;
-	memset(node->acktosend, 0, sizeof(node->acktosend));
-	node->firstacktosend = 0;
+	memset(node, 0, sizeof(node_t));
 	node->nextacknum = 1;
-	node->remotefirstack = 0;
-	node->flags = 0;
 }
 
 static void InitAck(void)
@@ -805,16 +802,16 @@ const char *packettypename[NUMPACKETTYPE] =
 	"TELLFILESNEEDED",
 	"MOREFILESNEEDED",
 
-	"PING"
+	"PING",
 #ifdef SATURNPAK
-	,
-
 	"WILLRESENDGAMESTATE",
 	"CANRECEIVEGAMESTATE",
 	"RECEIVEDGAMESTATE",
 
-	"ISSATURN" // special packet to identify saturn clients
+	"ISSATURN", // special packet to identify saturn clients
 #endif
+	"MAPICON",            // Send map image icon (gamespy).
+	"NEEDMAPICON"   // Request missed map icon (gamespy).
 };
 
 const char *Net_GetPacketName(UINT8 packettype)
@@ -1021,7 +1018,7 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum, size_t packetlen
 			return false;
 		}
 		netbuffer->ack = netbuffer->ackreturn = 0; // don't hold over values from last packet sent/received
-		M_Memcpy(&reboundstore[rebound_head], netbuffer,
+		memcpy(&reboundstore[rebound_head], netbuffer,
 			doomcom->datalength);
 		reboundsize[rebound_head] = doomcom->datalength;
 		rebound_head = (rebound_head+1) % MAXREBOUND;
@@ -1107,7 +1104,7 @@ boolean HGetPacket(void)
 	// Get a packet from self
 	if (rebound_tail != rebound_head)
 	{
-		M_Memcpy(netbuffer, &reboundstore[rebound_tail], reboundsize[rebound_tail]);
+		memcpy(netbuffer, &reboundstore[rebound_tail], reboundsize[rebound_tail]);
 		doomcom->datalength = reboundsize[rebound_tail];
 		if (netbuffer->packettype == PT_NODETIMEOUT)
 			doomcom->remotenode = netbuffer->u.textcmd[0];
@@ -1224,7 +1221,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 +1263,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 +1299,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 +1308,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.h

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

src/d_netfil.c

@@ -64,7 +64,6 @@
 static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid);
 
 #ifdef HAVE_CURL
-size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream);
 #if (LIBCURL_VERSION_MAJOR <= 7) && (LIBCURL_VERSION_MINOR < 35)
 static int curlprogress_callback(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow);
 #else
@@ -110,14 +109,14 @@ static fileused_t transferFiles[UINT8_MAX + 1];
 // Write time of file: utime
 
 // Receiver structure
-INT32 fileneedednum; // Number of files needed to join the server
-fileneeded_t fileneeded[MAX_WADFILES]; // List of needed files
+INT32 fileneedednum = 0; // Number of files needed to join the server
+fileneeded_t fileneeded[MAX_WADFILES] = {}; // List of needed files
 #ifdef HAVE_THREADS
 static I_mutex downloadmutex;
 #endif
 char downloaddir[512] = "DOWNLOAD";
 
-file_download_t filedownload;
+file_download_t filedownload = {};
 
 #ifdef HAVE_CURL
 static CURL *http_handle;
@@ -131,7 +130,9 @@ static UINT32 curl_origfilesize;
 static UINT32 curl_origtotalfilesize;
 static char *curl_realname = NULL;
 fileneeded_t *curl_curfile = NULL;
-HTTP_login *curl_logins;
+HTTP_login *curl_logins = NULL;
+
+static void CURLGetFile(void);
 #endif
 
 /** Fills a serverinfo packet with information about wad files loaded.
@@ -902,7 +903,7 @@ void SV_FileSendTicker(void)
 
 		if (ram)
 		{
-			M_Memcpy(p->data, &f->id.ram[transfer[i].position], size);
+			memcpy(p->data, &f->id.ram[transfer[i].position], size);
 		}
 		else if (fread(p->data, 1, size, transferFiles[f->fileid].file) != size)
 		{
@@ -959,7 +960,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download \"%s\"", filename);
+		I_Error("Tried to download base-game file: \"%s\"", filename);
 
 	if (filenum >= fileneedednum)
 	{
@@ -1018,21 +1019,21 @@ void Got_Filetxpak(void)
 
 		switch(file->status)
 		{
-		case FS_NOTFOUND:
-			s = "FS_NOTFOUND";
-			break;
-		case FS_FOUND:
-			s = "FS_FOUND";
-			break;
-		case FS_OPEN:
-			s = "FS_OPEN";
-			break;
-		case FS_MD5SUMBAD:
-			s = "FS_MD5SUMBAD";
-			break;
-		default:
-			s = "unknown";
-			break;
+			case FS_NOTFOUND:
+				s = "FS_NOTFOUND";
+				break;
+			case FS_FOUND:
+				s = "FS_FOUND";
+				break;
+			case FS_OPEN:
+				s = "FS_OPEN";
+				break;
+			case FS_MD5SUMBAD:
+				s = "FS_MD5SUMBAD";
+				break;
+			default:
+				s = "unknown";
+				break;
 		}
 
 		I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);
@@ -1080,12 +1081,14 @@ void CloseNetFile(void)
 
 	// Receiving a file?
 	for (i = 0; i < MAX_WADFILES; i++)
+	{
 		if (fileneeded[i].status == FS_DOWNLOADING && fileneeded[i].file)
 		{
 			fclose(fileneeded[i].file);
 			// File is not complete delete it
 			remove(fileneeded[i].filename);
 		}
+	}
 
 	// Remove PT_FILEFRAGMENT from acknowledge list
 	Net_AbortPacketType(PT_FILEFRAGMENT);
@@ -1099,17 +1102,16 @@ void nameonly(char *s)
 	void *ns;
 
 	for (j = strlen(s); j != (size_t)-1; j--)
+	{
 		if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
 		{
 			ns = &(s[j+1]);
 			len = strlen(ns);
-#if 0
-				M_Memcpy(s, ns, len+1);
-#else
-				memmove(s, ns, len+1);
-#endif
+			memmove(s, ns, len+1);
+
 			return;
 		}
+	}
 }
 
 // Returns the length in characters of the last element of a path.
@@ -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

@@ -127,16 +127,32 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
 
 #include <time.h>
 
-// Locations for searching the srb2.srb
+/// Locations to directly check for srb2.srb in
+const char *wadDefaultPaths[] = {
 #if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
-#define DEFAULTWADLOCATION1 "/usr/local/share/games/SRB2Kart"
-#define DEFAULTWADLOCATION2 "/usr/local/games/SRB2Kart"
-#define DEFAULTWADLOCATION3 "/usr/share/games/SRB2Kart"
-#define DEFAULTWADLOCATION4 "/usr/games/SRB2Kart"
-#define DEFAULTSEARCHPATH1 "/usr/local/games"
-#define DEFAULTSEARCHPATH2 "/usr/games"
-#define DEFAULTSEARCHPATH3 "/usr/local"
+	"/usr/local/share/games/SRB2Kart",
+	"/usr/local/games/SRB2Kart",
+	"/usr/share/games/SRB2Kart",
+	"/usr/games/SRB2Kart",
+#elif defined (_WIN32)
+	"c:\\games\\srb2kart",
+	"\\games\\srb2kart",
 #endif
+	NULL
+};
+
+// Folders to recurse through looking for srb2.srb
+const char *wadSearchPaths[] = {
+#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
+	"/usr/local/games",
+	"/usr/games",
+	"/usr/local",
+#elif defined (_WIN32)
+	"c:\\games",
+	"\\games",
+#endif
+	NULL
+};
 
 /**	\brief WAD file to look for
 */
@@ -151,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"
@@ -162,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)
@@ -180,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;
@@ -683,11 +695,7 @@ void I_JoyScale4(void)
 
 
 */
-void I_ShutdownJoystick(void)
-{
-}
-
-void I_GetJoystickEvents(UINT8 index)
+void I_ShutdownJoystick(UINT8 index)
 {
 	(void)index;
 }
@@ -808,20 +816,23 @@ static void I_SetupMumble(void)
 void I_UpdateMumble(const mobj_t *mobj, const listener_t listener)
 {
 #ifdef HAVE_MUMBLE
-	double angle;
+	float angle;
 	fixed_t anglef;
 
 	if (!mumble)
 		return;
 
-	if (mumble->uiVersion != 2) {
-		wcsncpy(mumble->name, L"SRB2Kart "VERSIONSTRINGW, 256);
+	if (mumble->uiVersion != 2)
+	{
+		wcsncpy(mumble->name, L"SRB2Kart " VERSIONSTRINGW, 256);
 		wcsncpy(mumble->description, L"Sonic Robo Blast 2 Kart with integrated Mumble Link support.", 2048);
 		mumble->uiVersion = 2;
 	}
 	mumble->uiTick++;
 
-	if (!netgame || gamestate != GS_LEVEL) { // Zero out, but never delink.
+	// Zero out, but never delink.
+	if (!netgame || gamestate != GS_LEVEL)
+	{
 		mumble->fAvatarPosition[0] = mumble->fAvatarPosition[1] = mumble->fAvatarPosition[2] = 0.0f;
 		mumble->fAvatarFront[0] = 1.0f;
 		mumble->fAvatarFront[1] = mumble->fAvatarFront[2] = 0.0f;
@@ -838,31 +849,34 @@ void I_UpdateMumble(const mobj_t *mobj, const listener_t listener)
 		mumble->context_len = (UINT32)(p - mumble->context);
 	}
 
-	if (mobj) {
-		mumble->fAvatarPosition[0] = FIXED_TO_FLOAT(mobj->x) / MUMBLEUNIT;
-		mumble->fAvatarPosition[1] = FIXED_TO_FLOAT(mobj->z) / MUMBLEUNIT;
-		mumble->fAvatarPosition[2] = FIXED_TO_FLOAT(mobj->y) / MUMBLEUNIT;
+	if (mobj)
+	{
+		mumble->fAvatarPosition[0] = FixedToFloat(mobj->x) / MUMBLEUNIT;
+		mumble->fAvatarPosition[1] = FixedToFloat(mobj->z) / MUMBLEUNIT;
+		mumble->fAvatarPosition[2] = FixedToFloat(mobj->y) / MUMBLEUNIT;
 
 		anglef = AngleFixed(mobj->angle);
-		angle = FIXED_TO_FLOAT(anglef)*DEG2RAD;
-		mumble->fAvatarFront[0] = (float)cos(angle);
+		angle = (float)(FixedToFloat(anglef) * DEG2RAD);
+		mumble->fAvatarFront[0] = cosf(angle);
 		mumble->fAvatarFront[1] = 0.0f;
-		mumble->fAvatarFront[2] = (float)sin(angle);
-	} else {
+		mumble->fAvatarFront[2] = sinf(angle);
+	}
+	else
+	{
 		mumble->fAvatarPosition[0] = mumble->fAvatarPosition[1] = mumble->fAvatarPosition[2] = 0.0f;
 		mumble->fAvatarFront[0] = 1.0f;
 		mumble->fAvatarFront[1] = mumble->fAvatarFront[2] = 0.0f;
 	}
 
-	mumble->fCameraPosition[0] = FIXED_TO_FLOAT(listener.x) / MUMBLEUNIT;
-	mumble->fCameraPosition[1] = FIXED_TO_FLOAT(listener.z) / MUMBLEUNIT;
-	mumble->fCameraPosition[2] = FIXED_TO_FLOAT(listener.y) / MUMBLEUNIT;
+	mumble->fCameraPosition[0] = FixedToFloat(listener.x) / MUMBLEUNIT;
+	mumble->fCameraPosition[1] = FixedToFloat(listener.z) / MUMBLEUNIT;
+	mumble->fCameraPosition[2] = FixedToFloat(listener.y) / MUMBLEUNIT;
 
 	anglef = AngleFixed(listener.angle);
-	angle = FIXED_TO_FLOAT(anglef)*DEG2RAD;
-	mumble->fCameraFront[0] = (float)cos(angle);
+	angle = (float)(FixedToFloat(anglef) * DEG2RAD);
+	mumble->fCameraFront[0] = cosf(angle);
 	mumble->fCameraFront[1] = 0.0f;
-	mumble->fCameraFront[2] = (float)sin(angle);
+	mumble->fCameraFront[2] = sinf(angle);
 #else
 	(void)mobj;
 	(void)listener;
@@ -970,7 +984,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }
 
-boolean g_in_exiting_signal_handler = false;
+static volatile sig_atomic_t g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1034,6 +1048,11 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }
 
+boolean I_In_Exiting_Signal_Handler(void)
+{
+	return g_in_exiting_signal_handler;
+}
+
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1053,11 +1072,17 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
+static volatile sig_atomic_t interrupted = 0;
+
+boolean I_Interrupted(void)
 {
-	signal(num, SIG_DFL); //default signal action
-	raise(num);
-	I_Quit();
+	return interrupted;
+}
+
+static void quit_handler(int num)
+{
+	(void)num;
+	interrupted = 1;
 }
 
 #ifdef HAVE_LIBBACKTRACE
@@ -1417,20 +1442,6 @@ death:
 	exit(0);
 }
 
-void I_WaitVBL(INT32 count)
-{
-	count = 1;
-	I_Sleep(count);
-}
-
-void I_BeginRead(void)
-{
-}
-
-void I_EndRead(void)
-{
-}
-
 //
 // I_Error
 //
@@ -1821,16 +1832,23 @@ static const char *searchWad(const char *searchDir)
 		return tempsw;
 	}
 
-	strcpy(tempsw, WADKEYWORD2);
-	fstemp = filesearch(tempsw, searchDir, NULL, true, 20);
-	if (fstemp == FS_FOUND)
-	{
-		pathonly(tempsw);
-		return tempsw;
-	}
 	return NULL;
 }
 
+#define CHECKWADPATH(ret) \
+do { \
+	I_OutputMsg(",%s", ret); \
+	if (isWadPathOk(ret)) \
+		return ret; \
+} while (0)
+
+#define SEARCHWAD(str) \
+do { \
+	WadPath = searchWad(str); \
+	if (WadPath) \
+		return WadPath; \
+} while (0)
+
 /**	\brief go through all possible paths and look for srb2.srb
 
   \return path to srb2.srb if any
@@ -1839,6 +1857,7 @@ static const char *locateWad(void)
 {
 	const char *envstr;
 	const char *WadPath;
+	int i;
 
 	I_OutputMsg("SRB2WADDIR");
 	// does SRB2WADDIR exist?
@@ -1846,132 +1865,51 @@ static const char *locateWad(void)
 		return envstr;
 
 #ifndef NOCWD
-	I_OutputMsg(",.");
 	// examine current dir
 	strcpy(returnWadPath, ".");
+	I_OutputMsg(",%s", returnWadPath);
 	if (isWadPathOk(returnWadPath))
 		return NULL;
 #endif
 
-
+#ifndef NOHOME
 #ifdef DEFAULTDIR
 	I_OutputMsg(",HOME/" DEFAULTDIR);
 	// examine user jart directory
 	if ((envstr = I_GetEnv("HOME")) != NULL)
 	{
 		sprintf(returnWadPath, "%s" PATHSEP DEFAULTDIR, envstr);
-		if (isWadPathOk(returnWadPath))
-			return returnWadPath;
-	}
-#endif
-
-
-#ifdef CMAKECONFIG
-#ifndef NDEBUG
-	I_OutputMsg(","CMAKE_ASSETS_DIR);
-	strcpy(returnWadPath, CMAKE_ASSETS_DIR);
-	if (isWadPathOk(returnWadPath))
-	{
-		return returnWadPath;
+		CHECKWADPATH(returnWadPath);
 	}
 #endif
 #endif
 
 #ifdef __APPLE__
 	OSX_GetResourcesPath(returnWadPath);
-	I_OutputMsg(",%s", returnWadPath);
-	if (isWadPathOk(returnWadPath))
-	{
-		return returnWadPath;
-	}
+	CHECKWADPATH(returnWadPath);
 #endif
 
 	// examine default dirs
-#ifdef DEFAULTWADLOCATION1
-	I_OutputMsg(","DEFAULTWADLOCATION1);
-	strcpy(returnWadPath, DEFAULTWADLOCATION1);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION2
-	I_OutputMsg(","DEFAULTWADLOCATION2);
-	strcpy(returnWadPath, DEFAULTWADLOCATION2);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION3
-	I_OutputMsg(","DEFAULTWADLOCATION3);
-	strcpy(returnWadPath, DEFAULTWADLOCATION3);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION4
-	I_OutputMsg(","DEFAULTWADLOCATION4);
-	strcpy(returnWadPath, DEFAULTWADLOCATION4);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION5
-	I_OutputMsg(","DEFAULTWADLOCATION5);
-	strcpy(returnWadPath, DEFAULTWADLOCATION5);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION6
-	I_OutputMsg(","DEFAULTWADLOCATION6);
-	strcpy(returnWadPath, DEFAULTWADLOCATION6);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifdef DEFAULTWADLOCATION7
-	I_OutputMsg(","DEFAULTWADLOCATION7);
-	strcpy(returnWadPath, DEFAULTWADLOCATION7);
-	if (isWadPathOk(returnWadPath))
-		return returnWadPath;
-#endif
-#ifndef NOHOME
-	// find in $HOME
-	I_OutputMsg(",HOME/" DEFAULTDIR);
-	if ((envstr = I_GetEnv("HOME")) != NULL)
+	for (i = 0; wadDefaultPaths[i]; i++)
 	{
-		char *tmp = malloc(strlen(envstr) + sizeof(PATHSEP) + sizeof(DEFAULTDIR));
-		strcpy(tmp, envstr);
-		strcat(tmp, PATHSEP);
-		strcat(tmp, DEFAULTDIR);
-		WadPath = searchWad(tmp);
-		free(tmp);
-		if (WadPath)
-			return WadPath;
+		strcpy(returnWadPath, wadDefaultPaths[i]);
+		CHECKWADPATH(returnWadPath);
 	}
-#endif
-#ifdef DEFAULTSEARCHPATH1
-	// find in /usr/local
-	I_OutputMsg(", in:"DEFAULTSEARCHPATH1);
-	WadPath = searchWad(DEFAULTSEARCHPATH1);
-	if (WadPath)
-		return WadPath;
-#endif
-#ifdef DEFAULTSEARCHPATH2
-	// find in /usr/games
-	I_OutputMsg(", in:"DEFAULTSEARCHPATH2);
-	WadPath = searchWad(DEFAULTSEARCHPATH2);
-	if (WadPath)
-		return WadPath;
-#endif
-#ifdef DEFAULTSEARCHPATH3
-	// find in ???
-	I_OutputMsg(", in:"DEFAULTSEARCHPATH3);
-	WadPath = searchWad(DEFAULTSEARCHPATH3);
-	if (WadPath)
-		return WadPath;
-#endif
+
+	// search paths
+	for (i = 0; wadSearchPaths[i]; i++)
+	{
+		I_OutputMsg(", in:%s", wadSearchPaths[i]);
+		SEARCHWAD(wadSearchPaths[i]);
+	}
+
 	// if nothing was found
 	return NULL;
 }
 
 const char *I_LocateWad(void)
 {
-	const char *waddir;
+	const char *waddir = NULL;
 
 	I_OutputMsg("Looking for WADs in: ");
 	waddir = locateWad();
@@ -1981,12 +1919,15 @@ const char *I_LocateWad(void)
 	{
 		// change to the directory where we found srb2.srb
 #if defined (_WIN32)
+		waddir = _fullpath(NULL, waddir, MAX_PATH);
 		SetCurrentDirectoryA(waddir);
 #else
+		waddir = realpath(waddir, NULL);
 		if (waddir == NULL || chdir(waddir) == -1)
 			I_OutputMsg("Couldn't change working directory\n");
 #endif
 	}
+
 	return waddir;
 }
 

src/dedicated/i_video.c

@@ -65,13 +65,6 @@ void I_OsPolling(void)
 		I_GetConsoleEvents();
 }
 
-//
-// I_UpdateNoBlit
-//
-void I_UpdateNoBlit(void)
-{
-}
-
 //
 // I_FinishUpdate
 //
@@ -155,7 +148,10 @@ boolean I_UseNativeKeyboard(void)
 	return false;
 }
 
+void I_HandleControllerHatRepeat(void)
+{
+}
+
 void I_SetBorderlessWindow(void)
 {
-
 }

src/dehacked.c

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

src/dehacked.h

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

src/doomdef.h

@@ -19,25 +19,18 @@
 // This should actually be in the makefile,
 // but I can't stand that gibberish. D:
 #define SOUND_DUMMY   0
-#define SOUND_SDL     1
-#define SOUND_MIXER   2
+#define SOUND_MIXER   1
 
 #ifndef SOUND
 #ifdef HAVE_SDL
-
 // Use Mixer interface?
 #ifdef HAVE_MIXER
     #define SOUND SOUND_MIXER
+#else
+	#define SOUND SOUND_DUMMY
 #endif
-
-// Use generic SDL interface.
-#ifndef SOUND
-#define SOUND SOUND_SDL
-#endif
-
-#else // No SDL.
-// No more interfaces. :(
-#define SOUND SOUND_DUMMY
+#else
+	#define SOUND SOUND_DUMMY
 #endif
 #endif
 
@@ -47,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>
@@ -114,8 +130,8 @@ extern char  logfilename[1024];
 #else
 #define VERSION    1 // Game version
 #define SUBVERSION 6 // more precise version number
-#define VERSIONSTRING "Saturn v9"
-#define VERSIONSTRINGW L"Saturn v9"
+#define VERSIONSTRING "Saturn v9.2"
+#define VERSIONSTRINGW L"Saturn v9.2"
 
 #define SATURN_TESTING // comment out for saturn release builds!
 
@@ -453,11 +469,6 @@ extern char savegamename[256];
 //TODO: delet this
 #define M_GetText(x) (x)
 
-FUNCINLINE static ATTRINLINE void *M_Memcpy(void *dest, const void *src, size_t n)
-{
-	return memcpy(dest, src, n);
-}
-
 char *va(const char *format, ...) FUNCPRINTF;
 char *M_GetToken(const char *inputString);
 char *sizeu1(size_t num);
@@ -489,7 +500,7 @@ extern INT32 cv_debug;
 // Misc stuff for later...
 // =======================
 
-#define ANG2RAD(angle) ((float)((angle)*M_PI)/ANGLE_180)
+#define ANG2RAD(angle) ((float)((angle)*M_PIf) / (float)ANGLE_180)
 
 // Modifier key variables, accessible anywhere
 extern UINT8 shiftdown, ctrldown, altdown;
@@ -505,22 +516,6 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);
 
-/* http://www.cse.yorku.ca/~oz/hash.html */
-static inline
-UINT32 quickncasehash (const char *p, size_t n)
-{
-	size_t i = 0;
-	UINT32 x = 5381;
-
-	while (i < n && p[i])
-	{
-		x = (x * 33) ^ tolower(p[i]);
-		i++;
-	}
-
-	return x;
-}
-
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))
@@ -538,6 +533,10 @@ UINT32 quickncasehash (const char *p, size_t n)
 #define M_PIl 3.1415926535897932384626433832795029L
 #endif
 
+#ifndef M_PIf
+#define M_PIf 3.14159265f
+#endif
+
 // Floating point comparison epsilons from float.h
 #ifndef FLT_EPSILON
 #define FLT_EPSILON 1.1920928955078125e-7f
@@ -574,6 +573,13 @@ UINT32 quickncasehash (const char *p, size_t n)
 // NOTE: you WILL have nasal troubles if the variable is not initialized
 #define CLEANUP(f) __attribute__((__cleanup__(f)))
 
+// the GNU constructor and destructor attributes
+// The constructor attribute causes the function to be called automatically before execution enters main ().
+// Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called.
+// Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.
+#define CONSTRUCTOR __attribute__((constructor, used))
+#define DESTRUCTOR __attribute__((destructor, used))
+
 // An assert-type mechanism.
 #ifdef PARANOIA
 #define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__))

src/doomstat.h

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

@@ -68,10 +68,25 @@ extern "C" {
 	#define strnicmp(x,y,n) strncasecmp(x,y,n)
 #endif
 
-#ifndef __cplusplus
-char *strcasestr(const char *in, const char *what);
-#define stristr strcasestr
+// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
+// to not cause warnings or compile issues on older glibc versions we do this silly thing
+// to not have a gazillion glibc version checks
+#if defined(__GLIBC_PREREQ)
+#if __GLIBC_PREREQ(2, 43)
+	#define gconst const
+#else
+	#define gconst
 #endif
+#else
+	#define gconst
+#endif
+
+#ifndef _GNU_SOURCE
+char *nongnu_strcasestr(const char *in, const char *what);
+#define strcasestr nongnu_strcasestr
+#endif
+
+#define stristr strcasestr
 
 #if defined (macintosh) //|| defined (__APPLE__) //skip all boolean/Boolean crap
 	#define true 1
@@ -125,9 +140,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)
 
 /* Boolean type definition */
+#include <stdbool.h>
 
 #ifndef _WIN32
-#include <stdbool.h>
 // dont use stdbools _BOOL type
 // its smaller (1 byte) than the old interger bool (4 bytes)
 // which results in packed struct sizes being mismatched between vanilla and this
@@ -135,9 +150,7 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 // which we cant use as enumeration constants
 typedef int32_t boolean;
 #else
-#define false FALSE
-#define true TRUE
-#define boolean BOOL
+#define boolean int32_t
 #endif
 
 /* 7.18.2.1  Limits of exact-width integer types */
@@ -293,7 +306,7 @@ typedef struct
 	UINT8 green;
 	UINT8 blue;
 	UINT8 alpha;
-} byteColor_t;
+} ATTRPACK byteColor_t;
 
 union FColorRGBA
 {

src/f_finale.c

@@ -166,8 +166,8 @@ static void F_SkyScroll(INT32 scrollspeed)
 	patch_t *pat, *pat2;
 	INT32 anim2 = 0;
 
-	pat = W_CachePatchName("TITLEBG1", PU_PATCH_LOWPRIORITY);
-	pat2 = W_CachePatchName("TITLEBG2", PU_PATCH_LOWPRIORITY);
+	pat = W_CachePatchName("TITLEBG1", PU_PATCH);
+	pat2 = W_CachePatchName("TITLEBG2", PU_PATCH);
 
 	w = (vid.scaledwidth << FRACBITS);
 
@@ -208,16 +208,13 @@ static void F_SkyScroll(INT32 scrollspeed)
 INT32 intro_scenenum = 0;
 INT32 intro_curtime = 0;
 
-const char *introtext[NUMINTROSCENES];
+const char *introtext[NUMINTROSCENES] = {};
 
 static tic_t introscenetime[NUMINTROSCENES] =
 {
 	 4*TICRATE,	// KART KR(eW
 };
 
-// custom intros
-void F_StartCustomCutscene(INT32 cutscenenum, boolean precutscene, boolean resetplayer);
-
 void F_StartIntro(void)
 {
 	if (gamestate)
@@ -257,26 +254,21 @@ void F_StartIntro(void)
 //
 void F_IntroDrawer(void)
 {
-	boolean highres = false;
 	INT32 cx = 8, cy = 128;
 	patch_t *background = NULL;
 	INT32 bgxoffs = 0;
 
+	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 120);
+
 	// DRAW A FULL PIC INSTEAD OF FLAT!
 	if (intro_scenenum == 0)
 	{
-		background = W_CachePatchName("KARTKREW", PU_PATCH_LOWPRIORITY);
-		highres = true;
-	}
+		background = W_CachePatchName("KARTKREW", PU_PATCH);
 
-	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 120);
-
-	if (background)
-	{
-		if (highres)
+		if (background)
+		{
 			V_DrawSmallScaledPatch(bgxoffs, 0, 0, background);
-		else
-			V_DrawScaledPatch(bgxoffs, 0, 0, background);
+		}
 	}
 
 	W_UnlockCachedPatch(background);
@@ -324,6 +316,7 @@ void F_IntroTicker(void)
 			D_StartTitle();
 			return;
 		}
+
 		if (finalecount == 8)
 			S_StartSound(NULL, sfx_vroom);
 		else if (finalecount == 47)
@@ -626,7 +619,6 @@ void F_StartCredits(void)
 	timetonext = 2*TICRATE;
 }
 
-
 void F_CreditDrawer(void)
 {
 	UINT16 i;
@@ -661,22 +653,23 @@ void F_CreditDrawer(void)
 	// Draw credits text on top
 	for (i = 0; credits[i]; i++)
 	{
-		switch(credits[i][0])
+		switch (credits[i][0])
 		{
-		case 0:
-			y += 80<<FRACBITS;
-			break;
-		case 1:
-			if (y>>FRACBITS > -20)
-				V_DrawCreditString((160 - (V_CreditStringWidth(&credits[i][1])>>1))<<FRACBITS, y, 0, &credits[i][1]);
-			y += 30<<FRACBITS;
-			break;
-		default:
-			if (y>>FRACBITS > -10)
-				V_DrawStringAtFixed(32<<FRACBITS, y, V_ALLOWLOWERCASE, credits[i]);
-			y += 12<<FRACBITS;
-			break;
+			case 0:
+				y += 80<<FRACBITS;
+				break;
+			case 1:
+				if (y>>FRACBITS > -20)
+					V_DrawCreditString((160 - (V_CreditStringWidth(&credits[i][1])>>1))<<FRACBITS, y, 0, &credits[i][1]);
+				y += 30<<FRACBITS;
+				break;
+			default:
+				if (y>>FRACBITS > -10)
+					V_DrawStringAtFixed(32<<FRACBITS, y, V_ALLOWLOWERCASE, credits[i]);
+				y += 12<<FRACBITS;
+				break;
 		}
+
 		if (((y>>FRACBITS) * vid.dup) > vid.height)
 			break;
 	}
@@ -701,7 +694,7 @@ void F_CreditTicker(void)
 	// Draw credits text on top
 	for (i = 0; credits[i]; i++)
 	{
-		switch(credits[i][0])
+		switch (credits[i][0])
 		{
 			case 0: y += 80<<FRACBITS; break;
 			case 1: y += 30<<FRACBITS; break;
@@ -979,10 +972,10 @@ void F_StartTitleScreen(void)
 	demoDelayLeft = demoDelayTime;
 	demoIdleLeft = demoIdleTime;
 
-	ttbanner = W_CachePatchName("TTKBANNR", PU_PATCH_LOWPRIORITY);
-	ttkart = W_CachePatchName("TTKART", PU_PATCH_LOWPRIORITY);
-	ttcheckers = W_CachePatchName("TTCHECK", PU_PATCH_LOWPRIORITY);
-	ttkflash = W_CachePatchName("TTKFLASH", PU_PATCH_LOWPRIORITY);
+	ttbanner = W_CachePatchName("TTKBANNR", PU_PATCH);
+	ttkart = W_CachePatchName("TTKART", PU_PATCH);
+	ttcheckers = W_CachePatchName("TTCHECK", PU_PATCH);
+	ttkflash = W_CachePatchName("TTKFLASH", PU_PATCH);
 }
 
 // (no longer) De-Demo'd Title Screen
@@ -1179,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)
@@ -1325,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;
 }
 
@@ -1419,6 +1410,7 @@ void F_EndCutScene(void)
 	}
 }
 
+// custom intros
 void F_StartCustomCutscene(INT32 cutscenenum, boolean precutscene, boolean resetplayer)
 {
 	if (!cutscenes[cutscenenum])

src/f_wipe.c

@@ -98,7 +98,8 @@ static fixed_t paldiv;
   * \param	lump	Lump name to get data from
   * \return	fademask_t for lump
   */
-static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum) {
+static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum)
+{
 	static char lumpname[9] = "FADEmmss";
 	static fademask_t fm = {NULL,0,0,0,0,0};
 	lumpnum_t lumpnum;
@@ -148,6 +149,7 @@ static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum) {
 		case 0: // end marker (not bad!, but still need clearing)
 			goto freemask;
 	}
+
 	if (lsize != fm.size)
 		fm.mask = Z_Realloc(fm.mask, lsize, PU_STATIC, NULL);
 	fm.size = lsize;
@@ -257,7 +259,7 @@ static void F_DoWipe(fademask_t *fademask)
 				// shortcut - memcpy source to work
 				while (draw_linestogo--)
 				{
-					M_Memcpy(w_base+relativepos, s_base+relativepos, draw_rowend-draw_rowstart);
+					memcpy(w_base+relativepos, s_base+relativepos, draw_rowend-draw_rowstart);
 					relativepos += vid.width;
 				}
 			}
@@ -266,7 +268,7 @@ static void F_DoWipe(fademask_t *fademask)
 				// shortcut - memcpy target to work
 				while (draw_linestogo--)
 				{
-					M_Memcpy(w_base+relativepos, e_base+relativepos, draw_rowend-draw_rowstart);
+					memcpy(w_base+relativepos, e_base+relativepos, draw_rowend-draw_rowstart);
 					relativepos += vid.width;
 				}
 			}
@@ -359,8 +361,14 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 	// on for fade-to-black
 	for (;;)
 	{
+		if (I_Interrupted())
+		{
+			I_Quit();
+		}
+
 		// get fademask first so we can tell if it exists or not
 		fmask = F_GetFadeMask(wipetype, wipeframe++);
+
 		if (!fmask)
 			break;
 
@@ -377,11 +385,10 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 			HWR_DoWipe(wipetype, wipeframe-1); // send in the wipe type and wipeframe because we need to cache the graphic
 		else
 #endif
-		if (rendermode != render_none) //this allows F_RunWipe to be called in dedicated servers
+		if (rendermode != render_none) // this allows F_RunWipe to be called in dedicated servers
 			F_DoWipe(fmask);
 
 		I_OsPolling();
-		I_UpdateNoBlit();
 
 		if (rendermode != render_none && drawMenu)
 		{
@@ -401,6 +408,7 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 
 		NetKeepAlive(); // Update the network so we don't cause timeouts
 	}
+
 	WipeInAction = false;
 #endif
 }

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

@@ -44,16 +44,16 @@ consvar_t cv_addons_search_case = {"addons_search_case", "No", CV_SAVE, CV_YesNo
 static CV_PossibleValue_t addons_search_type_cons_t[] = {{0, "Start"}, {1, "Anywhere"}, {0, NULL}};
 consvar_t cv_addons_search_type = {"addons_search_type", "Anywhere", CV_SAVE, addons_search_type_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-char menupath[MAXFILEPATH];
-size_t menupathindex[menudepth];
+char menupath[MAXFILEPATH] = {};
+size_t menupathindex[menudepth] = {};
 size_t menudepthleft = menudepth;
 
 char menusearchbuf[MAXSTRINGLENGTH+1];
-textinput_t menusearch;
+textinput_t menusearch = {};
 
-char **dirmenu, **coredirmenu; // core only local for this file
-size_t sizedirmenu, sizecoredirmenu; // ditto
-size_t dir_on[menudepth];
+char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
+size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
+size_t dir_on[menudepth] = {};
 UINT8 refreshdirmenu = 0;
 char *refreshdirname = NULL;
 
@@ -92,7 +92,6 @@ INT32 pathisdirectory(const char *path)
 // skip those folders, they will not have any addons
 static const char *exclude_paths[] = {
 	"logs",
-	"luafiles",
 	"replay",
 	"mdls",
 	"gifs",
@@ -272,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));
 }
 
@@ -315,8 +317,7 @@ void closefilemenu(boolean validsize)
 		coredirmenu = NULL;
 	}
 
-	if (refreshdirname)
-		Z_Free(refreshdirname);
+	Z_Free(refreshdirname);
 	refreshdirname = NULL;
 }
 
@@ -344,8 +345,7 @@ void searchfilemenu(char *tempname)
 
 	if (!menusearch.length)
 	{
-		if (dirmenu)
-			Z_Free(dirmenu);
+		Z_Free(dirmenu);
 		dirmenu = coredirmenu;
 		sizedirmenu = sizecoredirmenu;
 
@@ -387,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;
 	}
 
@@ -503,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
@@ -68,19 +70,19 @@ UINT8  numDemos      = 0; //3; -- i'm FED UP of losing my skincolour to a broken
 UINT32 demoDelayTime = 15*TICRATE;
 UINT32 demoIdleTime  = 3*TICRATE;
 
-boolean nodrawers; // for comparative timing purposes
-boolean noblit; // for comparative timing purposes
+boolean nodrawers = false; // for comparative timing purposes
+boolean noblit = false; // for comparative timing purposes
 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;
 static boolean demosynced = true; // console warning message
 
-struct demovars_s demo;
+struct demovars_s demo = {};
 
 consvar_t cv_resyncdemo = {"resyncdemo", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -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)
@@ -257,31 +261,31 @@ void G_ReadDemoExtraData(void)
 			UINT8 kartspeed, kartweight;
 
 			// Skin
-			M_Memcpy(name, demobuf.p, 16);
+			memcpy(name, demobuf.p, 16);
 			demobuf.p += 16;
 			SetPlayerSkin(p, name);
 
 			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)
 		{
 			// Color
-			M_Memcpy(name, demobuf.p, 16);
+			memcpy(name, demobuf.p, 16);
 			demobuf.p += 16;
 			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;
 				}
 		}
@@ -289,7 +293,7 @@ void G_ReadDemoExtraData(void)
 		if (extradata & DXD_NAME)
 		{
 			// Name
-			M_Memcpy(player_names[p],demobuf.p,16);
+			memcpy(player_names[p],demobuf.p,16);
 			demobuf.p += 16;
 		}
 
@@ -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())
@@ -395,7 +399,7 @@ void G_WriteDemoExtraData(void)
 				// Skin
 				memset(name, 0, 16);
 				strncpy(name, skins[players[i].skin].name, 16);
-				M_Memcpy(demobuf.p,name,16);
+				memcpy(demobuf.p, name, 16);
 				demobuf.p += 16;
 
 				WRITEUINT8(demobuf.p, skins[players[i].skin].kartspeed);
@@ -407,7 +411,7 @@ void G_WriteDemoExtraData(void)
 				// Color
 				memset(name, 0, 16);
 				strncpy(name, KartColor_Names[players[i].skincolor], 16);
-				M_Memcpy(demobuf.p,name,16);
+				memcpy(demobuf.p, name, 16);
 				demobuf.p += 16;
 			}
 
@@ -416,7 +420,7 @@ void G_WriteDemoExtraData(void)
 				// Name
 				memset(name, 0, 16);
 				memcpy(name, player_names[i], 15); // Keeping 1 null byte for safety, sorry players with name containing more than 15 characters
-				M_Memcpy(demobuf.p,name,16);
+				memcpy(demobuf.p, name, 16);
 				demobuf.p += 16;
 			}
 
@@ -484,6 +488,7 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
 
 	G_CopyTiccmd(cmd, &oldcmd[playernum], 1);
 
+	// what in the actual fuck is this???
 	// SRB2kart: Copy-pasted from ticcmd building, removes that crappy demo cam
 	if (((players[displayplayers[0]].mo && players[displayplayers[0]].speed > 0) // Moving
 		|| (leveltime > starttime && (cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE)) // Rubber-burn turn
@@ -1131,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)
@@ -1139,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)
@@ -1152,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);
 		}
@@ -1181,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);
@@ -1190,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
 		}
@@ -1364,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
@@ -1384,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;
 	}
 }
@@ -1592,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]);
@@ -1670,7 +1704,7 @@ void G_BeginRecording(void)
 		demoflags |= DF_LUAVARS;
 
 	// Setup header.
-	M_Memcpy(demobuf.p, DEMOHEADER, 12); demobuf.p += 12;
+	memcpy(demobuf.p, DEMOHEADER, 12); demobuf.p += 12;
 	WRITEUINT8(demobuf.p,VERSION);
 	WRITEUINT8(demobuf.p,SUBVERSION);
 	WRITEUINT16(demobuf.p,DEMOVERSION);
@@ -1701,9 +1735,9 @@ void G_BeginRecording(void)
 	demobuf.p += 16;
 
 	// game data
-	M_Memcpy(demobuf.p, "PLAY", 4); demobuf.p += 4;
+	memcpy(demobuf.p, "PLAY", 4); demobuf.p += 4;
 	WRITEINT16(demobuf.p,gamemap);
-	M_Memcpy(demobuf.p, mapmd5, 16); demobuf.p += 16;
+	memcpy(demobuf.p, mapmd5, 16); demobuf.p += 16;
 
 	WRITEUINT8(demobuf.p, demoflags);
 	WRITEUINT8(demobuf.p, gametype & 0xFF);
@@ -1763,19 +1797,19 @@ void G_BeginRecording(void)
 		// Name
 		memset(name, 0, 16);
 		memcpy(name, player_names[p], 15);
-		M_Memcpy(demobuf.p,name,16);
+		memcpy(demobuf.p, name, 16);
 		demobuf.p += 16;
 
 		// Skin
 		memset(name, 0, 16);
 		strncpy(name, skins[player->skin].name, 16);
-		M_Memcpy(demobuf.p,name,16);
+		memcpy(demobuf.p, name, 16);
 		demobuf.p += 16;
 
 		// Color
 		memset(name, 0, 16);
 		strncpy(name, KartColor_Names[player->skincolor], 16);
-		M_Memcpy(demobuf.p,name,16);
+		memcpy(demobuf.p, name, 16);
 		demobuf.p += 16;
 
 		// Score, since Kart uses this to determine where you start on the map
@@ -1834,19 +1868,19 @@ void G_WriteStanding(UINT8 ranking, char *name, INT32 skinnum, UINT8 color, UINT
 	// Name
 	memset(temp, 0, 16);
 	strncpy(temp, name, 16);
-	M_Memcpy(demobuf.p,temp,16);
+	memcpy(demobuf.p,temp,16);
 	demobuf.p += 16;
 
 	// Skin
 	memset(temp, 0, 16);
 	strncpy(temp, skins[skinnum].name, 16);
-	M_Memcpy(demobuf.p,temp,16);
+	memcpy(demobuf.p,temp,16);
 	demobuf.p += 16;
 
 	// Color
 	memset(temp, 0, 16);
 	strncpy(temp, KartColor_Names[color], 16);
-	M_Memcpy(demobuf.p,temp,16);
+	memcpy(demobuf.p,temp,16);
 	demobuf.p += 16;
 
 	// Score/time/whatever
@@ -2212,7 +2246,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 	{
 		case DEMOVERSION: // latest always supported
 			// demo title
-			M_Memcpy(pdemo->title, info_p, 64);
+			memcpy(pdemo->title, info_p, 64);
 			info_p += 64;
 			break;
 #ifdef DEMO_COMPAT_100
@@ -2311,11 +2345,11 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 		pdemo->standings[count].ranking = READUINT8(extrainfo_p);
 
 		// Name
-		M_Memcpy(pdemo->standings[count].name, extrainfo_p, 16);
+		memcpy(pdemo->standings[count].name, extrainfo_p, 16);
 		extrainfo_p += 16;
 
 		// Skin
-		M_Memcpy(temp,extrainfo_p,16);
+		memcpy(temp,extrainfo_p,16);
 		extrainfo_p += 16;
 		pdemo->standings[count].skin = UINT8_MAX;
 
@@ -2329,7 +2363,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 		}
 
 		// Color
-		M_Memcpy(temp,extrainfo_p,16);
+		memcpy(temp,extrainfo_p,16);
 		extrainfo_p += 16;
 
 		for (i = 0; i < MAXSKINCOLORS; i++)
@@ -2369,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
@@ -2424,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
 	}
@@ -2440,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;
 }
@@ -2459,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");
@@ -2494,16 +2555,16 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 	{
 		case DEMOVERSION: // latest always supported
 			// demo title
-			M_Memcpy(pdemo->title, info_p, 64);
+			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:
@@ -2536,7 +2597,7 @@ void G_DoPlayDemo(char *defdemoname)
 	UINT8 i, p;
 	lumpnum_t l;
 	char skin[17], color[17], *n;
-	CLEANUP(Z_Pfree) char *pdemoname;
+	CLEANUP(Z_Pfree) char *pdemoname = NULL;
 	UINT8 version, subversion;
 	UINT32 randseed;
 	char msg[1024];
@@ -2544,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();
 
@@ -2555,7 +2616,7 @@ void G_DoPlayDemo(char *defdemoname)
 	if (defdemoname == NULL)
 	{
 		demobuf.p = demobuf.buffer;
-		pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed
+		pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed
 	}
 	else
 	{
@@ -2567,7 +2628,7 @@ void G_DoPlayDemo(char *defdemoname)
 			n++;
 
 		pdemoname = ZZ_Alloc(strlen(n)+1);
-		strcpy(pdemoname,n);
+		strcpy(pdemoname, n);
 
 		M_SetPlaybackMenuPointer();
 
@@ -2580,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;
 			}
 
@@ -2592,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
@@ -2612,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;
 	}
@@ -2627,7 +2688,7 @@ void G_DoPlayDemo(char *defdemoname)
 	{
 		case DEMOVERSION: // latest always supported
 			// demo title
-			M_Memcpy(demo.titlename, demobuf.p, 64);
+			memcpy(demo.titlename, demobuf.p, 64);
 			demobuf.p += 64;
 			break;
 #ifdef DEMO_COMPAT_100
@@ -2638,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;
 	}
@@ -2649,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;
 	}
@@ -2666,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;
 		}
@@ -2724,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;
@@ -2762,19 +2823,29 @@ 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)
 	{
 		// Player name
-		M_Memcpy(player_names[0],demobuf.p,16);
+		memcpy(player_names[0],demobuf.p,16);
 		demobuf.p += 16;
 
 		// Skin
-		M_Memcpy(skin,demobuf.p,16);
+		memcpy(skin,demobuf.p,16);
 		demobuf.p += 16;
 
 		// Color
-		M_Memcpy(color,demobuf.p,16);
+		memcpy(color,demobuf.p,16);
 		demobuf.p += 16;
 
 		demobuf.p += 5; // Backwards compat - some stats
@@ -2789,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;
 		}
@@ -2799,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;
 		}
@@ -2815,14 +2886,14 @@ void G_DoPlayDemo(char *defdemoname)
 		}
 
 		// net var data
-		CV_LoadNetVars(&demobuf.p);
+		demobuf.p += CV_LoadNetVars(demobuf.p);
 
 		// Sigh ... it's an empty demo.
 		if (*demobuf.p == DEMOMARKER)
 		{
 			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;
 		}
@@ -2853,14 +2924,14 @@ void G_DoPlayDemo(char *defdemoname)
 #endif
 
 	// net var data
-	CV_LoadNetVars(&demobuf.p);
+	demobuf.p += CV_LoadNetVars(demobuf.p);
 
 	// Sigh ... it's an empty demo.
 	if (*demobuf.p == DEMOMARKER)
 	{
 		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;
 	}
@@ -2909,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;
 			}
@@ -2921,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;
 		}
@@ -2933,16 +3004,16 @@ void G_DoPlayDemo(char *defdemoname)
 		players[p].spectator = spectator;
 
 		// Name
-		M_Memcpy(player_names[p],demobuf.p,16);
+		memcpy(player_names[p],demobuf.p,16);
 		demobuf.p += 16;
 
 		// Skin
-		M_Memcpy(skin,demobuf.p,16);
+		memcpy(skin,demobuf.p,16);
 		demobuf.p += 16;
 		SetPlayerSkin(p, skin);
 
 		// Color
-		M_Memcpy(color,demobuf.p,16);
+		memcpy(color,demobuf.p,16);
 		demobuf.p += 16;
 
 		for (i = 0; i < MAXSKINCOLORS; i++)
@@ -3019,6 +3090,9 @@ post_compat:
 	if (cv_director.value)
 		CV_SetValue(&cv_director, 0);
 
+	if (demo.timing)
+		G_DoneLevelLoad();
+
 	demo.deferstart = true;
 }
 #undef SKIPERRORS
@@ -3101,7 +3175,7 @@ void G_AddGhost(char *defdemoname)
 			return;
 	}
 
-	M_Memcpy(md5, p, 16); p += 16; // demo checksum
+	memcpy(md5, p, 16); p += 16; // demo checksum
 
 	for (gh = ghosts; gh; gh = gh->next)
 	{
@@ -3157,15 +3231,15 @@ void G_AddGhost(char *defdemoname)
 	if (ghostversion == 0x0001)
 	{
 		// Player name (TODO: Display this somehow if it doesn't match cv_playername!)
-		M_Memcpy(name, p,16);
+		memcpy(name, p,16);
 		p += 16;
 
 		// Skin
-		M_Memcpy(skin, p,16);
+		memcpy(skin, p,16);
 		p += 16;
 
 		// Color
-		M_Memcpy(color, p,16);
+		memcpy(color, p,16);
 		p += 16;
 
 		// Ghosts do not have a player structure to put this in.
@@ -3215,15 +3289,15 @@ void G_AddGhost(char *defdemoname)
 	}
 
 	// Player name (TODO: Display this somehow if it doesn't match cv_playername!)
-	M_Memcpy(name, p, 16);
+	memcpy(name, p, 16);
 	p += 16;
 
 	// Skin
-	M_Memcpy(skin, p, 16);
+	memcpy(skin, p, 16);
 	p += 16;
 
 	// Color
-	M_Memcpy(color, p, 16);
+	memcpy(color, p, 16);
 	p += 16;
 
 	p += 4; // score
@@ -3260,7 +3334,7 @@ void G_AddGhost(char *defdemoname)
 	gh = Z_Calloc(sizeof(demoghost), PU_LEVEL, NULL);
 	gh->next = ghosts;
 	gh->buffer = buffer;
-	M_Memcpy(gh->checksum, md5, 16);
+	memcpy(gh->checksum, md5, 16);
 	gh->p = p;
 	buffer = NULL; // buffer can't be freed now!
 
@@ -3409,7 +3483,7 @@ void G_UpdateStaffGhostName(lumpnum_t l)
 	if (ghostversion == 0x0001)
 	{
 		// Player name
-		M_Memcpy(dummystaffname, p,16);
+		memcpy(dummystaffname, p,16);
 		dummystaffname[16] = '\0';
 		return; // Not really a failure but whatever
 	}
@@ -3431,7 +3505,7 @@ void G_UpdateStaffGhostName(lumpnum_t l)
 	if (READUINT8(p) != 0)
 		return;
 
-	M_Memcpy(dummystaffname, p, 16);
+	memcpy(dummystaffname, p, 16);
 	dummystaffname[16] = '\0';
 
 	// Ok, no longer any reason to care, bye
@@ -3531,7 +3605,6 @@ void G_FreeGhosts(void)
 	ghosts = NULL;
 }
 
-
 boolean G_CheckDemoStatus(void)
 {
 	G_FreeGhosts();
@@ -3625,7 +3698,7 @@ void G_SaveDemo(void)
 	}
 	WRITEUINT8(demobuf.p, DW_END); // Mark end of demo extra data.
 
-	M_Memcpy(p, demo.titlename, 64); // Write demo title here
+	memcpy(p, demo.titlename, 64); // Write demo title here
 	p += 64;
 
 	if (multiplayer)

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

@@ -59,18 +59,15 @@
 #include "discord.h"
 #endif
 
-gameaction_t gameaction;
+gameaction_t gameaction = 0;
 gamestate_t gamestate = GS_NULL;
 UINT8 ultimatemode = false;
 
-boolean botingame;
-UINT8 botskin;
-UINT8 botcolor;
+boolean botingame = false;
+UINT8 botskin = 0;
+UINT8 botcolor = 0;
 
-JoyType_t Joystick[MAXSPLITSCREENPLAYERS];
-
-// 1024 bytes is plenty for a savegame
-#define SAVEGAMESIZE (1024)
+JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
 
 // SRB2kart
 char gamedatafilename[64] = "kartdata.dat";
@@ -83,10 +80,10 @@ static void G_DoContinued(void);
 static void G_DoWorldDone(void);
 static void G_DoStartVote(void);
 
-music_t mapmusic;
+music_t mapmusic = {};
 
 INT16 gamemap = 1;
-INT16 maptol;
+INT16 maptol = 0;
 UINT8 globalweather = 0;
 INT32 curWeather = PRECIP_NONE;
 INT32 cursaveslot = -1; // Auto-save 1p savegame slot
@@ -97,29 +94,28 @@ UINT16 mainwads = 0;
 boolean modifiedgame = false; // Set if homebrew PWAD stuff has been added.
 boolean majormods = false; // Set if Lua/Gameplay SOC/replacement map has been added.
 boolean savemoddata = false;
-UINT8 paused;
+UINT8 paused = 0;
 UINT8 modeattacking = ATTACKING_NONE;
 boolean imcontinuing = false;
-boolean runemeraldmanager = false;
 
-boolean netgame; // only true if packets are broadcast
-boolean multiplayer;
-boolean playeringame[MAXPLAYERS];
-boolean addedtogame;
-player_t players[MAXPLAYERS];
+boolean netgame = false; // only true if packets are broadcast
+boolean multiplayer = false;
+boolean playeringame[MAXPLAYERS] = {};
+boolean addedtogame = false;
+player_t players[MAXPLAYERS] = {};
 
-INT32 consoleplayer; // player taking events and displaying
-INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {0}; // view being displayed
+INT32 consoleplayer = 0; // player taking events and displaying
+INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed
 
-tic_t gametic;
-tic_t levelstarttic; // gametic at level start
-UINT32 totalrings; // for intermission
-INT16 lastmap; // last level you were at (returning from special stages)
-tic_t timeinmap; // Ticker for time spent in level (used for levelcard display)
+tic_t gametic = 0;
+tic_t levelstarttic = 0; // gametic at level start
+UINT32 totalrings = 0; // for intermission
+INT16 lastmap = 0; // last level you were at (returning from special stages)
+tic_t timeinmap = 0; // Ticker for time spent in level (used for levelcard display)
 
-INT16 spstage_start;
-INT16 sstage_start;
-INT16 sstage_end;
+INT16 spstage_start = 0;
+INT16 sstage_start = 0;
+INT16 sstage_end = 0;
 
 boolean looptitle = true;
 boolean useNightsSS = false;
@@ -132,44 +128,44 @@ UINT8 skincolor_bluering = SKINCOLOR_STEEL;
 tic_t countdowntimer = 0;
 boolean countdowntimeup = false;
 
-cutscene_t *cutscenes[128];
+cutscene_t *cutscenes[128] = {};
 
-INT16 nextmapoverride;
-boolean skipstats;
+INT16 nextmapoverride = 0;
+boolean skipstats = false;
 
 // Pointers to each CTF flag
-mobj_t *redflag;
-mobj_t *blueflag;
+mobj_t *redflag = NULL;
+mobj_t *blueflag = NULL;
 // Pointers to CTF spawn location
-mapthing_t *rflagpoint;
-mapthing_t *bflagpoint;
+mapthing_t *rflagpoint = NULL;
+mapthing_t *bflagpoint = NULL;
 
-struct quake quake;
+struct quake quake = {};
 
 // Map Header Information
-mapheader_t* mapheaderinfo[NUMMAPS] = {NULL};
+mapheader_t* mapheaderinfo[NUMMAPS] = {};
 
 static boolean exitgame = false;
 static boolean retrying = false;
 
-UINT8 stagefailed; // Used for GEMS BONUS? Also to see if you beat the stage.
+UINT8 stagefailed = 0; // Used for GEMS BONUS? Also to see if you beat the stage.
 
-UINT16 emeralds;
-UINT32 token; // Number of tokens collected in a level
-UINT32 tokenlist; // List of tokens collected
-INT32 tokenbits; // Used for setting token bits
+UINT16 emeralds = 0;
+UINT32 token = 0; // Number of tokens collected in a level
+UINT32 tokenlist = 0; // List of tokens collected
+INT32 tokenbits = 0; // Used for setting token bits
 
 // Old Special Stage
-INT32 sstimer; // Time allotted in the special stage
+INT32 sstimer = 0; // Time allotted in the special stage
 
 boolean gamedataloaded = false;
 
 // Time attack data for levels
 // These are dynamically allocated for space reasons now
-recorddata_t *mainrecords[NUMMAPS]   = {NULL};
-UINT8 mapvisited[NUMMAPS];
+recorddata_t *mainrecords[NUMMAPS] = {};
+UINT8 mapvisited[NUMMAPS] = {};
 
-UINT32 bluescore, redscore; // CTF and Team Match team scores
+UINT32 bluescore = 0, redscore = 0; // CTF and Team Match team scores
 
 // ring count... for PERFECT!
 INT32 nummaprings = 0;
@@ -179,12 +175,12 @@ INT32 nummapboxes = 0;
 INT32 numgotboxes = 0;
 
 // Elminates unnecessary searching.
-boolean CheckForBustableBlocks;
-boolean CheckForBouncySector;
-boolean CheckForQuicksand;
-boolean CheckForMarioBlocks;
-boolean CheckForFloatBob;
-boolean CheckForReverseGravity;
+boolean CheckForBustableBlocks = false;
+boolean CheckForBouncySector = false;
+boolean CheckForQuicksand = false;
+boolean CheckForMarioBlocks = false;
+boolean CheckForFloatBob = false;
+boolean CheckForReverseGravity = false;
 
 // Powerup durations
 UINT16 invulntics = 20*TICRATE;
@@ -213,75 +209,67 @@ const INT32 wantedfrequency = 10*TICRATE;
 INT32 gameovertics = 15*TICRATE;
 
 UINT8 use1upSound = 0;
-UINT8 maxXtraLife = 2; // Max extra lives from rings
 
-UINT8 introtoplay;
-UINT8 creditscutscene;
+UINT8 introtoplay = 0;
+UINT8 creditscutscene = 0;
 
 // Emerald locations
-mobj_t *hunt1;
-mobj_t *hunt2;
-mobj_t *hunt3;
+mobj_t *hunt1 = NULL;
+mobj_t *hunt2 = NULL;
+mobj_t *hunt3 = NULL;
 
-tic_t racecountdown, exitcountdown; // for racing
+tic_t racecountdown = 0, exitcountdown = 0; // for racing
 
-fixed_t gravity;
-fixed_t mapobjectscale;
+fixed_t gravity = 0;
+fixed_t mapobjectscale = FRACUNIT;
 
-struct maplighting maplighting;
+struct maplighting maplighting = {};
 
-INT16 autobalance; //for CTF team balance
-INT16 teamscramble; //for CTF team scramble
-INT16 scrambleplayers[MAXPLAYERS]; //for CTF team scramble
-INT16 scrambleteams[MAXPLAYERS]; //for CTF team scramble
-INT16 scrambletotal; //for CTF team scramble
-INT16 scramblecount; //for CTF team scramble
+INT16 autobalance = 0; //for CTF team balance
+INT16 teamscramble = 0; //for CTF team scramble
+INT16 scrambleplayers[MAXPLAYERS] = {}; //for CTF team scramble
+INT16 scrambleteams[MAXPLAYERS] = {}; //for CTF team scramble
+INT16 scrambletotal = 0; //for CTF team scramble
+INT16 scramblecount = 0; //for CTF team scramble
 
-INT32 cheats; //for multiplayer cheat commands
+INT32 cheats = 0; //for multiplayer cheat commands
 
 // SRB2Kart
 // Cvars that we don't want changed mid-game
-UINT8 gamespeed; // Game's current speed (or difficulty, or cc, or etc); 0 for easy, 1 for normal, 2 for hard
+UINT8 gamespeed = 0; // Game's current speed (or difficulty, or cc, or etc); 0 for easy, 1 for normal, 2 for hard
 boolean encoremode = false; // Encore Mode currently enabled?
-boolean prevencoremode;
-boolean franticitems; // Frantic items currently enabled?
-boolean comeback; // Battle Mode's karma comeback is on/off
+boolean prevencoremode = 0;
+boolean franticitems = 0; // Frantic items currently enabled?
+boolean comeback = 0; // Battle Mode's karma comeback is on/off
 
 // Voting system
-INT16 votelevels[4][2]; // Levels that were rolled by the host
-SINT8 votes[MAXPLAYERS]; // Each player's vote
-SINT8 pickedvote; // What vote the host rolls
+INT16 votelevels[4][2] = {}; // Levels that were rolled by the host
+SINT8 votes[MAXPLAYERS] = {}; // Each player's vote
+SINT8 pickedvote = 0; // What vote the host rolls
 
 // Server-sided, synched variables
-SINT8 battlewanted[4]; // WANTED players in battle, worth x2 points
-tic_t wantedcalcdelay; // Time before it recalculates WANTED
-tic_t indirectitemcooldown; // Cooldown before any more Shrink, SPB, or any other item that works indirectly is awarded
-tic_t hyubgone; // Cooldown before hyudoro is allowed to be rerolled
-tic_t mapreset; // Map reset delay when enough players have joined an empty game
-UINT8 nospectategrief; // How many players need to be in-game to eliminate last; for preventing spectate griefing
-boolean thwompsactive; // Thwomps activate on lap 2
-SINT8 spbplace; // SPB exists, give the person behind better items
-boolean startedInFreePlay; // Map was started in free play
+SINT8 battlewanted[4] = {}; // WANTED players in battle, worth x2 points
+tic_t wantedcalcdelay = 0; // Time before it recalculates WANTED
+tic_t indirectitemcooldown = 0; // Cooldown before any more Shrink, SPB, or any other item that works indirectly is awarded
+tic_t hyubgone = 0; // Cooldown before hyudoro is allowed to be rerolled
+tic_t mapreset = 0; // Map reset delay when enough players have joined an empty game
+UINT8 nospectategrief = 0; // How many players need to be in-game to eliminate last; for preventing spectate griefing
+boolean thwompsactive = 0; // Thwomps activate on lap 2
+SINT8 spbplace = 0; // SPB exists, give the person behind better items
+boolean startedInFreePlay = false; // Map was started in free play
 
 // Client-sided, unsynched variables (NEVER use in anything that needs to be synced with other players)
-boolean legitimateexit; // Did this client actually finish the match?
-boolean comebackshowninfo; // Have you already seen the "ATTACK OR PROTECT" message?
-static INT16 randmapbuffer[NUMMAPS+1]; // Buffer for maps RandMap is allowed to roll
+boolean legitimateexit = 0; // Did this client actually finish the match?
+boolean comebackshowninfo = 0; // Have you already seen the "ATTACK OR PROTECT" message?
+static INT16 randmapbuffer[NUMMAPS+1] = {}; // Buffer for maps RandMap is allowed to roll
 
-tic_t hidetime;
+tic_t hidetime = 0;
 
 // Grading
-UINT32 timesBeaten;
-UINT32 timesBeatenWithEmeralds;
-//UINT32 timesBeatenUltimate;
+UINT32 timesBeaten = 0;
+UINT32 timesBeatenWithEmeralds = 0;
 
-INT16 prevmap, nextmap;
-
-// Analog Control
-void SendWeaponPref(void);
-void SendWeaponPref2(void);
-void SendWeaponPref3(void);
-void SendWeaponPref4(void);
+INT16 prevmap = 0, nextmap = 0;
 
 // don't mind me putting these here, I was lazy to figure out where else I could put those without blowing up the compiler.
 
@@ -319,6 +307,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};
 
@@ -459,6 +449,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};
 
@@ -470,7 +468,7 @@ consvar_t cv_cechotoggle = {"show_cecho", "On", CV_SAVE, cechotoggle_t, NULL, 0,
 #endif
 
 #ifdef SEENAMES
-player_t *seenplayer; // player we're aiming at right now
+player_t *seenplayer = NULL; // player we're aiming at right now
 #endif
 
 char player_names[MAXPLAYERS][MAXPLAYERNAME+1] =
@@ -493,7 +491,7 @@ char player_names[MAXPLAYERS][MAXPLAYERNAME+1] =
 	"Player 16"
 }; // SRB2kart - removed Players 17 through 32
 
-INT32 player_name_changes[MAXPLAYERS];
+INT32 player_name_changes[MAXPLAYERS] = {};
 
 INT16 rw_maximums[NUM_WEAPONS] =
 {
@@ -520,11 +518,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;
 	}
 }
 
@@ -570,6 +565,7 @@ static void G_SetSaveGameModified(void)
 	{
 		if (!unlockables[i].conditionset)
 			continue;
+
 		if (!unlockables[i].unlocked)
 		{
 			unlockables[i].unlocked = true;
@@ -595,7 +591,7 @@ void G_SetGameModified(boolean silent, boolean major)
 	G_SetSaveGameModified();
 
 	if (!silent)
-		CONS_Alert(CONS_NOTICE, M_GetText("Record Attack data will be saved to a seperate save file.\n"));
+		CONS_Alert(CONS_NOTICE, "Record Attack data will be saved to a seperate save file.\n");
 
 	// If in record attack recording, cancel it.
 	if (modeattacking)
@@ -634,6 +630,7 @@ const char *G_BuildMapName(INT32 map)
 			map = gamemap-1;
 		else
 			map = prevmap;
+
 		map = G_RandMap(G_TOLFlag(cv_newgametype.value), map, false, 0, false, NULL)+1;
 	}
 
@@ -667,7 +664,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)
@@ -680,18 +677,19 @@ 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)
 {
 	INT32 retaxis;
 	INT32 axisval;
+	INT32 deadzone;
 	boolean flp = false;
 
 	UINT8 pnum = player-1;
 
-	//find what axis to get
+	// find what axis to get
 	switch (axissel)
 	{
 		case AXISTURN:
@@ -750,45 +748,33 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
 	{
 		axisval /= 2;
 		retaxis = joyxmove[pnum][axisval];
-
-		if (retaxis < (-JOYAXISRANGE))
-			retaxis = -JOYAXISRANGE;
-		if (retaxis > (+JOYAXISRANGE))
-			retaxis = +JOYAXISRANGE;
-		if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
-		{
-			const INT32 jdeadzone = ((JOYAXISRANGE-1) * cv_xdeadzone[pnum].value) >> FRACBITS;
-			if (abs(retaxis) <= jdeadzone)
-				return 0;
-		}
-
-		if (flp)
-			retaxis = -retaxis; // flip it around
-
-		return retaxis;
+		deadzone = cv_xdeadzone[pnum].value;
 	}
 	else
 	{
 		axisval--;
 		axisval /= 2;
 		retaxis = joyymove[pnum][axisval];
-
-		if (retaxis < (-JOYAXISRANGE))
-			retaxis = -JOYAXISRANGE;
-		if (retaxis > (+JOYAXISRANGE))
-			retaxis = +JOYAXISRANGE;
-		if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
-		{
-			const INT32 jdeadzone = ((JOYAXISRANGE-1) * cv_ydeadzone[pnum].value) >> FRACBITS;
-			if (abs(retaxis) <= jdeadzone)
-				return 0;
-		}
-
-		if (flp)
-			retaxis = -retaxis; // flip it around
-
-		return retaxis;
+		deadzone = cv_ydeadzone[pnum].value;
 	}
+
+	if (retaxis < (-JOYAXISRANGE))
+		retaxis = -JOYAXISRANGE;
+	if (retaxis > (+JOYAXISRANGE))
+		retaxis = +JOYAXISRANGE;
+
+	if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
+	{
+		const INT32 jdeadzone = ((JOYAXISRANGE-1) * deadzone) >> FRACBITS;
+
+		if (abs(retaxis) <= jdeadzone)
+			return 0;
+	}
+
+	if (flp)
+		retaxis = -retaxis; // flip it around
+
+	return retaxis;
 }
 
 boolean InputDown(INT32 gc, UINT8 p)
@@ -806,14 +792,18 @@ boolean InputDown(INT32 gc, UINT8 p)
 	}
 }
 
-INT32 localaiming[MAXSPLITSCREENPLAYERS];
-angle_t localangle[MAXSPLITSCREENPLAYERS];
-boolean camspin[MAXSPLITSCREENPLAYERS];
+INT32 localaiming[MAXSPLITSCREENPLAYERS] = {};
+angle_t localangle[MAXSPLITSCREENPLAYERS] = {};
+boolean camspin[MAXSPLITSCREENPLAYERS] = {};
 
 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;
@@ -876,9 +866,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.
@@ -913,15 +902,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)
@@ -933,6 +918,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
@@ -975,7 +1017,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;
 	}
@@ -983,7 +1025,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
@@ -1080,7 +1122,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)
 		{
@@ -1143,7 +1185,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;
@@ -1161,6 +1203,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
@@ -1182,10 +1226,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)
 	{
@@ -1210,7 +1254,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	if (gamestate == GS_LEVEL)
 		LUA_HookTiccmd(player, cmd, HOOK(PlayerCmd));
 
-	//Reset away view if a command is given.
+	// Reset away view if a command is given.
 	if (displayplayers[0] != consoleplayer && ssplayer == 1
 	&& (cmd->forwardmove || cmd->sidemove || cmd->buttons))
 	{
@@ -1219,12 +1263,12 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	}
 }
 
-ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
+ticcmd_t *G_CopyTiccmd(ticcmd_t* restrict dest, const ticcmd_t* restrict src, const size_t n)
 {
-	return M_Memcpy(dest, src, n*sizeof(*src));
+	return memcpy(dest, src, n*sizeof(*src));
 }
 
-ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
+ticcmd_t *G_MoveTiccmd(ticcmd_t* restrict dest, const ticcmd_t* restrict src, const size_t n)
 {
 	size_t i;
 	for (i = 0; i < n; i++)
@@ -1261,7 +1305,7 @@ static void G_DoLoadLevel(boolean resetplayer)
 
 	if (gamestate == GS_INTERMISSION)
 		Y_EndIntermission();
-	if (gamestate == GS_VOTING)
+	else if (gamestate == GS_VOTING)
 		Y_EndVote();
 
 	G_SetGamestate(GS_LEVEL);
@@ -1766,14 +1810,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);
 
@@ -1787,7 +1832,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;
@@ -1811,7 +1856,7 @@ void G_ResetViews(void)
 	*/
 	for (viewd = 1; viewd <= splits; ++viewd)
 	{
-		G_AdjustView(viewd, 0, false);
+		G_AdjustViewEx(viewd, 0, false, resetfreecam);
 	}
 }
 
@@ -1892,7 +1937,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
 		}
 	}
 
@@ -1900,7 +1945,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)
@@ -2298,7 +2342,7 @@ void G_PlayerReborn(INT32 player)
 	}
 
 	/* I'm putting this here because lol */
-	fade = (cv_birdmusic.value && cv_fading.value && P_IsLocalPlayer(p));
+	fade = (cv_fading.value && P_IsLocalPlayer(p));
 
 	if (fade)
 	{
@@ -2329,12 +2373,6 @@ void G_PlayerReborn(INT32 player)
 
 	if (gametype == GT_COOP)
 		P_FindEmerald(); // scan for emeralds to hunt for
-
-	// Reset Nights score and max link to 0 on death
-	p->maxlink = 0;
-
-	// If NiGHTS, find lowest mare to start with.
-	p->mare = 0;
 }
 
 //
@@ -2353,22 +2391,25 @@ static boolean G_CheckSpot(INT32 playernum, mapthing_t *mthing)
 	if (!mthing)
 		return false;
 
+	x = mthing->x << FRACBITS;
+	y = mthing->y << FRACBITS;
+
 	if (!players[playernum].mo)
 	{
 		// first spawn of level
 		for (i = 0; i < playernum; i++)
+		{
 			if (playeringame[i] && players[i].mo
-				&& players[i].mo->x == mthing->x << FRACBITS
-				&& players[i].mo->y == mthing->y << FRACBITS)
+				&& players[i].mo->x == x
+				&& players[i].mo->y == y)
 			{
 				return false;
 			}
+		}
+
 		return true;
 	}
 
-	x = mthing->x << FRACBITS;
-	y = mthing->y << FRACBITS;
-
 	if (!K_CheckPlayersRespawnColliding(playernum, x, y))
 		return false;
 
@@ -2870,17 +2911,23 @@ UINT8 G_GetGametypeColor(INT16 gt)
   */
 INT16 G_TOLFlag(INT32 pgametype)
 {
-	if (!multiplayer)                 return TOL_SP;
-	if (pgametype == GT_COOP)         return TOL_RACE; // SRB2kart
-	if (pgametype == GT_COMPETITION)  return TOL_COMPETITION;
-	if (pgametype == GT_RACE)         return TOL_RACE;
-	if (pgametype == GT_MATCH)        return TOL_MATCH;
-	if (pgametype == GT_TEAMMATCH)    return TOL_MATCH;
-	if (pgametype == GT_TAG)          return TOL_TAG;
-	if (pgametype == GT_HIDEANDSEEK)  return TOL_TAG;
-	if (pgametype == GT_CTF)          return TOL_CTF;
+	if (!multiplayer)         return TOL_SP;
+
+	switch (pgametype)
+	{
+		case GT_COOP:         return TOL_RACE; // SRB2kart
+		case GT_COMPETITION:  return TOL_COMPETITION;
+		case GT_RACE:         return TOL_RACE;
+		case GT_MATCH:        return TOL_MATCH;
+		case GT_TEAMMATCH:    return TOL_MATCH;
+		case GT_TAG:          return TOL_TAG;
+		case GT_HIDEANDSEEK:  return TOL_TAG;
+		case GT_CTF:          return TOL_CTF;
+		default:
+			CONS_Alert(CONS_ERROR, "Unknown gametype! %d\n", pgametype);
+			break;
+	}
 
-	CONS_Alert(CONS_ERROR, M_GetText("Unknown gametype! %d\n"), pgametype);
 	return INT16_MAX;
 }
 
@@ -3032,7 +3079,8 @@ tryagain:
 
 void G_AddMapToBuffer(INT16 map)
 {
-	INT16 bufx, refreshnum = max(0, TOLMaps(G_TOLFlag(gametype))-3);
+	const INT32 tolmaps = TOLMaps(G_TOLFlag(gametype));
+	INT16 bufx, refreshnum = max(0, tolmaps-3);
 
 	// Add the map to the buffer.
 	for (bufx = NUMMAPS-1; bufx > 0; bufx--)
@@ -3063,6 +3111,7 @@ static void G_DoCompleted(void)
 	K_StatRound();
 
 	for (i = 0; i < MAXPLAYERS; i++)
+	{
 		if (playeringame[i])
 		{
 			// SRB2Kart: exitlevel shouldn't get you the points
@@ -3072,8 +3121,10 @@ static void G_DoCompleted(void)
 				if (P_IsLocalPlayer(&players[i]))
 					j++;
 			}
+
 			G_PlayerFinishLevel(i); // take away cards and stuff
 		}
+	}
 
 	// play some generic music if there's no win/cool/lose music going on (for exitlevel commands)
 	if (G_RaceGametype() && ((multiplayer && demo.playback) || j == splitscreen+1) && (cv_inttime.value > 0))
@@ -3217,10 +3268,14 @@ void G_AfterIntermission(void)
 
 		return;
 	}
-	else if (demo.recording && (modeattacking || demo.savemode != DSM_NOTSAVING))
-		G_SaveDemo();
-	else if (demo.recording)
-		G_ResetDemoRecording();
+
+	if (demo.recording)
+	{
+		if (modeattacking || demo.savemode != DSM_NOTSAVING)
+			G_SaveDemo();
+		else
+			G_ResetDemoRecording();
+	}
 
 	if (modeattacking) // End the run.
 	{
@@ -3229,7 +3284,9 @@ void G_AfterIntermission(void)
 	}
 
 	if (mapheaderinfo[gamemap-1]->cutscenenum) // Start a custom cutscene.
+	{
 		F_StartCustomCutscene(mapheaderinfo[gamemap-1]->cutscenenum-1, false, false);
+	}
 	else
 	{
 		if (nextmap < 1100-1)
@@ -3366,10 +3423,13 @@ static void G_DoContinued(void)
 // when something new is added.
 void G_EndGame(void)
 {
-	if (demo.recording && (modeattacking || demo.savemode != DSM_NOTSAVING))
-		G_SaveDemo();
-	else if (demo.recording)
-		G_ResetDemoRecording();
+	if (demo.recording)
+	{
+		if (modeattacking || demo.savemode != DSM_NOTSAVING)
+			G_SaveDemo();
+		else
+			G_ResetDemoRecording();
+	}
 
 	// Only do evaluation and credits in coop games.
 	if (gametype == GT_COOP)
@@ -3379,6 +3439,7 @@ void G_EndGame(void)
 			F_StartCredits();
 			return;
 		}
+
 		if (nextmap == 1101-1) // end game with evaluation
 		{
 			F_StartGameEvaluation();
@@ -3432,7 +3493,7 @@ void G_LoadGameData(void)
 	INT32 i, j;
 	UINT8 modded = false;
 	UINT8 rtemp;
-	savebuffer_t save;
+	savebuffer_t save = {};
 
 	//For records
 	tic_t rectime;
@@ -3478,9 +3539,8 @@ void G_LoadGameData(void)
 	modded = READUINT8(save.p);
 
 	// Aha! Someone's been screwing with the save file!
-	if ((modded && !savemoddata))
-		goto datacorrupt;
-	else if (modded != true && modded != false)
+	if ((modded && !savemoddata) ||
+		(modded != true && modded != false))
 		goto datacorrupt;
 
 	// TODO put another cipher on these things? meh, I don't care...
@@ -3545,7 +3605,7 @@ void G_LoadGameData(void)
 	return;
 
 	// Landing point for corrupt gamedata
-	datacorrupt:
+datacorrupt:
 	{
 		const char *gdfolder = "the SRB2Kart folder";
 
@@ -3566,7 +3626,7 @@ void G_SaveGameData(boolean force)
 	size_t length;
 	INT32 i, j;
 	UINT8 btemp;
-	savebuffer_t save;
+	savebuffer_t save = {};
 	(void)force;
 	char backupfile[MAX_WADPATH+4];
 
@@ -3737,7 +3797,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	size_t length;
 	char vcheck[VERSIONSIZE];
 	char savename[255];
-	savebuffer_t save;
+	savebuffer_t save = {};
 
 	// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
 	memset(&savedata, 0, sizeof(savedata));
@@ -3823,7 +3883,7 @@ void G_SaveGame(UINT32 savegameslot)
 	boolean saved;
 	char savename[256] = "";
 	const char *backup;
-	savebuffer_t save;
+	savebuffer_t save = {};
 
 	sprintf(savename, savegamename, savegameslot);
 	backup = va("%s",savename);
@@ -3837,7 +3897,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
+		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -4007,6 +4067,12 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
 	automapactive = false;
 	imcontinuing = false;
 
+	// HACK: this doesent reset if you change the map from within a replay and may cause crashes or the replayhut to be non functional
+	if (!demo.playback && demo.inreplayhut)
+	{
+		M_ResetDemoList();
+	}
+
 	if (!skipprecutscene && mapheaderinfo[gamemap-1]->precutscenenum && !modeattacking) // Start a custom cutscene.
 		F_StartCustomCutscene(mapheaderinfo[gamemap-1]->precutscenenum-1, true, resetplayer);
 	else
@@ -4082,12 +4148,13 @@ static void measurekeywords(mapsearchfreq_t *fr,
 {
 	char *qp;
 	char *sp;
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
 				PU_STATIC, NULL);
 	for (qp = strtok(va("%s", q), " ");
 			qp && fr->total < 255;
-			qp = strtok(0, " "))
+			qp = strtok(NULL, " "))
 	{
 		if (( sp = strcasestr(s, qp) ))
 		{
@@ -4096,10 +4163,12 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
+
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4168,7 +4237,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 			{
 				newmapnum = mapnum;
 				newmapname = realmapname;
-				realmapname = 0;
+				realmapname = NULL;
 				Z_Free(apromapname);
 				if (!wanttable)
 					break;
@@ -4189,7 +4258,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 				{
 					apromapnum = mapnum;
 					apromapname = realmapname;
-					realmapname = 0;
+					realmapname = NULL;
 				}
 			}
 			else/* ...match individual keywords */
@@ -4266,18 +4335,21 @@ INT32 G_FindMapByNameOrCode(const char *mapname, char **realmapnamep)
 	{
 		if (mapname[0] == '*') // current map
 			return gamemap;
-		else if (mapname[0] == '?' && mapheaderinfo[gamemap-1])
+
+		if (mapname[0] == '?' && mapheaderinfo[gamemap-1])
 			return G_RandMap(G_TOLFlag(gametype), gamemap-1, false, 0, false, NULL)+1;
-		else if (mapname[0] == '+' && mapheaderinfo[gamemap-1]) // next map
+
+		if (mapname[0] == '+' && mapheaderinfo[gamemap-1]) // next map
 		{
 			newmapnum = mapheaderinfo[gamemap-1]->nextlevel;
+
 			if (newmapnum < 1 || newmapnum > NUMMAPS)
 			{
-				CONS_Alert(CONS_ERROR, M_GetText("NextLevel (%d) is not a valid map.\n"), newmapnum);
+				CONS_Alert(CONS_ERROR, "NextLevel (%d) is not a valid map.\n", newmapnum);
 				return 0;
 			}
-			else
-				return newmapnum;
+
+			return newmapnum;
 		}
 	}
 	else if (mapnamelen == 2)/* maybe two digit code */

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;
 
@@ -160,7 +163,7 @@ typedef enum
 const char *G_BuildMapName(INT32 map);
 void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
 
-// copy ticcmd_t to and fro the normal way
+// copy ticcmd_t to and from the normal way
 ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n);
 // copy ticcmd_t to and fro network packets
 ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n);
@@ -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};
 
@@ -58,12 +58,21 @@ static void led_off_handle3(void);
 static void led_off_handle4(void);
 
 consvar_t cv_rumble[MAXSPLITSCREENPLAYERS] = {
-	{"rumble", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle, 0, NULL, NULL, 0, 0, NULL},
+	{"rumble",  "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle, 0, NULL, NULL, 0, 0, NULL},
 	{"rumble2", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle2, 0, NULL, NULL, 0, 0, NULL},
 	{"rumble3", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle3, 0, NULL, NULL, 0, 0, NULL},
 	{"rumble4", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle4, 0, NULL, NULL, 0, 0, NULL}
 };
 
+static CV_PossibleValue_t rumblestrength_cons_t[] = {{FRACUNIT/4, "MIN"}, {FRACUNIT*4, "MAX"}, {0, NULL}};
+
+consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS] = {
+	{"rumblestrength",  "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"rumblestrength2", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"rumblestrength3", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"rumblestrength4", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
+};
+
 static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}};
 consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
 	{"gamepadled",  "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL},
@@ -72,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)
@@ -116,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
 {
@@ -183,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
@@ -206,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;
@@ -214,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;
@@ -262,9 +273,6 @@ void G_ResetControls(void)
 
 	memset(joyxmove, 0, sizeof(joyxmove));
 	memset(joyymove, 0, sizeof(joyymove));
-
-	// reset those just in case the game missed the keyup event
-	memset(dpadscrollstate, false, sizeof(dpadscrollstate));
 }
 
 //
@@ -878,11 +886,13 @@ static const char *gamecontrolname[num_gamecontrols] =
 
 #include "k_kart.h"
 
-UINT16 G_GetSkinColor(INT32 playernum)
+UINT8 G_GetSkinColorForGamepad(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
+
 	if (gamestate == GS_LEVEL)
 	{
-		player_t *player = &players[displayplayers[playernum]];
+		const player_t *player = &players[displayplayers[playernum]];
 
 		if (player)
 		{
@@ -900,13 +910,13 @@ UINT16 G_GetSkinColor(INT32 playernum)
 	switch (playernum)
 	{
 		case 0:
-			return cv_playercolor.value;
+			return (UINT8)cv_playercolor.value;
 		case 1:
-			return cv_playercolor2.value;
+			return (UINT8)cv_playercolor2.value;
 		case 2:
-			return cv_playercolor3.value;
+			return (UINT8)cv_playercolor3.value;
 		case 3:
-			return cv_playercolor4.value;
+			return (UINT8)cv_playercolor4.value;
 		default:
 			return 0;
 	}
@@ -914,19 +924,23 @@ UINT16 G_GetSkinColor(INT32 playernum)
 	return 0;
 }
 
-void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color)
+// Sets the Indicator LED on supported gamepads to a desired skincolor
+// pass SKINCOLOR_NONE/0 to set the players skin color
+void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
 {
-	UINT16 skincolor;
+	UINT8 skincolor;
 	byteColor_t byte_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;
 	}
 
-	skincolor = color ? color : G_GetSkinColor(playernum);
+	// so we can override this
+	skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
 	byte_color = V_GetColor(colortranslations[skincolor][8]).s;
 
 	I_SetGamepadIndicatorColor(playernum, byte_color.red, byte_color.green, byte_color.blue);
@@ -934,16 +948,53 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 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);
 	}
 	else
+	{
 		G_SetPlayerGamepadIndicatorColor(playernum, 0);
+	}
+}
+
+static UINT8 curcolor[MAXSPLITSCREENPLAYERS] = {};
+
+void G_DeviceLEDTick(void)
+{
+	UINT8 i, newcolor;
+
+	if (numcontrollers == 0)
+	{
+		return;
+	}
+
+	for (i = 0; i <= splitscreen; i++)
+	{
+		if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
+			continue;
+
+		newcolor = G_GetSkinColorForGamepad(i);
+
+		if (curcolor[i] == newcolor) // dont update if same colour
+			continue;
+
+		G_SetPlayerGamepadIndicatorColor(i, newcolor);
+		curcolor[i] = newcolor;
+	}
+}
+
+// ensures next call to G_DeviceLEDTick will refresh the gamepad led
+void G_ResetDeviceLED(void)
+{
+	memset(curcolor, 0, sizeof(curcolor));
 }
 
 static void G_ResetPlayerDeviceRumble(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 	I_GamepadRumble(playernum, 0, 0, 0);
 }
 
@@ -961,14 +1012,140 @@ 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;
 	}
 
+	// doesent need to be super precise
+	// but ensure this is within range (0-65535)
+	// placed here so it applies to lua aswell
+	low_strength = (UINT16)min(FixedMul(low_strength, cv_rumblestrength[playernum].value), UINT16_MAX);
+	high_strength = (UINT16)min(FixedMul(high_strength, cv_rumblestrength[playernum].value), UINT16_MAX);
+
 	I_GamepadRumble(playernum, low_strength, high_strength, duration);
 }
 
+// rumble strengths
+enum
+{
+	RUMBLE_VERYSTRONG = FRACUNIT / 4,   // 16384
+	RUMBLE_STRONG     = FRACUNIT / 8,   // 8192
+	RUMBLE_MODERATE   = FRACUNIT / 64,  // 1024
+	RUMBLE_WEAK       = FRACUNIT / 128, // 512
+	RUMBLE_VERYWEAK   = FRACUNIT / 256, // 256
+};
+
+// Controller rumble!
+// this keeps track of a bunch of things
+// and makes your controller rumble accordingly
+void G_DeviceRumbleTick(void)
+{
+	UINT8 i;
+
+	if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL)
+	{
+		return;
+	}
+
+	for (i = 0; i <= splitscreen; i++)
+	{
+		if (!cv_usejoystick[i].value || !cv_rumble[i].value)
+		{
+			continue;
+		}
+
+		if (camera[i].freecam)
+		{
+			continue;
+		}
+
+		// SDL rumble strength goes from a range or 0-65535 respectively
+		// the higher, the stronger it is
+		UINT16 low = 0, high = 0;
+		// for how long the action should rumble, in ms
+		UINT16 lenght = 57; // 57ms is a short pulse, matches super well with this updating once per tic
+
+		const player_t *player = P_GetLocalPlayerForNum(i);
+
+		// allow lua to do some crap for spectators
+		if (player->spectator || !player->mo)
+		{
+			continue;
+		}
+
+		// reset the rumble if you exit or are ded lel
+		if (player->exiting ||
+			player->playerstate == PST_DEAD ||
+			player->kartstuff[k_respawn] > 1)
+		{
+			G_PlayerDeviceRumble(i, low, high, 0);
+			continue;
+		}
+
+		if (player->kartstuff[k_spinouttimer])
+		{
+			//low = high = FRACUNIT / 6;
+			low = high = FixedMul((RUMBLE_VERYSTRONG), (FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)))); // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time
+		}
+		else if (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2)))
+		{
+			low = high = RUMBLE_STRONG;
+		}
+		else if ((player->kartstuff[k_offroad])
+			&& player->speed != 0
+			&& P_IsObjectOnGround(player->mo))
+		{
+			// weaken this depending on if you got hyu or invinc
+			if (player->kartstuff[k_hyudorotimer])
+			{
+				high = RUMBLE_WEAK;
+			}
+			else if (player->kartstuff[k_invincibilitytimer])
+			{
+				high = RUMBLE_MODERATE;
+			}
+			else
+			{
+				low = high = RUMBLE_MODERATE;
+			}
+		}
+		else if ((player->kartstuff[k_bananadrag] > TICRATE)
+			&& player->speed != 0
+			&& P_IsObjectOnGround(player->mo))
+		{
+			if (leveltime & 1) // this is actually funny lel
+				high = RUMBLE_MODERATE;
+		}
+
+		if (player->kartstuff[k_brakedrift])
+		{
+			high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
+		}
+
+		// pulse when gettin new driftlevel
+		// let this come last
+		if (player->kartstuff[k_driftcharge]
+			&& player->driftlevel)
+		{
+			high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
+
+			if (player->driftlevel == 2)
+				lenght = 114;
+			else if (player->driftlevel == 3)
+				lenght = 174;
+		}
+
+		// hack alert! i just dont want this thing constantly resetting the rumble lol
+		if (low == 0 && high == 0)
+		{
+			continue;
+		}
+
+		G_PlayerDeviceRumble(i, low, high, lenght);
+	}
+}
+
 //
 // Detach any keys associated to the given game control
 // - pass the pointer to the gamecontrol table for the player being edited

src/g_input.h

@@ -37,7 +37,7 @@ typedef enum
 	KEY_JOY1 = KEY_MOUSE1 + MOUSEBUTTONS,
 	KEY_HAT1 = KEY_JOY1 + JOYBUTTONS,
 
-	KEY_DBLMOUSE1 =KEY_HAT1 + JOYHATS*4, // double clicks
+	KEY_DBLMOUSE1 = KEY_HAT1 + JOYHATS*4, // double clicks
 	KEY_DBLJOY1 = KEY_DBLMOUSE1 + MOUSEBUTTONS,
 	KEY_DBLHAT1 = KEY_DBLJOY1 + JOYBUTTONS,
 
@@ -109,14 +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];
 
@@ -131,13 +134,17 @@ extern INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2];
 #define PLAYER3INPUTDOWN(gc) (gamekeydown[gamecontrol[2][gc][0]] || gamekeydown[gamecontrol[2][gc][1]])
 #define PLAYER4INPUTDOWN(gc) (gamekeydown[gamecontrol[3][gc][0]] || gamekeydown[gamecontrol[3][gc][1]])
 
-// peace to my little coder fingers!
-// check a gamecontrol being active or not
+UINT8 G_GetSkinColorForGamepad(INT32 playernum);
+void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color);
+void G_DeviceLEDTick(void);
+void G_ResetDeviceLED(void);
 
-UINT16 G_GetSkinColor(INT32 playernum);
-void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color);
 void G_ResetAllDeviceRumbles(void);
 void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
+void G_DeviceRumbleTick(void);
+
+// peace to my little coder fingers!
+// check a gamecontrol being active or not
 
 // remaps the input event to a game control.
 void G_MapEventsToControls(event_t *ev);

src/hardware/hw_batching.c

@@ -21,28 +21,28 @@
 
 // The texture for the next polygon given to HWR_ProcessPolygon.
 // Set with HWR_SetCurrentTexture.
-GLMipmap_t *current_texture = NULL;
+static GLMipmap_t *current_texture = NULL;
 
-boolean currently_batching = false;
+static boolean currently_batching = false;
 
-FOutVector* finalVertexArray  = NULL;// contains subset of sorted vertices and texture coordinates to be sent to gpu
-UINT32* finalVertexIndexArray = NULL;// contains indexes for glDrawElements, taking into account fan->triangles conversion
+static FOutVector* finalVertexArray  = NULL;// contains subset of sorted vertices and texture coordinates to be sent to gpu
+static UINT32* finalVertexIndexArray = NULL;// contains indexes for glDrawElements, taking into account fan->triangles conversion
 //     NOTE have this alloced as 3x finalVertexArray size
-int finalVertexArrayAllocSize = 65536;
+static int finalVertexArrayAllocSize = 65536;
 
 //GLubyte* colorArray = NULL;// contains color data to be sent to gpu, if needed
 //int colorArrayAllocSize = 65536;
 // not gonna use this for now, just sort by color and change state when it changes
 // later maybe when using vertex attributes if it's needed
 
-PolygonArrayEntry* polygonArray        = NULL ;// contains the polygon data from DrawPolygon, waiting to be processed
-PolygonArrayEntry **polygonArraySorted = NULL; // contains sorted pointers to polygonArray
-int polygonArraySize      = 0;
-int polygonArrayAllocSize = 65536;
+static PolygonArrayEntry* polygonArray        = NULL ;// contains the polygon data from DrawPolygon, waiting to be processed
+static PolygonArrayEntry **polygonArraySorted = NULL; // contains sorted pointers to polygonArray
+static int polygonArraySize      = 0;
+static int polygonArrayAllocSize = 65536;
 
-FOutVector* unsortedVertexArray  = NULL; // contains unsorted vertices and texture coordinates from DrawPolygon
-int unsortedVertexArraySize      = 0;
-int unsortedVertexArrayAllocSize = 65536;
+static FOutVector* unsortedVertexArray  = NULL; // contains unsorted vertices and texture coordinates from DrawPolygon
+static int unsortedVertexArraySize      = 0;
+static int unsortedVertexArrayAllocSize = 65536;
 
 // Enables batching mode. HWR_ProcessPolygon will collect polygons instead of passing them directly to the rendering backend.
 // Call HWR_RenderBatches to render all the collected geometry.
@@ -126,8 +126,9 @@ void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPt
 		if (!(PolyFlags & PF_NoTexture) && !horizonSpecial)
 		{
 			// use FNV-1a to hash polygons for later sorting.
-			INT32 hash = 0x811c9dc5;
-#define DIGEST(h, x) h ^= (x); h *= 0x01000193
+			UINT32 hash = 0x811c9dc5;
+			UINT32 prime = 0x1000193;
+#define DIGEST(h, x) h ^= ((UINT32)(x)); h *= prime
 			if (current_texture)
 			{
 				DIGEST(hash, current_texture->downloaded);
@@ -148,7 +149,7 @@ void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPt
 			}
 #undef DIGEST
 			// remove the sign bit to ensure that skybox and horizon line comes first.
-			polygonArray[polygonArraySize-1].hash = (hash & INT32_MAX);
+			polygonArray[polygonArraySize-1].hash = (INT32)(hash & INT32_MAX);
 		}
 
 		memcpy(&unsortedVertexArray[unsortedVertexArraySize], pOutVerts, iNumPts * sizeof(FOutVector));
@@ -168,8 +169,10 @@ static int comparePolygons(const void *p1, const void *p2)
 	const PolygonArrayEntry *poly1 = *(PolygonArrayEntry *const *)p1;
 	const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
 
-	const int shader1 = (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial) ? -1 : poly1->shader;
-	const int shader2 = (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial) ? -1 : poly2->shader;
+	// special case with signedness to prevent overflowing
+	// FIXME: check for prediction slowdowns!
+	const int shader1 = poly1->hash & 0x80000000 ? -1 : poly1->shader;
+	const int shader2 = poly2->hash & 0x80000000 ? -1 : poly2->shader;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (shader1 == -1 && shader2 == -1)
@@ -210,8 +213,8 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 	const PolygonArrayEntry *poly1 = *(PolygonArrayEntry *const *)p1;
 	const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
 
-	const GLMipmap_t *texture1 = (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial) ? NULL : poly1->texture;
-	const GLMipmap_t *texture2 = (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial) ? NULL : poly2->texture;
+	const GLMipmap_t *texture1 = poly1->hash & 0x80000000 ? NULL : poly1->texture;
+	const GLMipmap_t *texture2 = poly2->hash & 0x80000000 ? NULL : poly2->texture;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (!texture1 && !texture2)
@@ -219,6 +222,7 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 
 	UINT32 downloaded1 = texture1 ? texture1->downloaded : 0; // there should be a opengl texture name here, usable for comparisons
 	UINT32 downloaded2 = texture2 ? texture2->downloaded : 0;
+
 	diff64 = downloaded1 - downloaded2;
 	if (diff64 != 0) return diff64;
 
@@ -260,7 +264,7 @@ void HWR_RenderBatches(void)
 	nextSurfaceInfo.LightInfo.light_level = 0;
 	nextSurfaceInfo.LightInfo.directional = false;
 
-	currently_batching = false;// no longer collecting batches
+	currently_batching = false; // no longer collecting batches
 
 	if (!polygonArraySize)
 	{
@@ -270,6 +274,8 @@ void HWR_RenderBatches(void)
 		return;// nothing to draw
 	}
 
+	const boolean useshader = HWR_UseShader();
+
 	// init stats vars
 	ps_hw_numpolys.value.i = polygonArraySize;
 	ps_hw_numcalls.value.i = ps_hw_numverts.value.i = 0;
@@ -284,7 +290,7 @@ void HWR_RenderBatches(void)
 
 	// sort polygons
 	PS_START_TIMING(ps_hw_batchsorttime);
-	qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), (HWR_UseShader() ? comparePolygons : comparePolygonsNoShaders));
+	qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), (useshader ? comparePolygons : comparePolygonsNoShaders));
 	PS_STOP_TIMING(ps_hw_batchsorttime);
 
 	// sort order
@@ -305,7 +311,7 @@ void HWR_RenderBatches(void)
 
 	// set state for first batch
 
-	if (HWR_UseShader())
+	if (useshader)
 	{
 		GL_SetShader(currentShader);
 	}
@@ -385,9 +391,9 @@ void HWR_RenderBatches(void)
 				nextSurfaceInfo = nextEntry->surf;
 
 				if (nextPolyFlags & PF_NoTexture)
-					nextTexture = 0;
+					nextTexture = NULL;
 
-				if (currentShader != nextShader && HWR_UseShader())
+				if (useshader && currentShader != nextShader)
 				{
 					changeState = true;
 					changeShader = true;
@@ -405,7 +411,7 @@ void HWR_RenderBatches(void)
 					changePolyFlags = true;
 				}
 
-				if (HWR_UseShader())
+				if (useshader)
 				{
 					if (currentSurfaceInfo.PolyColor.rgba != nextSurfaceInfo.PolyColor.rgba ||
 						currentSurfaceInfo.TintColor.rgba != nextSurfaceInfo.TintColor.rgba ||

src/hardware/hw_bsp.c

@@ -80,14 +80,6 @@ static poly_t *HWR_AllocPoly(INT32 numpts)
 	return p;
 }
 
-static polyvertex_t *HWR_AllocVertex(void)
-{
-	polyvertex_t *p;
-	size_t size = sizeof(polyvertex_t);
-	p = Z_Malloc(size, PU_HWRPLANE, NULL);
-	return p;
-}
-
 /// \todo polygons should be freed in reverse order for efficiency,
 /// for now don't free because it doesn't free in reverse order
 static void HWR_FreePoly(poly_t *poly)
@@ -546,7 +538,7 @@ static void loading_status(void)
 	x = BASEVIDWIDTH/2;
 	y = BASEVIDHEIGHT/2;
 	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31); // Black background to match fade in effect
-	//V_DrawPatchFill(W_CachePatchName("SRB2BACK", PU_PATCH)); // SRB2 background, ehhh too bright.
+	//V_DrawPatchFill(srb2back); // SRB2 background, ehhh too bright.
 	M_DrawTextBox(x-58, y-8, 13, 1);
 	V_DrawString(x-50, y, V_YELLOWMAP, "Loading...");
 	V_DrawRightAlignedString(x+50, y, V_YELLOWMAP, s);
@@ -637,7 +629,7 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
 		WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]);
 
 		// copy child bbox
-		M_Memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
+		memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
 	}
 	else
 		I_Error("WalkBSPNode: no front poly?");
@@ -855,100 +847,6 @@ static INT32 SolveTProblem(void)
 	return numsplitpoly;
 }
 
-#define NEARDIST (0.75f)
-#define MYMAX    (10000000000000.0f)
-
-/* Adjust true segs (from the segs lump) to be exactely the same as
- * plane polygone segs
- * This also convert fixed_t point of segs in float (in moste case
- * it share the same vertice
- */
-static void AdjustSegs(void)
-{
-	size_t i, count;
-	INT32 j;
-	seg_t *lseg;
-	poly_t *p;
-	INT32 v1found = 0, v2found = 0;
-	float nearv1, nearv2;
-
-	for (i = 0; i < numsubsectors; i++)
-	{
-		count = subsectors[i].numlines;
-		lseg = &segs[subsectors[i].firstline];
-		p = extrasubsectors[i].planepoly;
-
-		if (!p)
-			continue;
-
-		for (; count--; lseg++)
-		{
-			float distv1,distv2,tmp;
-			nearv1 = nearv2 = MYMAX;
-
-			// Don't touch polyobject segs. We'll compensate
-			// for this when we go about drawing them.
-			if (lseg->polyseg)
-				continue;
-
-			for (j = 0; j < p->numpts; j++)
-			{
-				distv1 = p->pts[j].x - FIXED_TO_FLOAT(lseg->v1->x);
-				tmp    = p->pts[j].y - FIXED_TO_FLOAT(lseg->v1->y);
-				distv1 = distv1*distv1+tmp*tmp;
-
-				if (distv1 <= nearv1)
-				{
-					v1found = j;
-					nearv1 = distv1;
-				}
-
-				// the same with v2
-				distv2 = p->pts[j].x - FIXED_TO_FLOAT(lseg->v2->x);
-				tmp    = p->pts[j].y - FIXED_TO_FLOAT(lseg->v2->y);
-				distv2 = distv2*distv2+tmp*tmp;
-
-				if (distv2 <= nearv2)
-				{
-					v2found = j;
-					nearv2 = distv2;
-				}
-			}
-
-			if (nearv1 <= NEARDIST*NEARDIST)
-				// share vertice with segs
-				lseg->pv1 = &(p->pts[v1found]);
-			else
-			{
-				// BP: here we can do better, using PointInSeg and compute
-				// the right point position also split a polygone side to
-				// solve a T-intersection, but too mush work
-
-				// convert fixed vertex to float vertex
-				polyvertex_t *pv = HWR_AllocVertex();
-				pv->x = FIXED_TO_FLOAT(lseg->v1->x);
-				pv->y = FIXED_TO_FLOAT(lseg->v1->y);
-				lseg->pv1 = pv;
-			}
-
-			if (nearv2 <= NEARDIST*NEARDIST)
-				lseg->pv2 = &(p->pts[v2found]);
-			else
-			{
-				polyvertex_t *pv = HWR_AllocVertex();
-				pv->x = FIXED_TO_FLOAT(lseg->v2->x);
-				pv->y = FIXED_TO_FLOAT(lseg->v2->y);
-				lseg->pv2 = pv;
-			}
-
-			lseg->pv1->x2 = FloatToFixed(lseg->pv1->x);
-			lseg->pv1->y2 = FloatToFixed(lseg->pv1->y);
-			lseg->pv2->x2 = FloatToFixed(lseg->pv2->x);
-			lseg->pv2->y2 = FloatToFixed(lseg->pv2->y);
-		}
-	}
-}
-
 
 // call this routine after the BSP of a Doom wad file is loaded,
 // and it will generate all the convex polys for the hardware renderer
@@ -1017,7 +915,6 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
 #else
 	SolveTProblem();
 #endif
-	AdjustSegs();
 
 #ifdef DEBUG_HWBSP
 	//debug debug..

src/hardware/hw_cache.c

@@ -36,7 +36,7 @@
 INT32 patchformat = GL_TEXFMT_AP_88; // use alpha for holes
 INT32 textureformat = GL_TEXFMT_P_8; // use chromakey for hole
 
-RGBA_t mapPalette[256] = {0}; // the palette for the currently loaded level or menu etc.
+RGBA_t mapPalette[256] = {}; // the palette for the currently loaded level or menu etc.
 
 static void HWR_FreeTextureColormaps(patch_t *patch);
 
@@ -162,7 +162,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = mipmap->data;
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -212,7 +212,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = mipmap->data;
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -287,8 +287,8 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	UINT16 bu16 = ((0x00 <<8) | HWR_PATCHES_CHROMAKEY_COLORINDEX);
 	INT32 blocksize = (glMipmap->width * glMipmap->height);
 
-	bpp =  format2bpp(glMipmap->format);
-	block = Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data));
+	bpp = format2bpp(glMipmap->format);
+	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
 
 	switch (bpp)
 	{
@@ -325,7 +325,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];
 
 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = textureformat;
+	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
 
 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -344,9 +344,9 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif
 
-	gltex->mipmap.colormap = Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL);
+	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
-	M_Memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
+	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
 
 	blockwidth = texture->width;
 	blockheight = texture->height;
@@ -377,7 +377,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL);
+		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;
 
 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -413,7 +413,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;
 
 		// setup the texture info
-		glMipmap->format = patchformat;
+		glMipmap->format = (GLTextureFormat_t)(patchformat);
 
 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -455,12 +455,13 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;
 
-	glPatch = patch->hardware;
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
 
 	Z_Free(glPatch->mipmap->data);
+	glPatch->mipmap->data = NULL;
 }
 
 void HWR_FreeTexture(patch_t *patch)
@@ -470,7 +471,7 @@ void HWR_FreeTexture(patch_t *patch)
 
 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = patch->hardware;
+		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 		HWR_FreeTextureColormaps(patch);
 
@@ -478,6 +479,7 @@ void HWR_FreeTexture(patch_t *patch)
 		{
 			HWR_FreeTextureData(patch);
 			Z_Free(glPatch->mipmap);
+			glPatch->mipmap = NULL;
 		}
 
 		Z_Free(patch->hardware);
@@ -495,7 +497,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;
 
-	pat = patch->hardware;
+	pat = (GLPatch_t *)(patch->hardware);
 	if (!pat)
 		return;
 
@@ -577,6 +579,9 @@ void HWR_InitMapTextures(void)
 
 static void FreeMapTexture(GLMapTexture_t *tex)
 {
+	if (!tex)
+		return;
+
 	GL_DeleteTexture(&tex->mipmap);
 	Z_Free(tex->mipmap.data);
 	tex->mipmap.data = NULL;
@@ -586,6 +591,12 @@ void HWR_FreeMapTextures(void)
 {
 	size_t i;
 
+	if (!gl_textures)
+	{
+		gl_numtextures = 0;
+		return;
+	}
+
 	for (i = 0; i < gl_numtextures; i++)
 	{
 		FreeMapTexture(&gl_textures[i].normal);
@@ -596,15 +607,22 @@ void HWR_FreeMapTextures(void)
 
 	// now the heap don't have any 'user' pointing to our
 	// texturecache info, we can free it
-	if (gl_textures)
-		free(gl_textures);
+	free(gl_textures);
 	gl_textures = NULL;
 	gl_numtextures = 0;
 }
 
+#define NAME    flatcheck
+#define KEY_TY  UINT32
+#define HASH_FN vt_hash_integer
+#define CMPR_FN vt_cmpr_integer
+#include "../verstable.h"
+
 static void HWR_PrecacheLevelFlats(void)
 {
-	lumpnum_t lump;
+	// lookup for flats that may´ve been already loaded
+	flatcheck flatpresent;
+	flatcheck_init(&flatpresent);
 	size_t i, j;
 	INT32 k;
 
@@ -625,15 +643,23 @@ static void HWR_PrecacheLevelFlats(void)
 
 				const levelflat_t *levelflat = &levelflats[pic];
 
-				lump = levelflat->lumpnum;
-				HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
-
-				if (levelflat->speed) // it is an animated flat
+				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
 				{
-					for (k = 1; k < levelflat->numpics; k++)
+					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
+					flatcheck_insert(&flatpresent, levelflat->lumpnum);
+				}
+
+				if (levelflat->speed) // is it an animated flat ?
+				{
+					// start from 0, occasionally basenumlump != flat->lumpnum
+					for (k = 0; k < levelflat->numpics; k++)
 					{
-						lump = levelflat->baselumpnum + k;
-						HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
+						lumpnum_t lump = levelflat->baselumpnum + k;
+						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+						{
+							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
+							flatcheck_insert(&flatpresent, lump);
+						}
 					}
 				}
 			}
@@ -647,20 +673,30 @@ static void HWR_PrecacheLevelFlats(void)
 		for (i = 0; i < numlevelflats; i++)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
-			lump = levelflat->lumpnum;
 
-			HWR_GetFlat(lump, false);
-
-			if (!levelflat->speed) // is it an animated flat ?
-				continue;
-
-			for (k = 1; k < levelflat->numpics; k++)
+			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
 			{
-				lump = levelflat->baselumpnum + k;
-				HWR_GetFlat(lump, false);
+				HWR_GetFlat(levelflat->lumpnum, false);
+				flatcheck_insert(&flatpresent, levelflat->lumpnum);
+			}
+
+			if (levelflat->speed) // is it an animated flat ?
+			{
+				// start from 0, occasionally basenumlump != flat->lumpnum
+				for (k = 0; k < levelflat->numpics; k++)
+				{
+					lumpnum_t lump = levelflat->baselumpnum + k;
+					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+					{
+						HWR_GetFlat(lump, false);
+						flatcheck_insert(&flatpresent, lump);
+					}
+				}
 			}
 		}
 	}
+
+	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -670,7 +706,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;
 
-	texturepresent = calloc(numtextures, sizeof (*texturepresent));
+	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
 
@@ -701,7 +737,10 @@ static void HWR_PrecacheLevelTextures(void)
 			{
 				const INT32 texnum = sidetex[f];
 
-				if (texnum < 0 || texnum >= numtextures || texturepresent[texnum])
+				if (texnum < 0 || texnum >= (signed)gl_numtextures)
+					continue;
+
+				if (texturepresent[texnum])
 					continue;
 #ifdef GLENCORE
 				texturepresent[texnum] = 1|noencoremap;
@@ -729,14 +768,16 @@ static void HWR_PrecacheLevelTextures(void)
 
 		for (h = 1; h < anim->numpics; h++)
 		{
+			const INT32 animtexnum = anim->basepic+h;
+
 			if (texpresent & 1)
 			{
-				HWR_GetTexture(anim->basepic+h, false);
+				HWR_GetTexture(animtexnum, false);
 			}
 #ifdef GLENCORE
 			if (texpresent & 2)
 			{
-				HWR_GetTexture(anim->basepic+h, true);
+				HWR_GetTexture(animtexnum, true);
 			}
 #endif
 		}
@@ -818,11 +859,20 @@ void HWR_PrecacheLevel(void)
 	// Precache flats.
 	HWR_PrecacheLevelFlats();
 
+	// prevent timeouts
+	NetKeepAlive();
+
 	// Precache textures.
 	HWR_PrecacheLevelTextures();
 
+	// prevent timeouts
+	NetKeepAlive();
+
 	// Precache sprites.
 	//HWR_PrecacheLevelSprites();
+
+	// prevent timeouts
+	//NetKeepAlive();
 }
 
 void HWR_LoadMapTextures(size_t pnumtextures)
@@ -831,7 +881,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();
 
 	gl_numtextures = pnumtextures;
-	gl_textures = calloc(gl_numtextures, sizeof(*gl_textures)); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
+	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
 
 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -843,6 +893,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
 {
 	GLMapTexture_t *gltex;
+	GLMipmap_t *glMipmap;
 
 	if (tex < 0 || tex >= (signed)gl_numtextures)
 	{
@@ -861,19 +912,22 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
 	gltex = &gl_textures[tex];
 #endif
 
+	glMipmap = &gltex->mipmap;
+
 	// Generate texture if missing from the cache
-	if (!gltex->mipmap.downloaded)
+	if (!glMipmap->downloaded)
 	{
 		if (!gltex->mipmap.data)
 			HWR_GenerateTexture(tex, gltex, noencore);
 
 		// If hardware does not have the texture, then call GL_SetTexture to upload it
-		GL_SetTexture(&gltex->mipmap);
+		GL_SetTexture(glMipmap);
 	}
-	HWR_SetCurrentTexture(&gltex->mipmap);
+
+	HWR_SetCurrentTexture(glMipmap);
 
 	// The system-memory data can be purged now.
-	Z_ChangeTag(gltex->mipmap.data, PU_HWRCACHE_UNLOCKED);
+	Z_ChangeTag(glMipmap->data, PU_HWRCACHE_UNLOCKED);
 
 	return gltex;
 }
@@ -924,7 +978,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
 
 #ifdef GLENCORE
-	flat = glMipmap->data;
+	flat = (UINT8 *)(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -968,9 +1022,9 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
+		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
-		M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
+		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
 
 	if (!glMipmap->downloaded)
@@ -992,7 +1046,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = patch->hardware;
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (!glMipmap->downloaded)
 	{
@@ -1013,8 +1067,8 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *grPatch = patch->hardware;
-	HWR_MakePatch(patch, grPatch, glMipmap, true);
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	HWR_MakePatch(patch, glPatch, glMipmap, true);
 
 	// If hardware does not have the texture, then call GL_SetTexture to upload it
 	// If it does have the texture, then call GL_UpdateTexture to update it
@@ -1022,6 +1076,7 @@ static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 		GL_SetTexture(glMipmap);
 	else
 		GL_UpdateTexture(glMipmap);
+
 	HWR_SetCurrentTexture(glMipmap);
 
 	// The system-memory data can be purged now.
@@ -1048,7 +1103,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 
 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = patch->hardware;
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1068,7 +1123,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 		{
 			if (memcmp(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)))
 			{
-				M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
+				memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 				HWR_UpdatePatchMipmap(patch, glMipmap);
 			}
 			else
@@ -1084,14 +1139,14 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 	//              (it have a liste of mipmap)
 	//    this malloc is cleared in HWR_FreeColormapCache
 	//    (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
-	newMipmap = calloc(1, sizeof (*newMipmap));
+	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;
 
-	newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
+	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
-	M_Memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
+	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
 	HWR_LoadPatchMipmap(patch, newMipmap);
 }
@@ -1112,7 +1167,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 	{
 		void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
 		Patch_Create(NULL, 0, ptr);
-		Patch_AllocateHardwarePatch(ptr);
+		Patch_AllocateHardwarePatch((patch_t *)(ptr));
 	}
 
 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1129,7 +1184,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = mipmap->data; // places the data directly into here
+	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1285,9 +1340,9 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = Z_Malloc(
+	UINT8 *lut = (UINT8 *)(Z_Malloc(
 		HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
-		PU_STATIC, NULL);
+		PU_STATIC, NULL));
 #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
 	for (b = 0; b < HWR_PALETTE_LUT_SIZE; b++)
 	{
@@ -1330,7 +1385,7 @@ void HWR_SetMapPalette(void)
 		if (palsize < 768) // 256 * 3
 			I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
 
-		RGB_data = W_CacheLumpNum(lumpnum, PU_CACHE);
+		RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
 		// we got the RGB palette now, but we need it in RGBA format.
 		for (i = 0; i < 256; i++)
 		{
@@ -1365,7 +1420,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL);
+	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
 
 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.

src/hardware/hw_clip.c

@@ -80,14 +80,13 @@
 
 
 typedef struct clipnode_s
-	{
-		struct clipnode_s *prev, *next;
-		angle_t start, end;
-	} clipnode_t;
+{
+	struct clipnode_s *prev, *next;
+	angle_t start, end;
+} clipnode_t;
 
-clipnode_t *freelist;
-clipnode_t *clipnodes;
-clipnode_t *cliphead;
+static clipnode_t *freelist;
+static clipnode_t *cliphead;
 
 static clipnode_t * gld_clipnode_GetNew(void);
 static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end);
@@ -167,6 +166,7 @@ static void gld_clipper_RemoveRange(clipnode_t *range)
 		{
 			range->prev->next = range->next;
 		}
+
 		if (range->next)
 		{
 			range->next->prev = range->prev;
@@ -178,7 +178,7 @@ static void gld_clipper_RemoveRange(clipnode_t *range)
 
 void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle)
 {
-	if(startangle > endangle)
+	if (startangle > endangle)
 	{
 		// The range has to added in two parts.
 		gld_clipper_AddClipRange(startangle, ANGLE_MAX);
@@ -320,7 +320,7 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 	double floatangle;
 	angle_t a1;
 
-	float tilt = (float)fabs(((double)(int)tiltangle) / ANG1);
+	float tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
 
 	if (tilt > 90.0f)
 		tilt = 90.0f;
@@ -331,11 +331,11 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 
 	// ok, this is a gross hack that barely works...
 	// but at least it doesn't overestimate too much...
-	clipfov = atan(1 / (GLdouble)projMatrix[0]) * 360.0 / M_PIl;
+	clipfov = atan(1 / (GLdouble)projMatrix[0]) * 360.0 / M_PI;
 	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;
 }
 
@@ -349,33 +349,32 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 // gld_FrustumSetup
 //
 
-static GLdouble viewMatrix[16];
-static GLdouble projMatrix[16];
-float frustum[6][4];
+static float frustum[6][4];
 
 #define CALCMATRIX(a, b, c, d, e, f, g, h)\
-(float)(viewMatrix[a] * projMatrix[b] + \
-viewMatrix[c] * projMatrix[d] + \
-viewMatrix[e] * projMatrix[f] + \
-viewMatrix[g] * projMatrix[h])
+	(modelMatrix[a] * projMatrix[b] + \
+	modelMatrix[c] * projMatrix[d] + \
+	modelMatrix[e] * projMatrix[f] + \
+	modelMatrix[g] * projMatrix[h])
 
 #define NORMALIZE_PLANE(i)\
-t = (float)sqrt(\
-frustum[i][0] * frustum[i][0] + \
-frustum[i][1] * frustum[i][1] + \
-frustum[i][2] * frustum[i][2]); \
-frustum[i][0] /= t; \
-frustum[i][1] /= t; \
-frustum[i][2] /= t; \
-frustum[i][3] /= t
+	t = sqrtf(\
+		frustum[i][0] * frustum[i][0] + \
+		frustum[i][1] * frustum[i][1] + \
+		frustum[i][2] * frustum[i][2]); \
+	frustum[i][0] /= t; \
+	frustum[i][1] /= t; \
+	frustum[i][2] /= t; \
+	frustum[i][3] /= t
 
 void gld_FrustumSetup(void)
 {
 	float t;
 	float clip[16];
 
-	pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
-	pglGetFloatv(GL_MODELVIEW_MATRIX, viewMatrix);
+	// HWR_SetTransform will take care of this!
+	//pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
+	//pglGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix);
 
 	clip[0]  = CALCMATRIX(0, 0, 1, 4, 2, 8, 3, 12);
 	clip[1]  = CALCMATRIX(0, 1, 1, 5, 2, 9, 3, 13);

src/hardware/hw_clip.h

@@ -16,7 +16,7 @@ extern "C" {
 #include "../tables.h"
 #include "../doomtype.h"
 
-//#define HAVE_SPHEREFRUSTRUM // enable if you want gld_SphereInFrustum and related code
+#define HAVE_SPHEREFRUSTRUM // enable if you want gld_SphereInFrustum and related code
 
 boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle);
 void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle);

src/hardware/hw_data.h

@@ -54,7 +54,7 @@ struct GLMipmap_s
 	UINT16					width, height;
 	UINT32					downloaded; // The GPU has this texture.
 
-	struct	GLMipmap_s		*nextcolormap;
+	struct GLMipmap_s		*nextcolormap;
 	struct GLColormap_s		*colormap;
 };
 typedef struct GLMipmap_s GLMipmap_t;
@@ -65,7 +65,7 @@ typedef struct GLMipmap_s GLMipmap_t;
 struct GLMapTexture_s
 {
 	GLMipmap_t		mipmap;
-	float			scaleX; //used for scaling textures on walls
+	float			scaleX; // used for scaling textures on walls
 	float			scaleY;
 };
 typedef struct GLMapTexture_s GLMapTexture_t;
@@ -74,7 +74,7 @@ typedef struct GLMapTexture_s GLMapTexture_t;
 struct GLPatch_s
 {
 	GLMipmap_t			*mipmap;
-	float				max_s,max_t;
+	float				max_s, max_t;
 };
 typedef struct GLPatch_s GLPatch_t;
 

src/hardware/hw_defs.h

@@ -79,7 +79,7 @@ typedef struct FColorARGB FColorARGB;
 // Simple 2D coordinate
 typedef struct
 {
-	FLOAT x,y;
+	FLOAT x, y;
 } F2DCoord, v2d_t;
 
 // ======================
@@ -117,7 +117,7 @@ typedef struct
 
 typedef struct
 {
-	FLOAT       x,y,z;           // position
+	FLOAT       x, y, z;           // position
 	FLOAT       anglex, angley, anglez;   // aimingangle / viewangle
 	FLOAT       scalex, scaley, scalez;
 	FLOAT       fovangle;
@@ -142,8 +142,8 @@ enum
 // Transformed vector, as passed to HWR API
 typedef struct
 {
-	FLOAT       x,y,z;
-	FLOAT       s,t;
+	FLOAT       x, y, z;
+	FLOAT       s, t;
 } FOutVector;
 
 typedef struct vbo_vertex_s
@@ -173,7 +173,7 @@ typedef struct
 	int rows, columns;
 	int loopcount;
 
-	int detail, vertex_count;
+	int vertex_count;
 	int texture, width, height;
 	boolean rebuild; // VBO needs to be rebuilt
 

src/hardware/hw_dll.h

@@ -1,67 +0,0 @@
-// Emacs style mode select   -*- C++ -*-
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) 2005 by SRB2 Jr. Team.
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//-----------------------------------------------------------------------------
-/// \file
-/// \brief Win32 DLL and Shared Objects API definitions
-
-#ifndef __HWR_DLL_H__
-#define __HWR_DLL_H__
-
-// Function declaration for exports from the DLL :
-// EXPORT <return-type> HWRAPI(<function-name>) (<arguments>);
-// If _CREATE_DLL_ is defined the above declaration translates to :
-// __declspec(dllexport) <return-type> WINAPI <function-name> (<arguments>);
-// If _CREATE_DLL_ is NOT DEFINED the above declaration translates to :
-// __declspec(dllexport) <return->type> (WINAPI *<function-name>) (<arguments>);
-
-#ifdef _CREATE_DLL_
- #ifdef __cplusplus
-  #define EXPORT  extern "C"
- #else
-  #define EXPORT
- #endif
- #ifdef _WIN32
-  #define HWRAPI(fn)  WINAPI fn
- #else
-  #define HWRAPI(fn)  fn
- #endif
-#else // _CREATE_DLL_
- #define EXPORT      typedef
- #ifdef _WIN32
-  #define HWRAPI(fn)  (WINAPI *fn)
- #else
-  #define HWRAPI(fn)  (*fn)
- #endif
-#endif
-
-// ==========================================================================
-//                                                                      MATHS
-// ==========================================================================
-
-// Constants
-#define DEGREE (0.017453292519943295769236907684883l) // 2*PI/360
-
-void GL_DBG_Printf(const char *format, ...) /*FUNCPRINTF*/;
-#define DBG_Printf GL_DBG_Printf
-
-#if defined (__CYGWIN__)
-void _init() __attribute__((constructor));
-void _fini() __attribute__((destructor));
-#else
-void _init();
-void _fini();
-#endif
-
-#endif

src/hardware/hw_draw.c

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

src/hardware/hw_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.h

@@ -102,8 +102,7 @@ void HWR_SetViewSize(void);
 void HWR_AddCommands(void);
 
 void HWR_RenderPlayerView(void);
-void HWR_RenderViewpoint(gl_portal_t *rootportal, player_t *player, int stencil_level, boolean allow_portals);
-void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, player_t *player, int stencil_level, boolean allow_portals);
+void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, int stencil_level, boolean allow_portals);
 
 void HWR_ClearSkyDome(void);
 void HWR_BuildSkyDome(void);
@@ -209,7 +208,6 @@ extern consvar_t cv_glportals;
 
 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
-extern consvar_t cv_glflashpal;
 
 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -221,11 +219,6 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }
 
-FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
-{
-	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
-}
-
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {

src/hardware/hw_md2.c

@@ -72,10 +72,9 @@
 #include <errno.h>
 #endif
 
-md2_t md2_models[NUMSPRITES];
-md2_t md2_playermodels[MAXSKINS];
-md2_t md2_localplayermodels[MAXLOCALSKINS];
-
+md2_t md2_models[NUMSPRITES] = {};
+md2_t md2_playermodels[MAXSKINS] = {};
+md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
 
 /*
  * free model
@@ -417,7 +416,7 @@ static void md2_loadTexture(md2_t *model)
 			size = w*h;
 			while (size--)
 			{
-				V_CubeApply(&image->s.red, &image->s.green, &image->s.blue);
+				V_CubeApply(image);
 				image++;
 			}
 		}
@@ -580,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];
@@ -694,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)
 	{
@@ -717,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;
@@ -1038,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
@@ -1058,7 +1050,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
 			{
 				if (memcmp(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)))
 				{
-					M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
+					memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 					HWR_CreateBlendedTexture(patch, blendgpatch, glMipmap, skinnum, color);
 					GL_UpdateTexture(glMipmap);
 				}
@@ -1085,7 +1077,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
 
 	newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
 	newMipmap->colormap->source = colormap;
-	M_Memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
+	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
 	HWR_CreateBlendedTexture(patch, blendgpatch, newMipmap, skinnum, color);
 
@@ -1107,7 +1099,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	INT32 frame = 0;
 	INT32 nextFrame = -1;
 	FTransform p;
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	if (!cv_glmdls.value || spr->precip)
 		return;
@@ -1199,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
@@ -1337,8 +1336,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		if (spr->mobj->frame & FF_ANIMATE)
 		{
 			// set duration and tics to be the correct values for FF_ANIMATE states
-			durs = (float)spr->mobj->state->var2;
-			tics = (float)spr->mobj->anim_duration;
+			durs = spr->mobj->state->var2;
+			tics = (INT32)spr->mobj->anim_duration;
 		}
 
 		//FIXME: this is not yet correct
@@ -1469,4 +1468,115 @@ 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);
+
+	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,12 +237,12 @@ 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;
 
-			M_Memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
+			memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
 
 			for (k = 0; k < mesh->numVertices; k++)
 			{
@@ -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
@@ -402,7 +402,7 @@ void Optimize(model_t *model)
 				char *destByte;
 				char *srcByte;
 
-				M_Memcpy(&newMesh->uvs[uvCount],
+				memcpy(&newMesh->uvs[uvCount],
 					curMesh->uvs,
 					sizeof(float)*2*curMesh->numTriangles*3);
 
@@ -410,13 +410,13 @@ void Optimize(model_t *model)
 
 				dest = (float*)newMesh->frames[0].vertices;
 				src = (float*)curMesh->frames[0].vertices;
-				M_Memcpy(&dest[vertCount],
+				memcpy(&dest[vertCount],
 					src,
 					sizeof(float)*3*curMesh->numTriangles*3);
 
 				dest = (float*)newMesh->frames[0].normals;
 				src = (float*)curMesh->frames[0].normals;
-				M_Memcpy(&dest[vertCount],
+				memcpy(&dest[vertCount],
 					src,
 					sizeof(float)*3*curMesh->numTriangles*3);
 
@@ -427,7 +427,7 @@ void Optimize(model_t *model)
 
 				if (srcByte)
 				{
-					M_Memcpy(&destByte[colorCount],
+					memcpy(&destByte[colorCount],
 						srcByte,
 						sizeof(char)*4*curMesh->numTriangles*3);
 				}

src/hardware/hw_portal.c

@@ -30,7 +30,7 @@
 
 SINT8 gl_portal_state = GLPORTAL_OFF;
 
-gl_portallist_t *currentportallist;
+gl_portallist_t *currentportallist = NULL;
 
 // clip the area outside the portal destination window
 void HWR_PortalClipping(gl_portal_t *portal)
@@ -38,7 +38,7 @@ void HWR_PortalClipping(gl_portal_t *portal)
 	gld_clipper_SafeAddClipRange(portal->angle1, portal->angle2);
 }
 
-static gl_portal_t* HWR_Portal_Add (seg_t *seg)
+static gl_portal_t* HWR_Portal_Add(seg_t *seg)
 {
 	gl_portal_t *portal = Z_Malloc(sizeof(gl_portal_t), PU_STATIC, NULL);
 
@@ -120,8 +120,8 @@ void HWR_PortalFrame(gl_portal_t* portal)
 	viewz = portal->viewz;
 
 	viewangle = portal->viewangle;
-	//viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT);
-	//viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
+	viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT);
+	viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
 
 	if (portal->clipline != -1)
 	{
@@ -157,7 +157,7 @@ static void HWR_RenderPortalSeg(gl_portal_t* portal, SINT8 state)
 }
 
 // Renders a single portal from the current viewpoint.
-void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, player_t *player, int stencil_level)
+void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, int stencil_level)
 {
 	// draw portal seg to stencil buffer with increment
 	HWR_SetTransform(fpov);
@@ -168,8 +168,10 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
 
 	// go to portal frame lmao
 	HWR_PortalFrame(portal);
+
 	// call HWR_RenderViewpoint
-	HWR_RenderPortalViewpoint(portal, player, stencil_level + 1, true);
+	HWR_RenderPortalViewpoint(portal, stencil_level + 1, true);
+
 	// return to current frame
 	if (rootportal)
 		HWR_PortalFrame(rootportal);

src/hardware/hw_portal.h

@@ -65,7 +65,7 @@ extern SINT8 gl_portal_state;
 // new thing
 extern gl_portallist_t *currentportallist;
 
-static inline void HWR_SetPortalState (SINT8 state)
+static inline void HWR_SetPortalState(SINT8 state)
 {
 	gl_portal_state = state;
 }
@@ -75,7 +75,7 @@ void HWR_PortalClipping(gl_portal_t *portal);
 
 void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg);
 void HWR_PortalFrame(gl_portal_t* portal);
-void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, player_t *player, int stencil_level);
+void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, int stencil_level);
 void HWR_FreePortalList(gl_portallist_t portallist);
 
 boolean HWR_PortalCheckPointSide(fixed_t x, fixed_t y);

src/hardware/hw_shaders.c

@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	char *location = strstr(str1, str2);
+	gconst char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else
@@ -201,7 +201,7 @@ static char *HWR_PreprocessShader(char *original)
 				CONS_Alert(CONS_ERROR, "HWR_PreprocessShader: Syntax error in #version. Expected version with 3 digits, but got %d digits.\n", version_number_len);
 				return NULL;
 			}
-			M_Memcpy(shader_glsl_version, read_pos, 3);
+			memcpy(shader_glsl_version, read_pos, 3);
 			ADVANCE(version_number_len)
 			version_len = (read_pos - original) - version_pos;
 			whitespace_len = strspn(read_pos, WHITESPACE_CHARS);
@@ -304,7 +304,7 @@ static char *HWR_PreprocessShader(char *original)
 	{
 		strcpy(write_pos, VERSION_PART);
 		write_pos += sizeof(VERSION_PART) - 1;
-		M_Memcpy(write_pos, shader_glsl_version, 3);
+		memcpy(write_pos, shader_glsl_version, 3);
 		write_pos += 3;
 		strcpy(write_pos, line_ending);
 		write_pos += line_ending_len;
@@ -344,7 +344,7 @@ static char *HWR_PreprocessShader(char *original)
 	}
 
 	// Copy the original shader.
-	M_Memcpy(write_pos, read_pos, original_len);
+	memcpy(write_pos, read_pos, original_len);
 
 	// Erase the original #version directive, if it exists and was copied.
 	if (new_len != original_len && version_pos != -1)
@@ -573,7 +573,7 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
 	size = W_LumpLengthPwad(wadnum, lump);
 
 	line = Z_Malloc(size+1, PU_STATIC, NULL);
-	M_Memcpy(line, shaderdef, size);
+	memcpy(line, shaderdef, size);
 	line[size] = '\0';
 
 	stoken = strtok(line, "\r\n ");

src/hardware/r_opengl/r_opengl.c

@@ -25,7 +25,7 @@
 
 // Eeeeh not sure is this right way, but it works < sry :c < sry again it had to go :c
 
-#if defined (HWRENDER) && !defined (NOROPENGL)
+#if defined (HWRENDER)
 
 #include "../../r_fps.h" // For R_GetTimeFrac, used for the leveltime shader uniform
 
@@ -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]; // 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()
@@ -110,6 +110,7 @@ GLint   screen_texsizew  = 512; // Power-of-two screen texture render resolution
 GLint   screen_texsizeh  = 512; // Power-of-two screen texture render resolution
 GLbyte  screen_depth     = 0;
 GLint maximumAnisotropy  = 0;
+boolean supportNPO2tex   = false;
 static GLboolean MipMap  = GL_FALSE;
 static GLint min_filter  = GL_LINEAR;
 static GLint mag_filter  = GL_LINEAR;
@@ -126,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;-)
-static GLfloat modelMatrix[16];
-GLfloat projMatrix[16];
-static GLint   viewport[4];
+GLfloat modelMatrix[16] = {};
+GLfloat projMatrix[16] = {};
+static GLint viewport[4];
 
 #ifdef USE_FBO_OGL
 enum
@@ -170,43 +171,9 @@ 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] = {};
 
-// shortcut for ((float)1/i)
-static const GLfloat byte2float[256] = {
-	0.000000f, 0.003922f, 0.007843f, 0.011765f, 0.015686f, 0.019608f, 0.023529f, 0.027451f,
-	0.031373f, 0.035294f, 0.039216f, 0.043137f, 0.047059f, 0.050980f, 0.054902f, 0.058824f,
-	0.062745f, 0.066667f, 0.070588f, 0.074510f, 0.078431f, 0.082353f, 0.086275f, 0.090196f,
-	0.094118f, 0.098039f, 0.101961f, 0.105882f, 0.109804f, 0.113725f, 0.117647f, 0.121569f,
-	0.125490f, 0.129412f, 0.133333f, 0.137255f, 0.141176f, 0.145098f, 0.149020f, 0.152941f,
-	0.156863f, 0.160784f, 0.164706f, 0.168627f, 0.172549f, 0.176471f, 0.180392f, 0.184314f,
-	0.188235f, 0.192157f, 0.196078f, 0.200000f, 0.203922f, 0.207843f, 0.211765f, 0.215686f,
-	0.219608f, 0.223529f, 0.227451f, 0.231373f, 0.235294f, 0.239216f, 0.243137f, 0.247059f,
-	0.250980f, 0.254902f, 0.258824f, 0.262745f, 0.266667f, 0.270588f, 0.274510f, 0.278431f,
-	0.282353f, 0.286275f, 0.290196f, 0.294118f, 0.298039f, 0.301961f, 0.305882f, 0.309804f,
-	0.313726f, 0.317647f, 0.321569f, 0.325490f, 0.329412f, 0.333333f, 0.337255f, 0.341176f,
-	0.345098f, 0.349020f, 0.352941f, 0.356863f, 0.360784f, 0.364706f, 0.368627f, 0.372549f,
-	0.376471f, 0.380392f, 0.384314f, 0.388235f, 0.392157f, 0.396078f, 0.400000f, 0.403922f,
-	0.407843f, 0.411765f, 0.415686f, 0.419608f, 0.423529f, 0.427451f, 0.431373f, 0.435294f,
-	0.439216f, 0.443137f, 0.447059f, 0.450980f, 0.454902f, 0.458824f, 0.462745f, 0.466667f,
-	0.470588f, 0.474510f, 0.478431f, 0.482353f, 0.486275f, 0.490196f, 0.494118f, 0.498039f,
-	0.501961f, 0.505882f, 0.509804f, 0.513726f, 0.517647f, 0.521569f, 0.525490f, 0.529412f,
-	0.533333f, 0.537255f, 0.541177f, 0.545098f, 0.549020f, 0.552941f, 0.556863f, 0.560784f,
-	0.564706f, 0.568627f, 0.572549f, 0.576471f, 0.580392f, 0.584314f, 0.588235f, 0.592157f,
-	0.596078f, 0.600000f, 0.603922f, 0.607843f, 0.611765f, 0.615686f, 0.619608f, 0.623529f,
-	0.627451f, 0.631373f, 0.635294f, 0.639216f, 0.643137f, 0.647059f, 0.650980f, 0.654902f,
-	0.658824f, 0.662745f, 0.666667f, 0.670588f, 0.674510f, 0.678431f, 0.682353f, 0.686275f,
-	0.690196f, 0.694118f, 0.698039f, 0.701961f, 0.705882f, 0.709804f, 0.713726f, 0.717647f,
-	0.721569f, 0.725490f, 0.729412f, 0.733333f, 0.737255f, 0.741177f, 0.745098f, 0.749020f,
-	0.752941f, 0.756863f, 0.760784f, 0.764706f, 0.768627f, 0.772549f, 0.776471f, 0.780392f,
-	0.784314f, 0.788235f, 0.792157f, 0.796078f, 0.800000f, 0.803922f, 0.807843f, 0.811765f,
-	0.815686f, 0.819608f, 0.823529f, 0.827451f, 0.831373f, 0.835294f, 0.839216f, 0.843137f,
-	0.847059f, 0.850980f, 0.854902f, 0.858824f, 0.862745f, 0.866667f, 0.870588f, 0.874510f,
-	0.878431f, 0.882353f, 0.886275f, 0.890196f, 0.894118f, 0.898039f, 0.901961f, 0.905882f,
-	0.909804f, 0.913726f, 0.917647f, 0.921569f, 0.925490f, 0.929412f, 0.933333f, 0.937255f,
-	0.941177f, 0.945098f, 0.949020f, 0.952941f, 0.956863f, 0.960784f, 0.964706f, 0.968628f,
-	0.972549f, 0.976471f, 0.980392f, 0.984314f, 0.988235f, 0.992157f, 0.996078f, 1.000000f
-};
+#define byte2float(byte) (GLfloat)(byte / 255.0f)
 
 // -----------------+
 // GL_DBG_Printf    : Output debug messages to debug log if DEBUG_TO_FILE is defined,
@@ -215,7 +182,7 @@ static const GLfloat byte2float[256] = {
 // -----------------+
 
 #ifdef DEBUG_TO_FILE
-FILE *gllogstream;
+FILE *gllogstream = NULL;
 #endif
 
 FUNCPRINTF void GL_DBG_Printf(const char *format, ...)
@@ -437,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;
@@ -778,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;
@@ -891,6 +866,8 @@ void SetupGLFunc4(void)
 	GetGLfunc(glUniform3fv);
 	GetGLfunc(glGetUniformLocation);
 
+	GetGLfunc(glOrtho);
+
 #ifdef GLDEBUGMESSAGE
 	GetGLfunc(glDebugMessageCallback);
 #endif
@@ -1022,11 +999,9 @@ boolean GL_CompileShader(int slot)
 	{
 		return true;
 	}
-	else
-	{
-		gl_shaders[slot].program = 0;
-		return false;
-	}
+
+	gl_shaders[slot].program = 0;
+	return false;
 }
 
 //
@@ -1068,6 +1043,7 @@ void GL_SetShader(int slot)
 		GL_UnSetShader();
 		return;
 	}
+
 	if (gl_allowshaders)
 	{
 		gl_shader_t *next_shader = &gl_shaders[slot]; // the gl_shader_t we are going to switch to
@@ -1129,7 +1105,7 @@ static void GL_SetNoTexture(void)
 // -----------------+
 static void GL_Perspective(GLfloat fovy, GLfloat aspect)
 {
-	GLfloat m[4][4] =
+	static GLfloat m[4][4] =
 	{
 		{ 1.0f, 0.0f, 0.0f, 0.0f},
 		{ 0.0f, 1.0f, 0.0f, 0.0f},
@@ -1137,7 +1113,6 @@ static void GL_Perspective(GLfloat fovy, GLfloat aspect)
 		{ 0.0f, 0.0f, 0.0f, 0.0f},
 	};
 
-	const GLfloat focallength = (GLfloat)(1.0f / (GLfloat)tan(fovy * (GLfloat)M_PIl / 360.0f));
 	const GLfloat deltaZ = FAR_CLIPPING_PLANE - NEAR_CLIPPING_PLANE;
 
 	if ((fabsf((float)deltaZ) < 1.0E-36f) || fpclassify(aspect) == FP_ZERO)
@@ -1145,6 +1120,8 @@ static void GL_Perspective(GLfloat fovy, GLfloat aspect)
 		return;
 	}
 
+	const GLfloat focallength = (1.0f / tanf(fovy * M_PIf / 360.0f));
+
 	m[0][0] = focallength / aspect;
 	m[1][1] = focallength;
 	m[2][2] = -(FAR_CLIPPING_PLANE + NEAR_CLIPPING_PLANE) / deltaZ;
@@ -1158,7 +1135,7 @@ static void GL_Perspective(GLfloat fovy, GLfloat aspect)
 // -----------------+
 void GL_SetModelView(GLint w, GLint h)
 {
-	GLint maxtexsize = 0;
+	static GLint maxtexsize = 0;
 	//GL_DBG_Printf("SetModelView(): %dx%d\n", (int)w, (int)h);
 
 	// The screen textures need to be flushed if the width or height change so that they be remade for the correct size
@@ -1176,14 +1153,24 @@ void GL_SetModelView(GLint w, GLint h)
 
 	screen_texsizew = screen_texsizeh = 512;
 
-	// look for power of two that is large enough for the screen
-	while (screen_texsizew < w)
-		screen_texsizew <<= 1;
+	if (supportNPO2tex)
+	{
+		screen_texsizew = screen_width;
+		screen_texsizeh = screen_height;
+	}
+	else
+	{
+		// look for power of two that is large enough for the screen
+		while (screen_texsizew < w)
+			screen_texsizew <<= 1;
 
-	while (screen_texsizeh < h)
-		screen_texsizeh <<= 1;
+		while (screen_texsizeh < h)
+			screen_texsizeh <<= 1;
+	}
+
+	if (!maxtexsize)
+		pglGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize); // Get the maximum supported texture size
 
-	pglGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize); // Get the maximum supported texture size
 	if ((screen_texsizew > maxtexsize || screen_texsizeh > maxtexsize) && maxtexsize > 0)
 	{
 		// The desired screen texture resolution is too big for the player's GPU!
@@ -1329,7 +1316,8 @@ void GL_DeleteTexture(GLMipmap_t *pTexInfo)
 
 	if (!pTexInfo)
 		return;
-	else if (pTexInfo->downloaded)
+
+	if (pTexInfo->downloaded)
 		pglDeleteTextures(1, (GLuint *)&pTexInfo->downloaded);
 
 	while (head)
@@ -1383,7 +1371,8 @@ void GL_Flush(void)
 	TexCacheTail = TexCacheHead = NULL; //Hurdler: well, TexCacheHead is already NULL
 	tex_downloaded = 0;
 
-	free(textureBuffer);
+	if (textureBuffer)
+		free(textureBuffer);
 	textureBuffer = NULL;
 	textureBufferSize = 0;
 }
@@ -1394,19 +1383,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	GLubyte         *where, *terminator;
+	gconst GLubyte *where, *terminator;
 
 	if (!extension || !start)
 		return 0;
 
-	where = (GLubyte *) strchr(extension, ' ');
+	where = (gconst GLubyte *)strchr(extension, ' ');
 
 	if (where || *extension == '\0')
 		return 0;
 
 	for (;;)
 	{
-		where = (GLubyte *) strstr((const char *) start, extension);
+		where = (gconst GLubyte *)strstr((const char *)start, extension);
 
 		if (!where)
 			break;
@@ -1489,14 +1478,14 @@ void GL_ReadScreenTexture(int tex, UINT8 *restrict dest, INT32 scale)
 // -----------------+
 void GL_SetPalette(RGBA_t *palette)
 {
-	INT32 i;
+	const size_t palsize = (sizeof(RGBA_t) * 256);
 
-	for (i = 0; i < 256; i++)
+	// on a palette change, you have to reload all of the textures
+	if (memcmp(myPaletteData, palette, palsize))
 	{
-		myPaletteData[i].s = palette[i].s;
+		memcpy(myPaletteData, palette, palsize);
+		GL_Flush();
 	}
-
-	GL_Flush();
 }
 
 // -----------------+
@@ -1537,6 +1526,7 @@ void GL_ClearBuffer(FBOOLEAN ColorMask, FBOOLEAN DepthMask, FBOOLEAN StencilMask
 
 		ClearMask |= GL_COLOR_BUFFER_BIT;
 	}
+
 	if (DepthMask)
 	{
 		pglClearDepth(1.0f);     //Hurdler: all that are permanen states
@@ -1548,7 +1538,7 @@ void GL_ClearBuffer(FBOOLEAN ColorMask, FBOOLEAN DepthMask, FBOOLEAN StencilMask
 	GL_SetBlend(DepthMask ? PF_Occlude | CurrentPolyFlags : CurrentPolyFlags&~PF_Occlude);
 
 	if (StencilMask)
-		ClearMask |= GL_STENCIL_BUFFER_BIT;// looks like sometimes stencil buffer needs clearing? had a problem with random black screens
+		ClearMask |= GL_STENCIL_BUFFER_BIT; // looks like sometimes stencil buffer needs clearing? had a problem with random black screens
 
 	pglClear(ClearMask);
 	pglEnableClientState(GL_VERTEX_ARRAY); // We always use this one
@@ -1573,11 +1563,11 @@ void GL_Draw2DLine(F2DCoord * v1, F2DCoord * v2, RGBA_t Color)
 
 	// This is the preferred, 'modern' way of rendering lines -- creating a polygon.
 	if (fabsf(v2->x - v1->x) > FLT_EPSILON)
-		angle = (float)atan((v2->y-v1->y)/(v2->x-v1->x));
+		angle = atanf((v2->y-v1->y)/(v2->x-v1->x));
 	else
 		angle = (float)N_PI_DEMI;
-	dx = (float)sin(angle) / (float)screen_width;
-	dy = (float)cos(angle) / (float)screen_height;
+	dx = sinf(angle) / (float)screen_width;
+	dy = cosf(angle) / (float)screen_height;
 
 	p[0] = v1->x - dx;  p[1] = -(v1->y + dy); p[2] = 1;
 	p[3] = v2->x - dx;  p[4] = -(v2->y + dy); p[5] = 1;
@@ -1592,18 +1582,21 @@ void GL_Draw2DLine(F2DCoord * v1, F2DCoord * v2, RGBA_t Color)
 	pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
 	pglEnable(GL_TEXTURE_2D);
 }
+
+static inline void Clamp2D(GLenum pname)
+{
+#ifdef GL_CLAMP_TO_EDGE
+	pglTexParameteri(GL_TEXTURE_2D, pname, GL_CLAMP_TO_EDGE);
+#else
+	pglTexParameteri(GL_TEXTURE_2D, pname, GL_CLAMP); // fallback clamp
+#endif
+}
+
 // -----------------+
 // SetBlend         : Set render mode
 // -----------------+
 // PF_Masked - we could use an ALPHA_TEST of GL_EQUAL, and alpha ref of 0,
 //             is it faster when pixels are discarded ?
-static void Clamp2D(GLenum pname)
-{
-	pglTexParameteri(GL_TEXTURE_2D, pname, GL_CLAMP); // fallback clamp
-#ifdef GL_CLAMP_TO_EDGE
-	pglTexParameteri(GL_TEXTURE_2D, pname, GL_CLAMP_TO_EDGE);
-#endif
-}
 
 static void GL_SetBlendEquation(GLenum mode)
 {
@@ -1752,14 +1745,6 @@ void GL_SetBlend(FBITFIELD PolyFlags)
 
 		if (Xor & PF_Modulated)
 		{
-#if defined (__unix__) || defined (UNIXCOMMON)
-			if (oglflags & GLF_NOTEXENV)
-			{
-				if (!(PolyFlags & PF_Modulated))
-					pglColor4ubv(white);
-			}
-			else
-#endif
 			if (PolyFlags & PF_Modulated)
 			{   // mix texture colour with Surface->PolyColor
 				pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
@@ -1814,47 +1799,72 @@ static void GL_AllocTextureBuffer(GLMipmap_t *pTexInfo)
 	}
 }
 
-#define PADDING_CHECK(offset, alphaCheck) { from = to + (offset); if ((alphaCheck)) from = NULL; else goto foundFrom; }
-
-static void PadRGBABitmap(RGBA_t *tex, UINT16 w, UINT16 h)
+static void PadRGBABitmap(RGBA_t *tex, UINT16 w, UINT16 h, UINT32 flags)
 {
-	INT32 i;
-	boolean notLeft, notRight, notTop, notBottom;
-	RGBA_t *to = tex - 1, *from;
+	INT32 i, c1, c2, idxAdd;
+	UINT16 c1size, c2size;
+	RGBA_t *current, *prev, *next, *first;
+	boolean ignorePrev, wrap;
 
-	for (i = 0; i < w * h; i++)
+	for (i = 0; i < 2; i++)
 	{
-		to++;
-		if (to->rgba != 0)
-			continue;
-		from = NULL;
+		c1size = i ? h : w;
+		c2size = i ? w : h;
+		idxAdd = i ? 1 : w;
+		wrap = i ? flags & TF_WRAPX : flags & TF_WRAPY;
 
-		notLeft = i % w != 0;
-		notRight = i % w != w - 1;
-		notTop = i / w != 0;
-		notBottom = i / w != h - 1;
-
-		if (notRight) PADDING_CHECK(1, from->s.alpha == 0) // Check +X
-		if (notBottom) PADDING_CHECK(w, from->s.alpha == 0) // Check +Y
-		if (notLeft) PADDING_CHECK(-1, from->s.alpha == 0) // Check -X
-		if (notTop) PADDING_CHECK(-w, from->s.alpha == 0) // Check -Y
-		if (notRight && notBottom) PADDING_CHECK(1 + w, from->s.alpha == 0) // Check +X+Y
-		if (notLeft && notBottom) PADDING_CHECK(-1 + w, from->s.alpha == 0) // Check -X+Y
-		if (notLeft && notTop) PADDING_CHECK(-1 - w, from->s.alpha == 0) // Check -X-Y
-		if (notRight && notTop) PADDING_CHECK(1 - w, from->s.alpha == 0) // Check +X-Y
-
-foundFrom:
-		if (from != NULL)
+		for (c1 = 0; c1 < c1size; c1++)
 		{
-			*to = *from;
-			to->s.alpha = 0;
+			if (i)
+			{
+				first = current = tex + (c1 * w);
+				prev = wrap ? tex + (w - 1 + c1 * w) : current;
+				next = tex + (1 + c1 * w);
+			}
+			else
+			{
+				first = current = tex + c1;
+				prev = wrap ? tex + (c1 + (h - 1) * w) : current;
+				next = tex + (c1 + w);
+			}
+
+			ignorePrev = false;
+
+			for (c2 = 0; c2 < c2size; c2++)
+			{
+				if (c2 == c2size - 1)
+					next = wrap ? first : current;
+
+				if (current->rgba)
+				{
+					ignorePrev = false;
+				}
+				else if (prev->rgba && !ignorePrev)
+				{
+					*current = *prev;
+					current->s.alpha = 0;
+					ignorePrev = true;
+				}
+				else if (next->rgba)
+				{
+					*current = *next;
+					current->s.alpha = 0;
+					ignorePrev = false;
+				}
+				else
+				{
+					ignorePrev = false;
+				}
+
+				prev = current;
+				current = next;
+				next += idxAdd;
+			}
 		}
 	}
 }
 
-#undef PADDING_CHECK
-
-static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD)
+static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD, UINT32 flags)
 {
 	if (tex == NULL)
 	{
@@ -1916,7 +1926,7 @@ static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD)
 		h /= 2;
 
 		if (padTexture)
-			PadRGBABitmap(tex, w, h);
+			PadRGBABitmap(tex, w, h, flags);
 
 		pglTexSubImage2D(GL_TEXTURE_2D, m + 1, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, tex);
 	}
@@ -1970,7 +1980,7 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 				{
 					if (chromakeyed && (*pImgData == HWR_PATCHES_CHROMAKEY_COLORINDEX))
 					{
-						tex[idx].s = (byteColor_t){0, 0, 0, 0};
+						memset(&tex[idx].s, 0, sizeof(byteColor_t));
 						pTexInfo->flags |= TF_TRANSPARENT; // there is a hole in it
 					}
 					else
@@ -1982,16 +1992,15 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 
 					if (texinfoformat != GL_TEXFMT_AP_88)
 						continue;
-					if (chromakeyed)
-						continue;
 
-					tex[idx].s.alpha = *pImgData;
+					if (!chromakeyed)
+						tex[idx].s.alpha = *pImgData;
 					pImgData++;
 				}
 			}
 
 			if (applyPadding)
-				PadRGBABitmap(tex, w, h);
+				PadRGBABitmap(tex, w, h, pTexInfo->flags);
 
 			break;
 		case GL_TEXFMT_RGBA:
@@ -2007,7 +2016,7 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 				ptex = tex;
 
 				if (applyPadding)
-					PadRGBABitmap(tex, w, h);
+					PadRGBABitmap(tex, w, h, pTexInfo->flags);
 			}
 
 			break;
@@ -2020,9 +2029,9 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 			{
 				for (i = 0; i < w; i++, idx++)
 				{
-					tex[idx].s.red   = *pImgData;
-					tex[idx].s.green = *pImgData;
-					tex[idx].s.blue  = *pImgData;
+					tex[idx].s.red =
+					tex[idx].s.green =
+					tex[idx].s.blue = *pImgData;
 					pImgData++;
 					tex[idx].s.alpha = *pImgData;
 					pImgData++;
@@ -2052,21 +2061,10 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 	pglBindTexture(GL_TEXTURE_2D, num);
 	tex_downloaded = num;
 
-	const int transparent = (pTexInfo->flags & TF_TRANSPARENT);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
+	pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
 
-	// disable texture filtering on any texture that has holes so there's no dumb borders or blending issues
-	if (transparent)
-	{
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	}
-	else
-	{
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
-	}
-
-	if (MipMap && !transparent) // No mipmaps on transparent stuff
+	if (MipMap)
 	{
 		pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 
@@ -2077,8 +2075,16 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
 
 		// Control the mipmap level of detail
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 5);
-		GenerateMipmaps(w, h, tex, 5);
+
+		if (pTexInfo->flags & TF_TRANSPARENT)
+		{
+			pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 0); // No mipmaps on transparent stuff
+		}
+		else
+		{
+			pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4);
+			GenerateMipmaps(w, h, tex, 4, pTexInfo->flags);
+		}
 	}
 	else
 	{
@@ -2112,7 +2118,8 @@ void GL_SetTexture(GLMipmap_t *pTexInfo)
 		GL_SetNoTexture();
 		return;
 	}
-	else if (pTexInfo->downloaded)
+
+	if (pTexInfo->downloaded)
 	{
 		if (pTexInfo->downloaded != tex_downloaded)
 		{
@@ -2212,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
@@ -2388,38 +2389,38 @@ static void GL_PreparePolygon(FSurfaceInfo *pSurf, FBITFIELD PolyFlags)
 
 	if (pSurf)
 	{
-		// If modulated, mix the surface colour to the texture
-		if (CurrentPolyFlags & PF_Modulated)
-			pglColor4ubv((GLubyte*)&pSurf->PolyColor.s);
-
 		// If the surface is either modulated or colormapped, or both
 		if (CurrentPolyFlags & (PF_Modulated | PF_ColorMapped))
 		{
-			poly.red   = byte2float[pSurf->PolyColor.s.red];
-			poly.green = byte2float[pSurf->PolyColor.s.green];
-			poly.blue  = byte2float[pSurf->PolyColor.s.blue];
-			poly.alpha = byte2float[pSurf->PolyColor.s.alpha];
-		}
+			// If modulated, mix the surface colour to the texture
+			if (CurrentPolyFlags & PF_Modulated)
+				pglColor4ubv((GLubyte*)&pSurf->PolyColor.s);
 
-		// Only if the surface is colormapped
-		if (CurrentPolyFlags & PF_ColorMapped)
-		{
-			tint.red   = byte2float[pSurf->TintColor.s.red];
-			tint.green = byte2float[pSurf->TintColor.s.green];
-			tint.blue  = byte2float[pSurf->TintColor.s.blue];
-			tint.alpha = byte2float[pSurf->TintColor.s.alpha];
+			poly.red   = byte2float(pSurf->PolyColor.s.red);
+			poly.green = byte2float(pSurf->PolyColor.s.green);
+			poly.blue  = byte2float(pSurf->PolyColor.s.blue);
+			poly.alpha = byte2float(pSurf->PolyColor.s.alpha);
 
-			fade.red   = byte2float[pSurf->FadeColor.s.red];
-			fade.green = byte2float[pSurf->FadeColor.s.green];
-			fade.blue  = byte2float[pSurf->FadeColor.s.blue];
-			fade.alpha = byte2float[pSurf->FadeColor.s.alpha];
-
-			if (pSurf->LightTableId && pSurf->LightTableId != lt_downloaded)
+			// Only if the surface is colormapped
+			if (CurrentPolyFlags & PF_ColorMapped)
 			{
-				pglActiveTexture(GL_TEXTURE2);
-				pglBindTexture(GL_TEXTURE_2D, pSurf->LightTableId);
-				pglActiveTexture(GL_TEXTURE0);
-				lt_downloaded = pSurf->LightTableId;
+				tint.red   = byte2float(pSurf->TintColor.s.red);
+				tint.green = byte2float(pSurf->TintColor.s.green);
+				tint.blue  = byte2float(pSurf->TintColor.s.blue);
+				tint.alpha = byte2float(pSurf->TintColor.s.alpha);
+
+				fade.red   = byte2float(pSurf->FadeColor.s.red);
+				fade.green = byte2float(pSurf->FadeColor.s.green);
+				fade.blue  = byte2float(pSurf->FadeColor.s.blue);
+				fade.alpha = byte2float(pSurf->FadeColor.s.alpha);
+
+				if (pSurf->LightTableId && pSurf->LightTableId != lt_downloaded)
+				{
+					pglActiveTexture(GL_TEXTURE2);
+					pglBindTexture(GL_TEXTURE_2D, pSurf->LightTableId);
+					pglActiveTexture(GL_TEXTURE0);
+					lt_downloaded = pSurf->LightTableId;
+				}
 			}
 		}
 	}
@@ -2459,12 +2460,10 @@ void GL_DrawIndexedTriangles(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT i
 	// the DrawPolygon variant of this has some code about polyflags and wrapping here but havent noticed any problems from omitting it?
 }
 
-static const boolean gl_ext_arb_vertex_buffer_object = true;
-
-#define NULL_VBO_VERTEX ((gl_skyvertex_t*)NULL)
-#define sky_vbo_x (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->x : &sky->data[0].x)
-#define sky_vbo_u (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->u : &sky->data[0].u)
-#define sky_vbo_r (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->r : &sky->data[0].r)
+//#define NULL_VBO_VERTEX ((gl_skyvertex_t*)NULL)
+#define sky_vbo_x ((void*)offsetof(gl_skyvertex_t, x))
+#define sky_vbo_u ((void*)offsetof(gl_skyvertex_t, u))
+#define sky_vbo_r ((void*)offsetof(gl_skyvertex_t, r))
 
 void GL_RenderSkyDome(gl_sky_t *sky)
 {
@@ -2476,30 +2475,23 @@ void GL_RenderSkyDome(gl_sky_t *sky)
 	if (sky->rebuild)
 	{
 		// delete VBO when already exists
-		if (gl_ext_arb_vertex_buffer_object)
-		{
-			if (sky->vbo)
-				pglDeleteBuffers(1, &sky->vbo);
-		}
+		if (sky->vbo)
+			pglDeleteBuffers(1, &sky->vbo);
 
-		if (gl_ext_arb_vertex_buffer_object)
-		{
-			// generate a new VBO and get the associated ID
-			pglGenBuffers(1, &sky->vbo);
+		// generate a new VBO and get the associated ID
+		pglGenBuffers(1, &sky->vbo);
 
-			// bind VBO in order to use
-			pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
+		// bind VBO in order to use
+		pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
 
-			// upload data to VBO
-			pglBufferData(GL_ARRAY_BUFFER, sky->vertex_count * sizeof(sky->data[0]), sky->data, GL_STATIC_DRAW);
-		}
+		// upload data to VBO
+		pglBufferData(GL_ARRAY_BUFFER, sky->vertex_count * sizeof(sky->data[0]), sky->data, GL_STATIC_DRAW);
 
 		sky->rebuild = false;
 	}
 
 	// bind VBO in order to use
-	if (gl_ext_arb_vertex_buffer_object)
-		pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
+	pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
 
 	// activate and specify pointers to arrays
 	pglVertexPointer(3, GL_FLOAT, sizeof(sky->data[0]), sky_vbo_x);
@@ -2543,8 +2535,7 @@ void GL_RenderSkyDome(gl_sky_t *sky)
 	pglColor4ubv(white);
 
 	// bind with 0, so, switch back to normal pointer operation
-	if (gl_ext_arb_vertex_buffer_object)
-		pglBindBuffer(GL_ARRAY_BUFFER, 0);
+	pglBindBuffer(GL_ARRAY_BUFFER, 0);
 
 	// deactivate color array
 	pglDisableClientState(GL_COLOR_ARRAY);
@@ -2941,24 +2932,24 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
 			pol = 0.0f;
 	}
 
-	poly.red    = byte2float[Surface->PolyColor.s.red];
-	poly.green  = byte2float[Surface->PolyColor.s.green];
-	poly.blue   = byte2float[Surface->PolyColor.s.blue];
-	poly.alpha  = byte2float[Surface->PolyColor.s.alpha];
+	poly.red    = byte2float(Surface->PolyColor.s.red);
+	poly.green  = byte2float(Surface->PolyColor.s.green);
+	poly.blue   = byte2float(Surface->PolyColor.s.blue);
+	poly.alpha  = byte2float(Surface->PolyColor.s.alpha);
 
 	pglColor4ubv((GLubyte*)&Surface->PolyColor.s);
 
 	GL_SetBlend(((poly.alpha < 1) ? Surface->PolyFlags : (PF_Masked|PF_Occlude))|PF_Modulated);
 
-	tint.red    = byte2float[Surface->TintColor.s.red];
-	tint.green  = byte2float[Surface->TintColor.s.green];
-	tint.blue   = byte2float[Surface->TintColor.s.blue];
-	tint.alpha  = byte2float[Surface->TintColor.s.alpha];
+	tint.red    = byte2float(Surface->TintColor.s.red);
+	tint.green  = byte2float(Surface->TintColor.s.green);
+	tint.blue   = byte2float(Surface->TintColor.s.blue);
+	tint.alpha  = byte2float(Surface->TintColor.s.alpha);
 
-	fade.red   = byte2float[Surface->FadeColor.s.red];
-	fade.green = byte2float[Surface->FadeColor.s.green];
-	fade.blue  = byte2float[Surface->FadeColor.s.blue];
-	fade.alpha = byte2float[Surface->FadeColor.s.alpha];
+	fade.red   = byte2float(Surface->FadeColor.s.red);
+	fade.green = byte2float(Surface->FadeColor.s.green);
+	fade.blue  = byte2float(Surface->FadeColor.s.blue);
+	fade.alpha = byte2float(Surface->FadeColor.s.alpha);
 
 	if (Surface->LightTableId && Surface->LightTableId != lt_downloaded)
 	{
@@ -3109,14 +3100,47 @@ 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     :
 // -----------------+
 void GL_SetTransform(FTransform *stransform)
 {
 	static boolean special_splitscreen;
-	GLdouble used_fov;
 	boolean shearing = false;
+	float used_fov;
 
 	pglLoadIdentity();
 
@@ -3166,7 +3190,8 @@ void GL_SetTransform(FTransform *stransform)
 	{
 		float dy = stransform->viewaiming * 2;
 
-		if (stransform->fliptype == TRANSFORM_FLIP || stransform->fliptype == TRANSFORM_MIRRORFLIP)
+		if (stransform->fliptype == TRANSFORM_FLIP
+			|| stransform->fliptype == TRANSFORM_MIRRORFLIP)
 			dy *= -1.0f;
 
 		pglTranslatef(0.0f, -dy/BASEVIDHEIGHT, 0.0f);
@@ -3174,11 +3199,13 @@ void GL_SetTransform(FTransform *stransform)
 
 	if (special_splitscreen)
 	{
-		used_fov = (float)(atan(tan(used_fov * M_PIl / 360) * 0.8) * 360 / M_PIl);
-		GL_Perspective((GLfloat)used_fov, 2*ASPECT_RATIO);
+		used_fov = (atanf(tanf(used_fov * M_PIf / 360.0f) * 0.8f) * 360.0f / M_PIf);
+		GL_Perspective(used_fov, 2*ASPECT_RATIO);
 	}
 	else
-		GL_Perspective((GLfloat)used_fov, ASPECT_RATIO);
+	{
+		GL_Perspective(used_fov, ASPECT_RATIO);
+	}
 
 	pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
 	pglMatrixMode(GL_MODELVIEW);
@@ -3312,8 +3339,8 @@ void GL_Framebuffer_Disable(void)
 	// delet our fbo
 	if (framebufferobject.fboobj)
 		pglDeleteFramebuffers(1, &framebufferobject.fboobj);
-
 	framebufferobject.fboobj = 0;
+
 	GL_Framebuffer_DeleteAttachments();
 }
 #endif
@@ -3443,7 +3470,7 @@ void GL_FlushScreenTextures(void)
 
 void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
 {
-	float fix[8];
+	static float fix[8];
 	float xfix, yfix;
 
 	if (gl_enable_screen_textures != 2)
@@ -3452,14 +3479,8 @@ void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
 	xfix = 1/((float)screen_texsizew/(float)screen_width);
 	yfix = 1/((float)screen_texsizeh/(float)screen_height);
 
-	fix[0] = 0.0f;
-	fix[1] = 0.0f;
-	fix[2] = 0.0f;
-	fix[3] = yfix;
-	fix[4] = xfix;
-	fix[5] = yfix;
-	fix[6] = xfix;
-	fix[7] = 0.0f;
+	fix[3] = fix[5] = yfix;
+	fix[4] = fix[6] = xfix;
 
 	pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 
@@ -3570,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;
@@ -3603,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;
@@ -3627,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;
@@ -3652,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);
@@ -3691,10 +3722,15 @@ 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
-	FRGBAFloat clearColour;
+	float xoff = 1.0f, yoff = 1.0f; // xoffset and yoffset for the polygon to have black bars around the screen
+
+	static float off[12] =
+	{
+		1.0f, 1.0f, 1.0f, 1.0f,
+		1.0f, 1.0f, 1.0f, 1.0f,
+		1.0f, 1.0f, 1.0f, 1.0f
+	};
 
-	static float off[12];
 	static float fix[8];
 
 	if (gl_enable_screen_textures != 2)
@@ -3709,42 +3745,27 @@ 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] = -xoff;
-	off[1] = -yoff;
-	off[2] = 1.0f;
-	off[3] = -xoff;
-	off[4] = yoff;
-	off[5] = 1.0f;
-	off[6] = xoff;
-	off[7] = yoff;
-	off[8] = 1.0f;
-	off[9] = xoff;
-	off[10] = -yoff;
-	off[11] = 1.0f;
+	off[0] = off[3]  = -xoff;
+	off[1] = off[10] = -yoff;
+	off[4] = off[7]  =  yoff;
+	off[6] = off[9]  =  xoff;
 
 	// float fix[8];
-	fix[0] = 0.0f;
-	fix[1] = 0.0f;
-	fix[2] = 0.0f;
-	fix[3] = yfix;
-	fix[4] = xfix;
-	fix[5] = yfix;
-	fix[6] = xfix;
-	fix[7] = 0.0f;
+	fix[3] = fix[5] = yfix;
+	fix[4] = fix[6] = xfix;
 
 	pglViewport(0, 0, width, height);
 
-	clearColour.red = clearColour.green = clearColour.blue = 0;
-	clearColour.alpha = 1;
+	FRGBAFloat clearColour = {0, 0, 0, 1};
 	GL_ClearBuffer(true, false, false, &clearColour);
 	GL_SetBlend(PF_NoDepthTest);
 

src/hardware/r_opengl/r_opengl.h

@@ -38,8 +38,6 @@ extern "C" {
 #endif
 #endif
 
-#define  _CREATE_DLL_  // necessary for Unix AND Windows
-
 #include "../../doomdef.h"
 #include "../hw_gl.h"
 #include "../../z_zone.h"
@@ -69,7 +67,6 @@ extern boolean supportstencil;
 void *GetGLFunc(const char *proc);
 boolean SetupGLfunc(void);
 void SetupGLFunc4(void);
-void GL_Flush(void);
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start);
 void GL_SetModelView(GLint w, GLint h);
 void GL_SetStates(void);
@@ -124,20 +121,12 @@ extern GLint			screen_width;
 extern GLint			screen_height;
 extern GLbyte			screen_depth;
 extern GLint			maximumAnisotropy;
+extern boolean			supportNPO2tex;
 extern boolean 			supportMipMap;
 
-/**	\brief OpenGL flags for video driver
-*/
-extern INT32            oglflags;
-
+extern GLfloat modelMatrix[16];
 extern GLfloat projMatrix[16];
 
-typedef enum
-{
-	GLF_NOZBUFREAD = 0x01,
-	GLF_NOTEXENV   = 0x02,
-} oglflags_t;
-
 #ifdef __cplusplus
 } // extern "C"
 #endif

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())
@@ -317,6 +318,7 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
+	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }
@@ -471,8 +473,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 +541,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

@@ -68,47 +68,47 @@
 //-------------------------------------------
 //              heads up font
 //-------------------------------------------
-patch_t *hu_font[HU_FONTSIZE];
-patch_t *kart_font[KART_FONTSIZE];	// SRB2kart
-patch_t *tny_font[HU_FONTSIZE];
-patch_t *tallnum[10]; // 0-9
+patch_t *hu_font[HU_FONTSIZE] = {};
+patch_t *kart_font[KART_FONTSIZE] = {};	// SRB2kart
+patch_t *tny_font[HU_FONTSIZE] = {};
+patch_t *tallnum[10] = {}; // 0-9
 
 // Level title and credits fonts
-patch_t *lt_font[LT_FONTSIZE];
-patch_t *cred_font[CRED_FONTSIZE];
+patch_t *lt_font[LT_FONTSIZE] = {};
+patch_t *cred_font[CRED_FONTSIZE] = {};
 
 // ping font
 // Note: I'd like to adress that at this point we might *REALLY* want to work towards a common drawString function that can take any font we want because this is really turning into a MESS. :V -Lat'
-patch_t *pingnum[10];
-patch_t *pinggfx[5];	// small ping graphic
-patch_t *pingmeasure[2]; // ping measurement graphic
+patch_t *pingnum[10] = {};
+patch_t *pinggfx[5] = {};	// small ping graphic
+patch_t *pingmeasure[2] = {}; // ping measurement graphic
 
-patch_t *ranknum[10]; // rank numbers
+patch_t *ranknum[10] = {}; // rank numbers
 
-patch_t *framecounter;
-patch_t *frameslash;	// framerate stuff. Used in screen.c
+patch_t *framecounter = NULL;
+patch_t *frameslash = NULL;	// framerate stuff. Used in screen.c
 
-static player_t *plr;
-boolean chat_on; // entering a chat message?
+patch_t *srb2back = NULL;
+
+static player_t *plr = NULL;
+boolean chat_on = false; // entering a chat message?
 static char w_chat_buf[HU_MAXMSGLEN + 1];
 static textinput_t w_chat;
 static boolean headsupactive = false;
-boolean hu_showscores; // draw rankings
+boolean hu_showscores = false; // draw rankings
 static char hu_tick;
-static tic_t hu_emoteanim = 0;
-#define MAXEMOTESUGGESTIONS 8
-static emote_t *emote_suggestions[MAXEMOTESUGGESTIONS] = {0};
+emote_autocomplete_t emote_autocomplete = {0};
 
-static huddrawlist_h luahuddrawlist_scores;
+static huddrawlist_h luahuddrawlist_scores = NULL;
 
-patch_t *rflagico;
-patch_t *bflagico;
-patch_t *rmatcico;
-patch_t *bmatcico;
-patch_t *tallminus;
+patch_t *rflagico = NULL;
+patch_t *bflagico = NULL;
+patch_t *rmatcico = NULL;
+patch_t *bmatcico = NULL;
+patch_t *tallminus = NULL;
 
 // song credits
-static patch_t *songcreditbg;
+static patch_t *songcreditbg = NULL;
 
 // -------
 // protos.
@@ -122,7 +122,7 @@ consvar_t cv_showspecstuff = {"showspecstuff", "No", CV_SAVE, CV_YesNo, NULL, 0,
 //                 KEYBOARD LAYOUTS FOR ENTERING TEXT
 //======================================================================
 
-char *shiftxform;
+char *shiftxform = NULL;
 
 char english_shiftxform[] =
 {
@@ -280,7 +280,7 @@ static void Command_Say_f(void);
 static void Command_Sayto_f(void);
 static void Command_Sayteam_f(void);
 static void Command_CSay_f(void);
-static void Got_Saycmd(UINT8 **p, INT32 playernum);
+static void Got_Saycmd(const UINT8 **p, INT32 playernum);
 
 void HU_LoadGraphics(void)
 {
@@ -291,6 +291,7 @@ void HU_LoadGraphics(void)
 		return;
 
 	j = HU_FONTSTART;
+
 	for (i = 0; i < HU_FONTSIZE; i++, j++)
 	{
 		// cache the heads-up font for entire game execution
@@ -361,21 +362,21 @@ void HU_LoadGraphics(void)
 			cred_font[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
 	}
 
-	//cache numbers too!
+	// cache numbers too!
 	for (i = 0; i < 10; i++)
 	{
 		sprintf(buffer, "STTNUM%d", i);
 		tallnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
 		sprintf(buffer, "PINGN%d", i);
-		pingnum[i] = (patch_t *) W_CachePatchName(buffer, PU_HUDGFX);
+		pingnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
 		sprintf(buffer, "OPPRNK0%d", i);
-		ranknum[i] = (patch_t *) W_CachePatchName(buffer, PU_HUDGFX);
+		ranknum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
 	}
 
 	// minus for negative tallnums
 	tallminus = (patch_t *)W_CachePatchName("STTMINUS", PU_HUDGFX);
 
-	songcreditbg = W_CachePatchName("K_SONGCR", PU_HUDGFX);
+	songcreditbg = (patch_t *)W_CachePatchName("K_SONGCR", PU_HUDGFX);
 
 	// cache ping gfx:
 	for (i = 0; i < 5; i++)
@@ -384,12 +385,15 @@ void HU_LoadGraphics(void)
 		pinggfx[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
 	}
 
-	pingmeasure[0] = W_CachePatchName("PINGD", PU_HUDGFX);
-	pingmeasure[1] = W_CachePatchName("PINGMS", PU_HUDGFX);
+	pingmeasure[0] = (patch_t *)W_CachePatchName("PINGD", PU_HUDGFX);
+	pingmeasure[1] = (patch_t *)W_CachePatchName("PINGMS", PU_HUDGFX);
 
 	// fps stuff
-	framecounter = W_CachePatchName("FRAMER", PU_HUDGFX);
-	frameslash  = W_CachePatchName("FRAMESL", PU_HUDGFX);;
+	framecounter = (patch_t *)W_CachePatchName("FRAMER", PU_HUDGFX);
+	frameslash  = (patch_t *)W_CachePatchName("FRAMESL", PU_HUDGFX);
+
+	// idk where else to put this lul
+	srb2back = (patch_t *)W_CachePatchName("SRB2BACK", PU_HUDGFX);
 }
 
 // Initialise Heads up
@@ -406,8 +410,10 @@ void HU_Init(void)
 	// set shift translation table
 	shiftxform = english_shiftxform;
 
-	luahuddrawlist_scores = LUA_HUD_CreateDrawList();
+	if (dedicated || rendermode == render_none)
+		return;
 
+	luahuddrawlist_scores = LUA_HUD_CreateDrawList();
 	HU_LoadGraphics();
 }
 
@@ -490,7 +496,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)
@@ -509,6 +517,7 @@ static void Chatlogsize_OnChange(void)
 	if (new_chat_log == NULL)
 	{
         free(chat_log);
+		chat_log = NULL;
 		return;
 	}
 	chat_log = new_chat_log;
@@ -589,12 +598,12 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 	}
 
 	// Only servers/admins can CSAY.
-	if(!server && !(IsPlayerAdmin(consoleplayer)))
+	if (!server && !(IsPlayerAdmin(consoleplayer)))
 		flags &= ~HU_CSAY;
 
 	// We handle HU_SERVER_SAY, not the caller.
 	flags &= ~HU_SERVER_SAY;
-	if(dedicated && !(flags & HU_CSAY))
+	if (dedicated && !(flags & HU_CSAY))
 		flags |= HU_SERVER_SAY;
 
 	buf[0] = target;
@@ -608,17 +617,20 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		strlcat(msg, COM_Argv(ix + usedargs), msgspace);
 	}
 
-	if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
+	const size_t msglength = strlen(msg);
+
+	if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
 	{
 		// what we're gonna do now is check if the node exists
 		// with that logic, characters 4 and 5 are our numbers:
 		const char *newmsg;
 		INT32 spc = 1; // used if nodenum[1] is a space.
-		char *nodenum = (char*) malloc(3);
+		CLEANUP(pfree) char *nodenum = (char*) malloc(3);
 		memcpy(nodenum, msg+3, 2);
 		nodenum[2] = '\0';
+
 		// check for undesirable characters in our "number"
-		if 	(((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
+		if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
 		{
 			// check if nodenum[1] is a space
 			if (nodenum[1] == ' ')
@@ -627,23 +639,21 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 			else
 			{
 				HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
-				free(nodenum);
 				return;
 			}
 		}
+
 		// I'm very bad at C, I swear I am, additional checks eww!
 		if (spc != 0)
 		{
 			if (msg[5] != ' ')
 			{
 				HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.", false);
-				free(nodenum);
 				return;
 			}
 		}
 
 		target = atoi((const char*) nodenum); // turn that into a number
-		free(nodenum);
 		//CONS_Printf("%d\n", target);
 
 		// check for target player, if it doesn't exist then we can't send the message!
@@ -654,12 +664,13 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 			HU_AddChatText(va("\x82NOTICE: \x80Player %d does not exist.", target), false); // same
 			return;
 		}
+
 		buf[0] = target;
 		newmsg = msg+5+spc;
 		strlcpy(msg, newmsg, HU_MAXMSGLEN + 1);
 	}
 
-	SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
+	SendNetXCmd(XD_SAY, buf, msglength + 1 + msg-buf);
 }
 
 /** Send a message to everyone.
@@ -879,11 +890,12 @@ const char *HU_SkinColorToConsoleColor(skincolors_t color)
   * \sa DoSayCommand
   * \author Graue <graue@oceanbase.org>
   */
-static void Got_Saycmd(UINT8 **p, INT32 playernum)
+static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 {
 	SINT8 target;
 	UINT8 flags;
 	const char *dispname;
+	char buf[HU_MAXMSGLEN + 1];
 	char *msg;
 	boolean action = false;
 	char *ptr;
@@ -893,8 +905,8 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 
 	target = READSINT8(*p);
 	flags = READUINT8(*p);
-	msg = (char *)*p;
-	SKIPSTRINGL(*p, HU_MAXMSGLEN + 1);
+	msg = buf;
+	READSTRINGN(*p, msg, HU_MAXMSGLEN + 1);
 
 	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
 	{
@@ -909,10 +921,12 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 		return;
 	}
 
+	const size_t msglength = strlen(msg);
+
 	//check for invalid characters (0x80 or above)
 	{
 		size_t i;
-		const size_t j = strlen(msg);
+		const size_t j = msglength;
 		for (i = 0; i < j; i++)
 		{
 			if (msg[i] & 0x80)
@@ -959,7 +973,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	}
 
 	// Handle "/me" actions, but only in messages to everyone.
-	if (target == 0 && strlen(msg) > 4 && strnicmp(msg, "/me ", 4) == 0)
+	if (target == 0 && msglength > 4 && strnicmp(msg, "/me ", 4) == 0)
 	{
 		msg += 4;
 		action = true;
@@ -1060,8 +1074,7 @@ static void Got_Saycmd(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
@@ -1081,7 +1094,6 @@ void HU_Ticker(void)
 		return;
 
 	hu_tick++;
-	hu_emoteanim++;
 	hu_tick &= 7; // currently only to blink chat input cursor
 
 	if (PLAYER1INPUTDOWN(gc_scores))
@@ -1141,10 +1153,12 @@ static boolean HU_clearChatSpaces(void)
 	size_t i = 0; // Used to just check our message
 	char c; // current character we're iterating.
 	boolean nothingbutspaces = true;
+	const size_t chatlength = strlen(w_chat_buf);
 
-	for (; i < strlen(w_chat_buf); i++) // iterate through message and eradicate all spaces that don't belong.
+	for (; i < chatlength; i++) // iterate through message and eradicate all spaces that don't belong.
 	{
 		c = w_chat_buf[i];
+
 		if (!c)
 			break; // if there's nothing, it's safe to assume our message has ended, so let's not waste any more time here.
 
@@ -1153,6 +1167,7 @@ static boolean HU_clearChatSpaces(void)
 			nothingbutspaces = false;
 		}
 	}
+
 	return nothingbutspaces;
 }
 
@@ -1199,11 +1214,11 @@ static void HU_SendChatMessage(void)
 		return;
 	}
 
-	size_t len = strlen(msg);
+	const size_t msglength = strlen(msg);
 
-	if (len >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
+	if (msglength >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
 	{
-		if (len > 6)
+		if (msglength > 6)
 			DoMute(msg+6);
 		else
 			HU_AddChatText("\x82NOTICE: \x80Usage: /mute <name|node>", false);
@@ -1211,7 +1226,7 @@ static void HU_SendChatMessage(void)
 		return;
 	}
 
-	if (len > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
+	if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
 	{
 		INT32 spc = 1; // used if nodenum[1] is a space.
 		const char *newmsg;
@@ -1333,6 +1348,7 @@ boolean HU_Responder(event_t *ev)
 			chat_on = true;
 			w_chat_buf[0] = 0;
 			M_TextInputInit(&w_chat, w_chat_buf, sizeof w_chat_buf);
+			memset(&emote_autocomplete, 0, sizeof(emote_autocomplete));
 			teamtalk = false;
 			chat_scrollmedown = true;
 			typelines = 1;
@@ -1345,6 +1361,7 @@ boolean HU_Responder(event_t *ev)
 			chat_on = true;
 			w_chat_buf[0] = 0;
 			M_TextInputInit(&w_chat, w_chat_buf, sizeof w_chat_buf);
+			memset(&emote_autocomplete, 0, sizeof(emote_autocomplete));
 			teamtalk = G_GametypeHasTeams();	// Don't teamtalk if we don't have teams.
 			chat_scrollmedown = true;
 			typelines = 1;
@@ -1370,9 +1387,9 @@ boolean HU_Responder(event_t *ev)
 		&& ev->data1 != gamecontrol[0][gc_talkkey][1]))
 			return false;
 
-		M_TextInputHandleEmotes(&w_chat, c, emote_suggestions, MAXEMOTESUGGESTIONS);
-
-		if (c == KEY_ENTER)
+		if (M_TextInputHandleEmotes(&w_chat, c, &emote_autocomplete))
+			; // Do nothing
+		else if (c == KEY_ENTER)
 		{
 			chat_on = false;
 			chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
@@ -1409,8 +1426,6 @@ boolean HU_Responder(event_t *ev)
 //                         HEADS UP DRAWING
 //======================================================================
 
-#define HU_DrawEmote(x, y, emote, flags) M_DrawEmote((x), (y), (emote), hu_emoteanim, (flags))
-
 // Precompile a wordwrapped string to any given width.
 // This is a muuuch better method than V_WORDWRAP.
 // again stolen and modified a bit from video.c, don't mind me, will need to rearrange this one day.
@@ -1469,6 +1484,7 @@ static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 			x = 0;
 		}
 	}
+
 	return newstring;
 }
 
@@ -1507,7 +1523,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
 			{
@@ -1539,19 +1555,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);
@@ -1583,7 +1601,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
 			{
@@ -1613,7 +1631,7 @@ static void HU_drawMiniChat(void)
 				if (cv_chatbacktint.value) // on request of wolfy
 					V_DrawFillConsoleMap(x + dx + 2, y+dy, EMOTEWIDTH, charheight, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);
 
-				HU_DrawEmote(x+dx+2, y+dy, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT|transflag);
+				M_DrawEmote(x+dx+2, y+dy, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT|transflag);
 				dx += EMOTEWIDTH - charwidth;
 
 				j += emotelen;
@@ -1628,16 +1646,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:
@@ -1689,7 +1708,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;
@@ -1698,7 +1717,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
 			{
@@ -1723,7 +1742,7 @@ static void HU_drawChatLog(INT32 offset)
 			{
 				if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
 				{
-					HU_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;
@@ -1743,10 +1762,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.
@@ -1789,6 +1808,7 @@ static void HU_DrawChat(void)
 	INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
 	UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
 	INT32 cflag = 0;
+	INT32 pm_offset = 0; // for cases when you type emote while also doing /pm
 	size_t select_start = 0, select_end = 0;
 	const char *ntalk = "Say: ", *ttalk = "Team: ";
 	const char *talk = ntalk;
@@ -1863,7 +1883,7 @@ static void HU_DrawChat(void)
 
 		if ((emote = M_VerifyEmote(w_chat_buf+i, &emotelen)))
 		{
-			HU_DrawEmote(chatx + c + 2, y-1, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT|t);
+			M_DrawEmote(chatx + c + 2, y-1, emote, V_SNAPTOBOTTOM|V_SNAPTOLEFT|t);
 			c += EMOTEWIDTH - charwidth;
 			i += emotelen-1;
 			drawwidth = EMOTEWIDTH;
@@ -1900,36 +1920,6 @@ static void HU_DrawChat(void)
 		}
 	}
 
-	if (emote_suggestions[0])
-	{
-		// A bit of copy-paste from /pm code :p
-		INT32 suggesty = chaty - charheight - 1;
-		size_t longest_suggestion_length = 0;
-
-		for (i = 0; i < MAXEMOTESUGGESTIONS && emote_suggestions[i]; ++i)
-		{
-			longest_suggestion_length = max(longest_suggestion_length, strlen(emote_suggestions[i]->name));
-		}
-
-#ifdef NETSPLITSCREEN
-		if (splitscreen)
-		{
-			suggesty -= BASEVIDHEIGHT/2;
-			if (splitscreen > 1)
-				suggesty += 16;
-		}
-		else
-#endif
-			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
-
-		for (i = 0; i < MAXEMOTESUGGESTIONS && emote_suggestions[i]; ++i)
-		{
-			V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*i), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-			V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*i), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", emote_suggestions[i]->name));
-			HU_DrawEmote(chatx + boxw + 2, suggesty - i*7, emote_suggestions[i], V_SNAPTOBOTTOM|V_SNAPTOLEFT);
-		}
-	}
-
 	// handle /pm list. It's messy, horrible and I don't care.
 	if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
 	{
@@ -1955,7 +1945,7 @@ static void HU_DrawChat(void)
 			longest_name_length = max(longest_name_length, strlen(player_names[i]));
 		}
 
-		for(i = 0; i < MAXPLAYERS; i++)
+		for (i = 0; i < MAXPLAYERS; i++)
 		{
 			if (!playeringame[i])
 				continue;
@@ -2010,9 +2000,74 @@ static void HU_DrawChat(void)
 
 		if (count == 0) // no results.
 		{
+			pm_offset = 48 + 2;
 			V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
 			V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
 		}
+		else
+		{
+			pm_offset = (longest_name_length+4)*4 + 2;
+		}
+	}
+
+	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
+	{
+		emote_t *suggest;
+		int skip = 0;
+
+		const char *complete;
+		int complete_len;
+
+		if (emote_autocomplete.complete[0])
+		{
+			complete = emote_autocomplete.complete;
+			complete_len = strlen(complete);
+		}
+		else
+		{
+			complete = &w_chat_buf[emote_autocomplete.emotestart];
+			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
+		}
+
+		// A bit of copy-paste from /pm code :p
+		INT32 suggesty = chaty - charheight - 1;
+		size_t longest_suggestion_length = 0;
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
+			++skip;
+		}
+
+		INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
+
+		skip = 0;
+
+#ifdef NETSPLITSCREEN
+		if (splitscreen)
+		{
+			suggesty -= BASEVIDHEIGHT/2;
+			if (splitscreen > 1)
+				suggesty += 16;
+		}
+		else
+#endif
+			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			V_DrawFillConsoleMap(chatx + boxw + pm_offset + 2, suggesty - (7*skip), emote_suggest_boxw, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			// Highlight currently suggested emote
+			int hlflag = 0;
+			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
+				hlflag = V_YELLOWMAP;
+
+			V_DrawSmallString(chatx + boxw + pm_offset + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
+			M_DrawEmote(chatx + boxw + pm_offset + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			++skip;
+		}
 	}
 
 	HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.
@@ -2061,15 +2116,15 @@ static void HU_DrawChat_Old(void)
 	i = 0;
 	while (w_chat_buf[i])
 	{
-		if (w_chat.cursor == (i+1) && hu_tick < 4)
-		{
-			INT32 cursorx = (HU_INPUTX+c+charwidth < vid.width) ? (HU_INPUTX + c + charwidth) : (HU_INPUTX); // we may have to go down.
-			INT32 cursory = (cursorx != HU_INPUTX) ? (y) : (y+charheight);
-			V_DrawCharacter(cursorx, cursory+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
-		}
+		int emotelen;
+		emote_t *emote;
 
-		//Hurdler: isn't it better like that?
-		if (w_chat_buf[i] >= HU_FONTSTART)
+		if ((emote = M_VerifyEmote(w_chat_buf+i, &emotelen)))
+		{
+			M_DrawScaledEmote((HU_INPUTX + c)<<FRACBITS, (y+con_scalefactor*2)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART | V_NOSCALEPATCH | t);
+			i += emotelen-1;
+		}
+		else if (w_chat_buf[i] >= HU_FONTSTART) //Hurdler: isn't it better like that?
 		{
 			//charwidth = hu_font[w_chat[i]-HU_FONTSTART]->width * con_scalefactor;
 			V_DrawCharacter(HU_INPUTX + c, y, w_chat_buf[i] | cv_constextsize.value | V_NOSCALESTART | t, !cv_allcaps.value);
@@ -2081,6 +2136,13 @@ static void HU_DrawChat_Old(void)
 
 		++i;
 
+		if (w_chat.cursor == i && hu_tick < 4)
+		{
+			INT32 cursorx = (HU_INPUTX+c+charwidth < vid.width) ? (HU_INPUTX + c + charwidth) : (HU_INPUTX); // we may have to go down.
+			INT32 cursory = (cursorx != HU_INPUTX) ? (y) : (y+charheight);
+			V_DrawCharacter(cursorx, cursory+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
+		}
+
 		c += charwidth;
 		if (c >= vid.width)
 		{

src/hu_stuff.h

@@ -90,6 +90,7 @@ extern patch_t *pinggfx[5];
 extern patch_t *ranknum[10];
 extern patch_t *framecounter;
 extern patch_t *frameslash;
+extern patch_t *srb2back;
 extern patch_t *lt_font[LT_FONTSIZE];
 extern patch_t *cred_font[CRED_FONTSIZE];
 extern patch_t *rflagico;

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

@@ -41,11 +41,6 @@ typedef enum {
 */
 extern UINT8 sound_started;
 
-/**	\brief info of samplerate
-*/
-#if defined(HAVE_SDL) && SOUND==SOUND_SDL
-extern consvar_t cv_samplerate;
-#endif
 
 /**	\brief	The I_GetSfx function
 

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
 */
@@ -39,7 +43,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;
 
 /** \brief Set to true when inside a signal handler that will exit the program. */
-extern boolean g_in_exiting_signal_handler;
+boolean I_In_Exiting_Signal_Handler(void);
 
 /**	\brief	The I_GetFreeMem function
 
@@ -61,10 +65,6 @@ precise_t I_GetPreciseTime(void);
   */
 UINT64 I_GetPrecisePrecision(void);
 
-/** \brief  Get the current time in rendering tics, including fractions.
-*/
-double I_GetFrameTime(void);
-
 /**	\brief	Sleeps for the given duration in milliseconds. Depending on the
             operating system's scheduler, the calling thread may give up its
 			time slice for a longer duration. The implementation should give a
@@ -195,6 +195,10 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);
 
+/**	\brief To check if a Interrupt or Terminate Signal was fired
+ */
+boolean I_Interrupted(void);
+
 /**	\brief	The I_GetDiskFreeSpace function
 
 	\param	freespace	a INT64 pointer to hold the free space amount
@@ -221,10 +225,6 @@ INT32 I_mkdir(const char *dirname, INT32 unixright);
 */
 const char *I_LocateWad(void);
 
-/**	\brief Joystick events
-*/
-void I_GetJoystickEvents(UINT8 index);
-
 char *I_GetEnv(const char *name);
 
 INT32 I_PutEnv(char *variable);

src/i_tcp.c

@@ -496,8 +496,10 @@ static void cleanupnodes(void)
 
 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
+	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
+	}
 }
 
 static SINT8 getfreenode(void)
@@ -507,11 +509,13 @@ static SINT8 getfreenode(void)
 	cleanupnodes();
 
 	for (j = 0; j < MAXNETNODES; j++)
+	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
+	}
 
 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -568,13 +572,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 +587,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:
@@ -635,7 +638,7 @@ static boolean SOCK_Get(void)
 		c = recvfrom(mysockets[n], (char *)&doomcom->data, MAXPACKETLENGTH, 0,
 			(void *)&fromaddress, &fromlen);
 
-		if (c != ERRSOCKET)
+		if (c > 0)
 		{
 #ifdef USE_STUN
 			if (STUN_got_response(doomcom->data, c))
@@ -649,7 +652,6 @@ static boolean SOCK_Get(void)
 				break;
 			}
 #endif
-
 			// find remote node number
 			for (j = 1; j <= MAXNETNODES; j++) // include LAN
 			{
@@ -670,7 +672,7 @@ static boolean SOCK_Get(void)
 			{
 				const time_t curTime = time(NULL);
 
-				M_Memcpy(&clientaddress[j], &fromaddress, fromlen);
+				memcpy(&clientaddress[j], &fromaddress, fromlen);
 				nodesocket[j] = mysockets[n];
 				DEBFILE(va("New node detected: node:%d address:%s\n", j,
 						SOCK_GetNodeAddress(j)));
@@ -764,6 +766,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;
@@ -781,6 +784,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;
@@ -793,6 +797,7 @@ static void SOCK_Send(void)
 	else
 	{
 		c = SOCK_SendToAddr(nodesocket[doomcom->remotenode], &clientaddress[doomcom->remotenode]);
+
 		if (c == ERRSOCKET)
 		{
 			e = errno;
@@ -811,7 +816,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (!numnode || numnode > MAXNETNODES)
+	if (numnode <= 0 || numnode > MAXNETNODES)
 		return;
 
 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1061,7 +1066,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++)
@@ -1432,14 +1436,12 @@ static void SOCK_RegisterHolePunch(void)
 
 static boolean SOCK_OpenSocket(void)
 {
-	size_t i;
-
-	memset(clientaddress, 0, sizeof (clientaddress));
+	memset(clientaddress, 0, sizeof(clientaddress));
 
+	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
-	for (i = 1; i < MAXNETNODES; i++)
-		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
+
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1479,13 +1481,13 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;
 
-	if (node > MAXNETNODES)
+	if (node < 0 || node > MAXNETNODES)
 		return false;
 
 	ban = numbans;
 	AddBannedIndex();
 
-	M_Memcpy(&banned[ban].address, &clientaddress[node], sizeof (mysockaddr_t));
+	memcpy(&banned[ban].address, &clientaddress[node], sizeof (mysockaddr_t));
 
 	if (banned[ban].address.any.sa_family == AF_INET)
 	{
@@ -1510,11 +1512,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);
 
@@ -1528,11 +1527,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};
@@ -63,7 +63,10 @@ void I_UpdateTime(fixed_t timescale)
 	ticratescaled = (double)((float)TICRATE * FixedToFloat(timescale));
 
 	enterprecise = I_GetPreciseTime();
-	elapsedseconds = (double)(enterprecise - oldenterprecise) / I_GetPrecisePrecision();
+	const precise_t elapsed = enterprecise - oldenterprecise;
+	const UINT64 precision = I_GetPrecisePrecision();
+	// explictily do this in double precision
+	elapsedseconds = (double)elapsed / (double)precision;
 	tictimer += elapsedseconds;
 	while (tictimer > 1.0/ticratescaled)
 	{

src/i_video.h

@@ -101,10 +101,6 @@ void VID_PrepareModeList(void);
 */
 extern boolean allow_fullscreen;
 
-/**	\brief Update video system without updating frame
-*/
-void I_UpdateNoBlit(void);
-
 /**	\brief Update video system with updating frame
 */
 void I_FinishUpdate(void);
@@ -113,13 +109,6 @@ void I_FinishUpdate(void);
 */
 void I_UpdateNoVsync(void);
 
-/**	\brief	Wait for vertical retrace or pause a bit.
-
-	\param	count	max wait
-
-	\return	void
-*/
-void I_WaitVBL(INT32 count);
 
 /**	\brief	The I_ReadScreen function
 
@@ -129,13 +118,6 @@ void I_WaitVBL(INT32 count);
 */
 void I_ReadScreen(UINT8 * restrict scr, INT32 scale);
 
-/**	\brief Start disk icon
-*/
-void I_BeginRead(void);
-
-/**	\brief Stop disk icon
-*/
-void I_EndRead(void);
 
 UINT32 I_GetRefreshRate(void);
 
@@ -151,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;
@@ -931,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
 
 //}
 
-INT32 ITEM_X, ITEM_Y;	// Item Window
-INT32 TIME_X, TIME_Y;	// Time Sticker
-INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-INT32 SPDM_X, SPDM_Y;	// Speedometer
-INT32 POSI_X, POSI_Y;	// Position Number
-INT32 FACE_X, FACE_Y;	// Top-four Faces
-INT32 STCD_X, STCD_Y;	// Starting countdown
-INT32 CHEK_Y;			// CHECK graphic
-INT32 MINI_X, MINI_Y;	// Minimap
-INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+static INT32 ITEM_X, ITEM_Y;	// Item Window
+static INT32 TIME_X, TIME_Y;	// Time Sticker
+static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+static INT32 SPDM_X, SPDM_Y;	// Speedometer
+static INT32 POSI_X, POSI_Y;	// Position Number
+static INT32 FACE_X, FACE_Y;	// Top-four Faces
+static INT32 STCD_X, STCD_Y;	// Starting countdown
+static INT32 CHEK_Y;			// CHECK graphic
+static INT32 MINI_X, MINI_Y;	// Minimap
+static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
 
 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-INT32 ITEM2_X, ITEM2_Y;
-INT32 LAPS2_X, LAPS2_Y;
-INT32 POSI2_X, POSI2_Y;
+static INT32 ITEM2_X, ITEM2_Y;
+static INT32 LAPS2_X, LAPS2_Y;
+static INT32 POSI2_X, POSI2_Y;
 
 static void K_initKartHUD(void)
 {
@@ -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
@@ -1076,12 +1076,55 @@ static void K_initKartHUD(void)
 	R_InterpolateView(R_GetTimeFrac(RTF_CAMERA), !cv_uncappedhud.value);
 }
 
+void K_KartPlayerHUDUpdate(player_t *player)
+{
+	if (player->kartstuff[k_lapanimation])
+		player->kartstuff[k_lapanimation]--;
+
+	if (player->kartstuff[k_yougotem])
+		player->kartstuff[k_yougotem]--;
+
+	if (G_BattleGametype() && (player->exiting || player->kartstuff[k_comebacktimer]))
+	{
+		if (player->exiting)
+		{
+			if (player->exiting < 6*TICRATE)
+				player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
+			else if (player->exiting == 6*TICRATE)
+				player->kartstuff[k_cardanimation] = 0;
+			else if (player->kartstuff[k_cardanimation] < 2*TICRATE)
+				player->kartstuff[k_cardanimation]++;
+		}
+		else
+		{
+			if (player->kartstuff[k_comebacktimer] < 6*TICRATE)
+				player->kartstuff[k_cardanimation] -= ((164-player->kartstuff[k_cardanimation])/8)+1;
+			else if (player->kartstuff[k_comebacktimer] < 9*TICRATE)
+				player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
+		}
+
+		if (player->kartstuff[k_cardanimation] > 164)
+			player->kartstuff[k_cardanimation] = 164;
+		if (player->kartstuff[k_cardanimation] < 0)
+			player->kartstuff[k_cardanimation] = 0;
+	}
+	else if (G_RaceGametype() && player->exiting)
+	{
+		if (player->kartstuff[k_cardanimation] < 2*TICRATE)
+			player->kartstuff[k_cardanimation]++;
+	}
+	else
+	{
+		player->kartstuff[k_cardanimation] = 0;
+	}
+}
+
 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)
@@ -1372,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));
@@ -1483,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
@@ -2152,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++)
 	{
@@ -2860,7 +2901,7 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
 
 	// X coordinate
 	// get difference between camangle and angle towards target
-	x = (INT32)viewangle - (INT32)R_PointToAngle(targx, targy);
+	x = (fixed_t)(viewangle - R_PointToAngle(targx, targy));
 
 	distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK);
     if (!distfact) distfact = 1;
@@ -3775,7 +3816,7 @@ static void K_drawKartMinimap(void)
 
 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap;
+			UINT8 *colormap = NULL;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3786,10 +3827,27 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;
 
-			if (mobj->colorized)
-				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-			else
-				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+			if (mobj->color)
+			{
+				if (mobj->colorized)
+				{
+					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+				}
+				else
+				{
+					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
+
+					// special case if startcolor is not the default (160 / Green)
+					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
+					{
+						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
+					}
+					else
+					{
+						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+					}
+				}
+			}
 
 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);
@@ -4387,8 +4445,10 @@ static void K_drawLapStartAnim(void)
 	UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
 	INT32 vflags = V_SNAPTOTOP|V_HUDTRANS;
 
-	fixed_t slideout = max(0, 32*(((progress - 76)*FRACUNIT) + R_GetTimeFrac(RTF_LEVEL)));
-	fixed_t slidein = max(0, 32*(((stplyr->kartstuff[k_lapanimation] - 76)*FRACUNIT) - R_GetTimeFrac(RTF_LEVEL)));
+	fixed_t slideout = 32*(((progress - 76)*FRACUNIT) + R_GetTimeFrac(RTF_LEVEL));
+	slideout = max(0, slideout);
+	fixed_t slidein = 32*(((stplyr->kartstuff[k_lapanimation] - 76)*FRACUNIT) - R_GetTimeFrac(RTF_LEVEL));
+	slidein = max(0, slidein);
 
 	// First, draw the emblem and hand
 	INT32 emblemx = (BASEVIDWIDTH << (FRACBITS - 1)) + slidein;
@@ -4423,7 +4483,9 @@ static void K_drawLapStartAnim(void)
 		V_DrawFixedPatch(leftx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2, 6)], NULL);
 
 		char *lapnum = va("%02d", stplyr->laps + 1);
-		for (int i = 0; i < (int)strlen(lapnum); i++)
+		const size_t laplength = strlen(lapnum);
+
+		for (int i = 0; i < (int)laplength; i++)
 		{
 			int digit = lapnum[i] - '0';
 			int frame = min(2, progress/2 - 8 - (i*2));

src/k_hud.h

@@ -24,7 +24,6 @@ extern "C" {
 UINT8 K_GetHudColor(void);
 boolean K_UseColorHud(void);
 boolean K_UseHighResPortraits(void);
-patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);
 
 void K_RegisterKartHudStuff(void);
 
@@ -35,7 +34,6 @@ extern consvar_t cv_colorizedhud,
 extern consvar_t cv_darkitembox;
 extern consvar_t cv_biglaps;
 extern consvar_t cv_highresportrait;
-extern consvar_t cv_stat_xoffset, cv_stat_yoffset;
 extern consvar_t cv_showstats;
 extern consvar_t cv_fancyroulette;
 extern consvar_t cv_showlaptimes;
@@ -43,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
@@ -52,6 +53,8 @@ extern CV_PossibleValue_t inputdisplay_cons_t[NUMINPUTDISPLAYSTUFF];
 #define NUMMINIMAPDOTSTUFF 5
 extern CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF];
 
+void K_KartPlayerHUDUpdate(player_t *player);
+
 const char *K_GetItemPatch(UINT8 item, boolean tiny);
 INT32 K_calcSplitFlags(INT32 snapflags);
 void K_LoadKartHUDGraphics(void);

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};
@@ -98,8 +100,6 @@ static void saltyhop_onchange(void)
 	}
 }
 
-static boolean K_SpeedLinesShouldBlend(player_t *player);
-
 // SOME IMPORTANT VARIABLES DEFINED IN DOOMDEF.H:
 // gamespeed is cc (0 for easy, 1 for normal, 2 for hard)
 // franticitems is Frantic Mode items, bool
@@ -484,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.
@@ -659,13 +660,22 @@ INT32 K_GetSkinNum(player_t *player)
 
 //
 // returns the mobj skinnumber
-// accounts for localskins
+// accounts for localskins ?
 //
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
 {
 	return skin - K_GetSkinArray(local);
 }
 
+//
+// returns the mobj skinnumber
+// accounts for localskins
+//
+INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
+{
+	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
+}
+
 //
 // returns the players skinnumber
 // accounts for localskins
@@ -766,6 +776,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);
@@ -811,8 +823,10 @@ boolean K_IsPlayerLosing(player_t *player)
 boolean K_IsPlayerWanted(player_t *player)
 {
 	UINT8 i;
-	if (!(G_BattleGametype()))
+
+	if (!G_BattleGametype())
 		return false;
+
 	for (i = 0; i < 4; i++)
 	{
 		if (battlewanted[i] == -1)
@@ -820,6 +834,7 @@ boolean K_IsPlayerWanted(player_t *player)
 		if (player == &players[battlewanted[i]])
 			return true;
 	}
+
 	return false;
 }
 
@@ -1244,7 +1259,9 @@ static void K_KartItemRoulette(player_t *player, ticcmd_t *cmd)
 	{
 		if (!playeringame[i] || players[i].spectator)
 			continue;
+
 		pingame++;
+
 		if (players[i].exiting)
 			dontforcespb = true;
 		if (players[i].kartstuff[k_bumper] > bestbumper)
@@ -1258,13 +1275,11 @@ static void K_KartItemRoulette(player_t *player, ticcmd_t *cmd)
 	// This makes the roulette produce the random noises.
 	if ((player->kartstuff[k_itemroulette] % 3) == 1 && P_IsDisplayPlayer(player))
 	{
-#define PLAYROULETTESND S_StartSound(NULL, sfx_itrol1 + ((player->kartstuff[k_itemroulette] / 3) % 8))
 		for (i = 0; i <= splitscreen; i++)
 		{
 			if (player == &players[displayplayers[i]] && players[displayplayers[i]].kartstuff[k_itemroulette])
-				PLAYROULETTESND;
+				S_StartSound(NULL, sfx_itrol1 + ((player->kartstuff[k_itemroulette] / 3) % 8));
 		}
-#undef PLAYROULETTESND
 	}
 
 	roulettestop = TICRATE + (3*(pingame - player->kartstuff[k_position]));
@@ -1363,8 +1378,9 @@ static fixed_t K_GetMobjWeight(mobj_t *mobj, mobj_t *against)
 			else
 			{
 				weight = (mobj->player->kartweight)<<FRACBITS;
-				if (mobj->player->speed > K_GetKartSpeed(mobj->player, false))
-					weight += (mobj->player->speed - K_GetKartSpeed(mobj->player, false))/8;
+				const fixed_t kartspeed = K_GetKartSpeed(mobj->player, false);
+				if (mobj->player->speed > kartspeed)
+					weight += (mobj->player->speed - kartspeed)/8;
 			}
 			break;
 		case MT_FALLINGROCK:
@@ -1473,7 +1489,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);
 
@@ -1486,9 +1501,9 @@ void K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2, boolean bounce, boolean solid)
 	}
 
 	// if the speed difference is less than this let's assume they're going proportionately faster from each other
-	if (P_AproxDistance(momdifx, momdify) < (25*mapobjectscale))
+	const fixed_t momdiflength = P_AproxDistance(momdifx, momdify);
+	if (momdiflength < (25*mapobjectscale))
 	{
-		fixed_t momdiflength = P_AproxDistance(momdifx, momdify);
 		fixed_t normalisedx = FixedDiv(momdifx, momdiflength);
 		fixed_t normalisedy = FixedDiv(momdify, momdiflength);
 		momdifx = FixedMul((25*mapobjectscale), normalisedx);
@@ -1652,7 +1667,7 @@ static void K_UpdateOffroad(player_t *player)
 	// If you are in offroad, a timer starts.
 	if (offroadstrength)
 	{
-		if (/*K_CheckOffroadCollide(player->mo) &&*/ player->kartstuff[k_offroad] == 0)	// With the way offroad is detected now that first check is no longer necessary. -Lat'
+		if (/*K_CheckOffroadCollide(player->mo) &&*/ player->kartstuff[k_offroad] == 0) // With the way offroad is detected now that first check is no longer necessary. -Lat'
 			player->kartstuff[k_offroad] = (TICRATE/2);
 
 		if (player->kartstuff[k_offroad] > 0)
@@ -2144,7 +2159,13 @@ static void K_GetKartBoostPower(player_t *player)
 		&& player->speed > 0
 		&& !player->spectator)
 	{
-		K_SpawnWipeoutTrail(player->mo, true);
+		mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true);
+
+		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
+		// is to hide them if you are in saltyhop jump
+		if (dust && player->mo->salty.jump)
+			dust->flags2 |= MF2_DONTDRAW;
+
 		if (leveltime % 6 == 0)
 			S_StartSound(player->mo, sfx_cdfm70);
 	}
@@ -2396,7 +2417,7 @@ void K_SpinPlayer(player_t *player, mobj_t *source, INT32 type, mobj_t *inflicto
 		|| player->kartstuff[k_invincibilitytimer] > 0 || player->kartstuff[k_growshrinktimer] > 0 || player->kartstuff[k_hyudorotimer] > 0
 		|| (G_BattleGametype() && ((player->kartstuff[k_bumper] <= 0 && player->kartstuff[k_comebacktimer]) || player->kartstuff[k_comebackmode] == 1)))
 	{
-		if (!force)	// if shoulddamage force, we go THROUGH that.
+		if (!force) // if shoulddamage force, we go THROUGH that.
 		{
 			K_DoInstashield(player);
 			return;
@@ -2441,6 +2462,7 @@ void K_SpinPlayer(player_t *player, mobj_t *source, INT32 type, mobj_t *inflicto
 				P_SetScale(karmahitbox, player->mo->scale);
 				CONS_Printf(M_GetText("%s lost all of their bumpers!\n"), player_names[player-players]);
 			}
+
 			player->kartstuff[k_bumper]--;
 			if (K_IsPlayerWanted(player))
 				K_CalculateBattleWanted();
@@ -2575,6 +2597,7 @@ void K_SquishPlayer(player_t *player, mobj_t *source, mobj_t *inflictor)
 				P_SetScale(karmahitbox, player->mo->scale);
 				CONS_Printf(M_GetText("%s lost all of their bumpers!\n"), player_names[player-players]);
 			}
+
 			player->kartstuff[k_bumper]--;
 			if (K_IsPlayerWanted(player))
 				K_CalculateBattleWanted();
@@ -2694,6 +2717,7 @@ void K_ExplodePlayer(player_t *player, mobj_t *source, mobj_t *inflictor) // A b
 				P_SetScale(karmahitbox, player->mo->scale);
 				CONS_Printf(M_GetText("%s lost all of their bumpers!\n"), player_names[player-players]);
 			}
+
 			player->kartstuff[k_bumper]--;
 			if (K_IsPlayerWanted(player))
 				K_CalculateBattleWanted();
@@ -2854,15 +2878,15 @@ void K_SpawnKartExplosion(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32
 	for (i = 0; i < number; i++)
 	{
 		fa = (i*degrees);
-		v[0] = FixedMul(FINECOSINE(fa),radius);
+		v[0] = FixedMul(FINECOSINE(fa), radius);
 		v[1] = 0;
-		v[2] = FixedMul(FINESINE(fa),radius);
+		v[2] = FixedMul(FINESINE(fa), radius);
 		v[3] = FRACUNIT;
 
 		res = VectorMatrixMultiply(v, *RotateXMatrix(rotangle));
-		M_Memcpy(&v, res, sizeof (v));
+		memcpy(&v, res, sizeof (v));
 		res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
-		M_Memcpy(&v, res, sizeof (v));
+		memcpy(&v, res, sizeof (v));
 
 		finalx = x + v[0];
 		finaly = y + v[1];
@@ -3098,17 +3122,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;
@@ -3425,7 +3450,7 @@ boolean K_CheckSlopeRollDist(mobj_t *mobj)
 		return true;
 
 	const fixed_t rolldist = (cv_sloperolldist.value * mapobjectscale);
-	const fixed_t m_dist = (R_QuickCamDist(mobj->x, mobj->y) << FRACBITS);
+	const fixed_t m_dist = R_QuickCamDist(mobj->x, mobj->y);
 
 	return (m_dist <= rolldist);
 }
@@ -3589,6 +3614,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);
@@ -3606,14 +3633,14 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 
 		sparkle->color = mo->color;
 
-		if (cv_playerblendeffects.value && mo->player && K_SpeedLinesShouldBlend(mo->player))
+		if (shouldblend)
 			sparkle->blendmode = AST_ADD;
 	}
 
 	P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
 }
 
-void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
+mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 {
 	mobj_t *dust;
 	angle_t aoff;
@@ -3654,6 +3681,8 @@ void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 
 	if (translucent)
 		dust->flags2 |= MF2_SHADOW;
+
+	return dust;
 }
 
 //	K_DriftDustHandling
@@ -3980,15 +4009,19 @@ void K_PuntMine(mobj_t *thismine, mobj_t *punter)
 		mine->floorz = thismine->floorz;
 		mine->ceilingz = thismine->ceilingz;
 
-		//Since we aren't using P_KillMobj, we need to clean up the hnext reference
-		{
-			P_SetTarget(&thismine->target->hnext, NULL); //target is the player who owns the mine
-			thismine->target->player->kartstuff[k_bananadrag] = 0;
-			thismine->target->player->kartstuff[k_itemheld] = 0;
+		// Copy interp data
+		mine->old_angle = thismine->old_angle;
+		mine->old_x = thismine->old_x;
+		mine->old_y = thismine->old_y;
+		mine->old_z = thismine->old_z;
 
-			if (--thismine->target->player->kartstuff[k_itemamount] <= 0)
-				thismine->target->player->kartstuff[k_itemtype] = KITEM_NONE;
-		}
+		// Since we aren't using P_KillMobj, we need to clean up the hnext reference
+		P_SetTarget(&thismine->target->hnext, NULL); // target is the player who owns the mine
+		thismine->target->player->kartstuff[k_bananadrag] = 0;
+		thismine->target->player->kartstuff[k_itemheld] = 0;
+
+		if (--thismine->target->player->kartstuff[k_itemamount] <= 0)
+			thismine->target->player->kartstuff[k_itemtype] = KITEM_NONE;
 
 		P_RemoveMobj(thismine);
 
@@ -4424,6 +4457,12 @@ void K_DropHnextList(player_t *player)
 		dropwork->floorz = work->floorz;
 		dropwork->ceilingz = work->ceilingz;
 
+		// Copy interp data
+		dropwork->old_angle = work->old_angle;
+		dropwork->old_x = work->old_x;
+		dropwork->old_y = work->old_y;
+		dropwork->old_z = work->old_z;
+
 		if (ponground)
 		{
 			// floorz and ceilingz aren't properly set to account for FOFs and Polyobjects on spawn
@@ -4506,7 +4545,7 @@ void K_DropItems(player_t *player)
 	{
 		mobj_t *drop = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z + player->mo->height/2, MT_FLOATINGITEM);
 		P_SetScale(drop, drop->scale>>4);
-		drop->destscale = (3*drop->destscale)/2;;
+		drop->destscale = (3*drop->destscale)/2;
 
 		drop->angle = player->mo->angle + ANGLE_90;
 		P_Thrust(drop,
@@ -5164,6 +5203,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)
 {
@@ -5174,7 +5231,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;
@@ -5210,7 +5267,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]++; }
@@ -5287,17 +5344,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);
 }
@@ -5329,53 +5376,13 @@ static void K_UpdateInvincibilitySounds(player_t *player)
 #undef STOPTHIS
 }
 
-void K_KartPlayerHUDUpdate(player_t *player)
-{
-	if (player->kartstuff[k_lapanimation])
-		player->kartstuff[k_lapanimation]--;
-
-	if (player->kartstuff[k_yougotem])
-		player->kartstuff[k_yougotem]--;
-
-	if (G_BattleGametype() && (player->exiting || player->kartstuff[k_comebacktimer]))
-	{
-		if (player->exiting)
-		{
-			if (player->exiting < 6*TICRATE)
-				player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
-			else if (player->exiting == 6*TICRATE)
-				player->kartstuff[k_cardanimation] = 0;
-			else if (player->kartstuff[k_cardanimation] < 2*TICRATE)
-				player->kartstuff[k_cardanimation]++;
-		}
-		else
-		{
-			if (player->kartstuff[k_comebacktimer] < 6*TICRATE)
-				player->kartstuff[k_cardanimation] -= ((164-player->kartstuff[k_cardanimation])/8)+1;
-			else if (player->kartstuff[k_comebacktimer] < 9*TICRATE)
-				player->kartstuff[k_cardanimation] += ((164-player->kartstuff[k_cardanimation])/8)+1;
-		}
-
-		if (player->kartstuff[k_cardanimation] > 164)
-			player->kartstuff[k_cardanimation] = 164;
-		if (player->kartstuff[k_cardanimation] < 0)
-			player->kartstuff[k_cardanimation] = 0;
-	}
-	else if (G_RaceGametype() && player->exiting)
-	{
-		if (player->kartstuff[k_cardanimation] < 2*TICRATE)
-			player->kartstuff[k_cardanimation]++;
-	}
-	else
-		player->kartstuff[k_cardanimation] = 0;
-}
-
-static boolean K_SpeedLinesShouldBlend(player_t *player)
+boolean K_PlayerEffectsShouldBlend(player_t *player)
 {
 	if (!cv_playerblendeffects.value || !player->mo)
 		return false;
 
-	if (player->kartstuff[k_sneakertimer])
+	if (player->kartstuff[k_sneakertimer] ||
+		player->kartstuff[k_invincibilitytimer])
 		return true;
 
 	// this is how the percentage speedometer calcs, i suck at maths so this was the easiest thing to do lmao
@@ -5460,7 +5467,7 @@ FUNCINLINE static ATTRINLINE void K_SpawnNormalSpeedLines(player_t *player, bool
 			fast->colorized = true;
 		}
 
-		if (colorSpeed && K_SpeedLinesShouldBlend(player))
+		if (colorSpeed && K_PlayerEffectsShouldBlend(player))
 			fast->blendmode = AST_ADD;
 	}
 }
@@ -5756,7 +5763,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();
 }
 
@@ -5936,45 +5943,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?
@@ -6052,8 +6047,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...
@@ -6128,6 +6123,7 @@ static void K_KartDrift(player_t *player, boolean onground)
 	else
 		player->kartstuff[k_brakedrift] = 0;
 }
+
 //
 // K_KartUpdatePosition
 //
@@ -6187,6 +6183,13 @@ void K_KartUpdatePosition(player_t *player)
 						}
 					}
 
+					// the player should NOT be checked against themselves! lol
+					// otherwise prevcheck will effectively be halved
+					// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
+					// oh well
+					//if (player == &players[i])
+						//continue;
+
 					const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
 					const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);
 
@@ -6316,7 +6319,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 
 	K_KartUpdatePosition(player);
 
-	if (LIKELY(!player->exiting))
+	if (!player->exiting)
 	{
 		if (player->kartstuff[k_oldposition] < player->kartstuff[k_position]) // But first, if you lost a place,
 		{
@@ -6479,7 +6482,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 						}
 						player->kartstuff[k_invincibilitytimer] = itemtime+(2*TICRATE); // 10 seconds
 
-						if (P_IsLocalPlayer(player) && cv_supermusic.value == 1 && cv_birdmusic.value)
+						if (cv_supermusic.value == 1 && P_IsLocalPlayer(player))
 							S_ChangeMusicSpecial("kinvnc");
 
 						P_RestoreMusic(player);
@@ -6683,7 +6686,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 							if (cv_kartdebugshrink.value && !modeattacking && !player->bot)
 								player->mo->destscale = (6*player->mo->destscale)/8;
 							player->kartstuff[k_growshrinktimer] = itemtime+(4*TICRATE); // 12 seconds
-							if (P_IsLocalPlayer(player) && cv_growmusic.value == 1 && cv_birdmusic.value )
+							if (cv_growmusic.value == 1 && P_IsLocalPlayer(player))
 								S_ChangeMusicSpecial("kgrow");
 							P_RestoreMusic(player);
 							S_StartSound(player->mo, sfx_kc5a);
@@ -6793,7 +6796,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;
@@ -6819,7 +6822,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_kart.h

@@ -41,7 +41,7 @@ void K_FlipFromObject(mobj_t *mo, mobj_t *master);
 void K_MatchGenericExtraFlags(mobj_t *mo, mobj_t *master);
 void K_RespawnChecker(player_t *player);
 void K_KartMoveAnimation(player_t *player);
-void K_KartPlayerHUDUpdate(player_t *player);
+boolean K_PlayerEffectsShouldBlend(player_t *player);
 void K_KartPlayerThink(player_t *player, ticcmd_t *cmd);
 void K_KartPlayerAfterThink(player_t *player);
 void K_DoInstashield(player_t *player);
@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
 void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
 void K_SpawnBoostTrail(player_t *player);
 void K_SpawnSparkleTrail(mobj_t *mo);
-void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
+mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
 void K_DriftDustHandling(mobj_t *spawner);
 void K_PuntMine(mobj_t *mine, mobj_t *punter);
 void K_DoSneaker(player_t *player, INT32 type);

src/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

@@ -45,27 +45,33 @@ boolean luaL_checkboolean(lua_State *L, int narg) {
 // String concatination
 static int lib_concat(lua_State *L)
 {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  char *r = NULL;
-  size_t rl = 0,sl;
-  lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
-    const char *s;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tolstring(L, -1, &sl);  /* get result */
-    if (s == NULL)
-      return luaL_error(L, LUA_QL("tostring") " must return a string to "
-													 LUA_QL("__add"));
+	int n = lua_gettop(L);  /* number of arguments */
+	int i;
+	char *r = NULL;
+	size_t rl = 0, sl;
+	lua_getglobal(L, "tostring");
+	for (i=1; i<=n; i++) {
+		const char *s;
+		lua_pushvalue(L, -1);  /* function to be called */
+		lua_pushvalue(L, i);   /* value to print */
+		lua_call(L, 1, 1);
+		s = lua_tolstring(L, -1, &sl);  /* get result */
+
+		if (sl == 0) {
+			lua_pop(L, 1);  /* pop result */
+			continue;
+		}
+
+		if (s == NULL)
+			return luaL_error(L, LUA_QL("tostring") " must return a string to "
+															LUA_QL("__add"));
 		r = Z_Realloc(r, rl+sl, PU_STATIC, NULL);
-		M_Memcpy(r+rl, s, sl);
+		memcpy(r+rl, s, sl);
 		rl += sl;
-    lua_pop(L, 1);  /* pop result */
-  }
-  lua_pushlstring(L, r, rl);
-  Z_Free(r);
+		lua_pop(L, 1);  /* pop result */
+	}
+	lua_pushlstring(L, r, rl);
+	Z_Free(r);
 	return 1;
 }
 
@@ -73,23 +79,24 @@ static int lib_concat(lua_State *L)
 // Copied from base Lua code
 static int lib_print(lua_State *L)
 {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  //HUDSAFE
-  lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
-    const char *s;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
-    lua_call(L, 1, 1);
-    s = lua_tostring(L, -1);  /* get result */
-    if (s == NULL)
-      return luaL_error(L, LUA_QL("tostring") " must return a string to "
-													 LUA_QL("print"));
-    if (i>1) CONS_Printf("\n");
-    CONS_Printf("%s", s);
-    lua_pop(L, 1);  /* pop result */
-  }
+	int n = lua_gettop(L);  /* number of arguments */
+	int i;
+	//HUDSAFE
+	lua_getglobal(L, "tostring");
+	for (i=1; i<=n; i++) {
+		const char *s;
+		lua_pushvalue(L, -1);  /* function to be called */
+		lua_pushvalue(L, i);   /* value to print */
+		lua_call(L, 1, 1);
+		s = lua_tostring(L, -1);  /* get result */
+
+		if (s == NULL)
+			return luaL_error(L, LUA_QL("tostring") " must return a string to "
+															LUA_QL("print"));
+		if (i>1) CONS_Printf("\n");
+		CONS_Printf("%s", s);
+		lua_pop(L, 1);  /* pop result */
+	}
 	CONS_Printf("\n");
 	return 0;
 }
@@ -377,7 +384,9 @@ static int lib_pSpawnMobj(lua_State *L)
 	NOHUD
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnMobj(x, y, z, type), META_MOBJ);
+	mobj_t *th = P_SpawnMobj(x, y, z, type);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -403,7 +412,9 @@ static int lib_pSpawnMissile(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnMissile(source, dest, type), META_MOBJ);
+	mobj_t *th = P_SpawnMissile(source, dest, type);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -420,7 +431,9 @@ static int lib_pSpawnXYZMissile(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnXYZMissile(source, dest, type, x, y, z), META_MOBJ);
+	mobj_t *th = P_SpawnXYZMissile(source, dest, type, x, y, z);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -439,7 +452,9 @@ static int lib_pSpawnPointMissile(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnPointMissile(source, xa, ya, za, type, x, y, z), META_MOBJ);
+	mobj_t *th = P_SpawnPointMissile(source, xa, ya, za, type, x, y, z);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -456,7 +471,9 @@ static int lib_pSpawnAlteredDirectionMissile(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnAlteredDirectionMissile(source, type, x, y, z, shiftingAngle), META_MOBJ);
+	mobj_t *th = P_SpawnAlteredDirectionMissile(source, type, x, y, z, shiftingAngle);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -485,7 +502,9 @@ static int lib_pSPMAngle(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SPMAngle(source, type, angle, allowaim, flags2), META_MOBJ);
+	mobj_t *th = P_SPMAngle(source, type, angle, allowaim, flags2);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -499,7 +518,9 @@ static int lib_pSpawnPlayerMissile(lua_State *L)
 		return LUA_ErrInvalid(L, "mobj_t");
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
-	LUA_PushUserdata(L, P_SpawnPlayerMissile(source, type, flags2), META_MOBJ);
+	mobj_t *th = P_SpawnPlayerMissile(source, type, flags2);
+	if (!P_MobjWasRemoved(th)) th->islocal = !hook_important;
+	LUA_PushUserdata(L, th, META_MOBJ);
 	return 1;
 }
 
@@ -1272,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))
@@ -3035,7 +3057,13 @@ static int lib_gSetPlayerGamepadIndicatorColor(lua_State *L)
 {
 	INT32 player = -1;
 	player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));    // retrieve player
-	UINT16 color = (UINT16)luaL_checkinteger(L, 2); // skincolor
+	UINT8 color = (UINT8)luaL_checkinteger(L, 2); // skincolor
+
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+
+	if (color >= MAXTRANSLATIONS)
+		return luaL_error(L, "color %d out of range (0 - %d).", color, MAXTRANSLATIONS-1);
 
 	for (int i = 0; i < MAXSPLITSCREENPLAYERS; ++i)
 	{
@@ -3063,6 +3091,9 @@ static int lib_gPlayerDeviceRumble(lua_State *L)
 	UINT16 high_strength = (UINT16)luaL_checkinteger(L, 3); // high frequency rumble motor strenght
 	UINT32 duration = (UINT32)luaL_optinteger(L, 4, 84); // duration of rumble in ms
 
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+
 	for (int i = 0; i < MAXSPLITSCREENPLAYERS; ++i)
 	{
 		if (plr - players == displayplayers[i])

src/lua_consolelib.c

@@ -28,13 +28,29 @@
 
 #define NOHUD if (hud_running) return luaL_error(L, "HUD rendering code should not call this function!");
 
-static const char *cvname = NULL;
+static consvar_t *this_cvar;
 
-void Got_Luacmd(UINT8 **cp, INT32 playernum)
+static void clear_lua_stack(void)
+{
+	if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
+		lua_settop(gL, 0); // clear stack
+}
+
+void Got_Luacmd(const UINT8 **cp, INT32 playernum)
 {
 	UINT8 i, argc, flags;
+	const char *argv[256];
 	char buf[256];
 
+	argc = READUINT8(*cp);
+	argv[0] = (const char*)*cp;
+	SKIPSTRINGN(*cp, 255);
+	for (i = 1; i < argc; i++)
+	{
+		argv[i] = (const char*)*cp;
+		SKIPSTRINGN(*cp, 255);
+	}
+
 	// don't use I_Assert here, goto the deny code below
 	// to clean up and kick people who try nefarious exploits
 	// like sending random junk lua commands to crash the server
@@ -47,8 +63,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
 	lua_getfield(gL, LUA_REGISTRYINDEX, "COM_Command"); // push COM_Command
 	if (!lua_istable(gL, -1)) goto deny;
 
-	argc = READUINT8(*cp);
-	READSTRINGN(*cp, buf, 255);
+	strlcpy(buf, argv[0], 255);
 	strlwr(buf); // must lowercase buffer
 	lua_getfield(gL, -1, buf); // push command info table
 	if (!lua_istable(gL, -1)) goto deny;
@@ -74,10 +89,17 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
 
 	lua_remove(gL, -2); // pop command info table
 
+	if (!lua_checkstack(gL, argc)) // player + command arguments
+	{
+		clear_lua_stack();
+		CONS_Alert(CONS_WARNING, "lua command stack overflow from %s (%d, need %d more)\n", player_names[playernum], lua_gettop(gL), argc);
+		return;
+	}
+
 	LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
 	for (i = 1; i < argc; i++)
 	{
-		READSTRINGN(*cp, buf, 255);
+		strlcpy(buf, argv[i], 255);
 		lua_pushstring(gL, buf);
 	}
 	LUA_Call(gL, (int)argc, 0, 1); // argc is 1-based, so this will cover the player we passed too.
@@ -88,8 +110,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
 
 deny:
 	//must be hacked/buggy client
-	if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
-		lua_settop(gL, 0); // clear stack
+	clear_lua_stack();
 
 	CONS_Alert(CONS_WARNING, M_GetText("Illegal lua command received from %s\n"), player_names[playernum]);
 	if (server)
@@ -133,7 +154,7 @@ void COM_Lua_f(void)
 	{
 		if (!splitscreen)
 		{
-			lua_pop(gL, 1); // pop command info table
+			lua_pop(gL, 2); // pop command info table and LUA_GetErrorMessage
 			return; // can't execute splitscreen command without player 2!
 		}
 
@@ -178,6 +199,13 @@ void COM_Lua_f(void)
 	I_Assert(lua_isfunction(gL, -1));
 	lua_remove(gL, -2); // pop command info table
 
+	if (!lua_checkstack(gL, COM_Argc() + 1))
+	{
+		CONS_Alert(CONS_WARNING, "lua command stack overflow (%d, need %s more)\n", lua_gettop(gL), sizeu1(COM_Argc() + 1));
+		lua_pop(gL, 2); // pop function and LUA_GetErrorMessage
+		return;
+	}
+
 	LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
 	for (i = 1; i < COM_Argc(); i++)
 		lua_pushstring(gL, COM_Argv(i));
@@ -284,16 +312,13 @@ static int lib_comBufInsertText(lua_State *L)
 	return 0;
 }
 
-void LUA_CVarChanged(const char *name)
+void LUA_CVarChanged(void *cvar)
 {
-	cvname = name;
+	this_cvar = cvar;
 }
 
 static void Lua_OnChange(void)
 {
-	I_Assert(gL != NULL);
-	I_Assert(cvname != NULL);
-
 	/// \todo Network this! XD_LUAVAR
 
     // Why?..
@@ -305,13 +330,10 @@ static void Lua_OnChange(void)
 	// From CV_OnChange registry field, get the function for this cvar by name.
 	lua_getfield(gL, LUA_REGISTRYINDEX, "CV_OnChange");
 	I_Assert(lua_istable(gL, -1));
-	lua_getfield(gL, -1, cvname); // get function
+	lua_pushlightuserdata(gL, this_cvar);
+	lua_rawget(gL, -2); // get function
 
-	// From the CV_Vars registry field, get the cvar's userdata by name.
-	lua_getfield(gL, LUA_REGISTRYINDEX, "CV_Vars");
-	I_Assert(lua_istable(gL, -1));
-	lua_getfield(gL, -1, cvname); // get consvar_t* userdata.
-	lua_remove(gL, -2); // pop the CV_Vars table.
+	LUA_RawPushUserdata(gL, this_cvar);
 
 	LUA_Call(gL, 1, 0, error_handler_i); // call function(cvar)
 	lua_pop(gL, 2); // pop CV_OnChange table and error handler
@@ -329,9 +351,8 @@ static int lib_cvRegisterVar(lua_State *L)
 	luaL_checktype(L, 1, LUA_TTABLE);
 	lua_settop(L, 1); // Clear out all other possible arguments, leaving only the first one.
 	NOHUD
-	cvar = lua_newuserdata(L, sizeof(consvar_t));
-	luaL_getmetatable(L, META_CVAR);
-	lua_setmetatable(L, -2);
+	cvar = ZZ_Calloc(sizeof(consvar_t));
+	LUA_PushUserdata(L, cvar, META_CVAR);
 
 #define FIELDERROR(f, e) luaL_error(L, "bad value for " LUA_QL(f) " in table passed to " LUA_QL("CV_RegisterVar") " (%s)", e);
 #define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))
@@ -384,7 +405,7 @@ static int lib_cvRegisterVar(lua_State *L)
 
 				lua_getfield(L, LUA_REGISTRYINDEX, "CV_PossibleValue");
 				I_Assert(lua_istable(L, 5));
-				lua_pushvalue(L, 2); // cvar userdata
+				lua_pushlightuserdata(L, cvar);
 				cvpv = lua_newuserdata(L, sizeof(CV_PossibleValue_t) * (count+1));
 				lua_rawset(L, 5);
 				lua_pop(L, 1); // pop CV_PossibleValue registry table
@@ -412,13 +433,14 @@ static int lib_cvRegisterVar(lua_State *L)
 				TYPEERROR("func", LUA_TFUNCTION)
 			lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange");
 			I_Assert(lua_istable(L, 5));
+			lua_pushlightuserdata(L, cvar);
 			lua_pushvalue(L, 4);
-			lua_setfield(L, 5, cvar->name);
+			lua_rawset(L, 5);
 			lua_pop(L, 1);
 			cvar->func = Lua_OnChange;
 		}
 		else if (((i == 5 && !(cvar->flags & CV_CALL))
-				|| (cvar->flags & CV_CALL && i == 6)) 
+				|| (cvar->flags & CV_CALL && i == 6))
 				|| (k && fasticmp(k, "category")))
 		{
 			category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
@@ -434,18 +456,12 @@ static int lib_cvRegisterVar(lua_State *L)
 #undef FIELDERROR
 #undef TYPEERROR
 
-	// stack: cvar table, cvar userdata
-	lua_getfield(L, LUA_REGISTRYINDEX, "CV_Vars");
-	I_Assert(lua_istable(L, 3));
-
-	lua_getfield(L, 3, cvar->name);
-	if (lua_type(L, -1) != LUA_TNIL)
-		return luaL_error(L, M_GetText("Variable %s is already defined\n"), cvar->name);
-	lua_pop(L, 1);
-
-	lua_pushvalue(L, 2);
-	lua_setfield(L, 3, cvar->name);
-	lua_pop(L, 1);
+	if (!cvar->name)
+		return luaL_error(L, M_GetText("Variable has no name!\n"));
+	if ((cvar->flags & CV_NOINIT) && !(cvar->flags & CV_CALL))
+		return luaL_error(L, M_GetText("Variable %s has CV_NOINIT without CV_CALL\n"), cvar->name);
+	if ((cvar->flags & CV_CALL) && !cvar->func)
+		return luaL_error(L, M_GetText("Variable %s has CV_CALL without a function\n"), cvar->name);
 
 	// actually time to register it to the console now! Finally!
 	cvar->flags |= CV_MODIFIED;
@@ -477,22 +493,9 @@ static int lib_cvRegisterVar(lua_State *L)
 
 static int lib_cvFindVar(lua_State *L)
 {
-	consvar_t *cv;
-	if (( cv = CV_FindVar(luaL_checkstring(L,1)) ))
-	{
-		lua_settop(L,1);/* We only want one argument in the stack. */
-		lua_pushlightuserdata(L, cv);/* Now the second value on stack. */
-		luaL_getmetatable(L, META_CVAR);
-		/*
-		The metatable is the last value on the stack, so this
-		applies it to the second value, which is the cvar.
-		*/
-		lua_setmetatable(L,2);
-		lua_pushvalue(L,2);
-		return 1;
-	}
-	else
-		return 0;
+	const char *name = luaL_checkstring(L, 1);
+	LUA_PushUserdata(L, CV_FindVar(name), META_CVAR);
+	return 1;
 }
 
 static int CVarSetFunction
@@ -501,7 +504,7 @@ static int CVarSetFunction
 		void (*Set)(consvar_t *, const char *),
 		void (*SetValue)(consvar_t *, INT32)
 ){
-	consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
+	consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
 
 	switch (lua_type(L, 2))
 	{
@@ -530,7 +533,8 @@ static int lib_cvStealthSet(lua_State *L)
 
 static int lib_cvAddValue(lua_State *L)
 {
-	consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
+	consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
+
 	CV_AddValue(cvar, (INT32)luaL_checknumber(L, 2));
 	return 0;
 }
@@ -545,6 +549,7 @@ static int lib_consPrintf(lua_State *L)
 	if (n < 2)
 		return luaL_error(L, "CONS_Printf requires at least two arguments: player and text.");
 	//HUDSAFE
+
 	plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
 	if (!plr)
 		return LUA_ErrInvalid(L, "player_t");
@@ -605,7 +610,7 @@ static int cvar_fields_ref = LUA_NOREF;
 
 static int cvar_get(lua_State *L)
 {
-	consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
+	consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
 	enum cvar_e field = Lua_optoption(L, 2, -1, cvar_fields_ref);
 
 	switch (field)

src/lua_hook.h

@@ -109,6 +109,7 @@ ENUM (STRING_HOOK);
 
 extern boolean hook_cmd_running;	// This is used by PlayerCmd and lua_playerlib to prevent anything from being wirtten to player while we run PlayerCmd.
 extern int hook_defrosting;
+extern bool hook_important;
 
 void LUA_HookVoid(int hook);
 void LUA_HookHUD(int hook, huddrawlist_h drawlist);

src/lua_hooklib.c

@@ -19,6 +19,7 @@
 #include "b_bot.h"
 #include "z_zone.h"
 #include "m_perfstats.h"
+#include "w_wad.h"
 
 #include "lua_script.h"
 #include "lua_libs.h"
@@ -39,14 +40,20 @@ LIST (stringHookNames, STRING_HOOK_LIST);
 
 #undef LIST
 
+typedef struct {
+	int id;
+	bool important;
+} hookinfo_t;
+
 typedef struct {
 	int numHooks;
-	int *ids;
+	hookinfo_t *ids;
 } hook_t;
 
 typedef struct {
 	int numGeneric;
 	int ref;
+	bool important;
 } stringhook_t;
 
 static hook_t hookIds[HOOK(MAX)];
@@ -56,6 +63,8 @@ static hook_t mobjHookIds[NUMMOBJTYPES][MOBJ_HOOK(MAX)];
 // Lua tables are used to lookup string hook ids.
 static stringhook_t stringHooks[STRING_HOOK(MAX)];
 
+bool hook_important = true;
+
 // This will be indexed by hook id, the value of which fetches the registry.
 static int * hookRefs;
 static int   nextid;
@@ -109,7 +118,11 @@ static void get_table(lua_State *L)
 
 FUNCINLINE static ATTRINLINE void add_hook_to_table(lua_State *L, int n)
 {
+	lua_newtable(L);
 	lua_pushnumber(L, nextid);
+	lua_rawseti(L, -2, 1);
+	lua_pushboolean(L, wadfiles[numwadfiles-1]->important);
+	lua_rawseti(L, -2, 2);
 	lua_rawseti(L, -2, n);
 }
 
@@ -180,12 +193,13 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
 {
 	Z_Realloc(map->ids, (map->numHooks + 1) * sizeof *map->ids,
 			PU_STATIC, &map->ids);
-	map->ids[map->numHooks++] = nextid;
+	map->ids[map->numHooks].important = wadfiles[numwadfiles-1]->important;
+	map->ids[map->numHooks++].id = nextid;
 }
 
 FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
 {
-	mobjtype_t   mobj_type = luaL_optnumber(L, 3, MT_NULL);
+	mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
 
 	luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t");
 
@@ -282,11 +296,11 @@ struct Hook_State {
 	INT32        status;/* return status to calling function */
 	void       * userdata;
 	int          hook_type;
-	mobjtype_t   mobj_type;/* >0 if mobj hook */
-	boolean      force_mobj;// allows mobj_type equal 0
+	mobjtype_t   mobj_type;/* <NUMMOBJTYPES if mobj hook */
 	const char * string;/* used to fetch table, ran first if set */
 	int          top;/* index of last argument passed to hook */
 	int          id;/* id to fetch ref */
+	boolean      important;/* is this hook from local addon */
 	int          values;/* num arguments passed to hook */
 	int          results;/* num values returned by hook */
 	Hook_Callback results_handler;/* callback when hook successfully returns */
@@ -349,10 +363,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_hook
 		int default_status,
 		int hook_type
 ){
-	hook->force_mobj = false;
-
 	return init_hook_type(hook, default_status,
-			hook_type, 0, NULL,
+			hook_type, NUMMOBJTYPES, NULL,
 			hookIds[hook_type].numHooks);
 }
 
@@ -366,8 +378,6 @@ FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
 	const mobjtype_t mobj_type =
 		primary_mobj ? primary_mobj->type : NUMMOBJTYPES;
 
-	hook->force_mobj = true;
-
 	return init_hook_type(hook, default_status,
 			hook_type, mobj_type, NULL,
 			mobj_hook_available(hook_type, mobj_type));
@@ -380,10 +390,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_string_hook
 		int          hook_type,
 		const char * string
 ){
-	hook->force_mobj = false;
-
 	if (init_hook_type(hook, default_status,
-				hook_type, 0, string,
+				hook_type, NUMMOBJTYPES, string,
 				stringHooks[hook_type].ref))
 	{
 		lua_pushstring(gL, string);
@@ -399,7 +407,7 @@ FUNCINLINE static ATTRINLINE boolean prepare_hud_hook
 		int hook_type
 ){
 	return init_hook_type(hook, 0,
-			hook_type, 0, NULL,
+			hook_type, NUMMOBJTYPES, NULL,
 			hudHookIds[hook_type].numHooks);
 }
 
@@ -416,22 +424,29 @@ FUNCINLINE static ATTRINLINE void init_hook_call
 	hook->results_handler = results_handler;
 }
 
-FUNCINLINE static ATTRINLINE void get_hook(Hook_State *hook, const int *ids, int n)
+FUNCINLINE static ATTRINLINE void get_hook(Hook_State *hook, const hookinfo_t *ids, int n)
 {
-	hook->id = ids[n];
+	hook->id = ids[n].id;
+	hook->important = ids[n].important;
 	lua_getref(gL, hookRefs[hook->id]);
 }
 
 FUNCINLINE static ATTRINLINE void get_hook_from_table(Hook_State *hook, int n)
 {
 	lua_rawgeti(gL, -1, n);
+	lua_rawgeti(gL, -1, 1);
 	hook->id = lua_tonumber(gL, -1);
 	lua_pop(gL, 1);
+	lua_rawgeti(gL, -2, 2);
+	hook->important = lua_toboolean(gL, -1);
+	lua_pop(gL, 2);
 	lua_getref(gL, hookRefs[hook->id]);
 }
 
 static int call_single_hook_no_copy(Hook_State *hook)
 {
+	hook_important = hook->important;
+
 	if (lua_pcall(gL, hook->values, hook->results, EINDEX) == 0)
 	{
 		if (hook->results > 0)
@@ -532,14 +547,11 @@ static int call_hooks
 	{
 		calls += call_string_hooks(hook);
 	}
-	else if (hook->force_mobj)
+	else if (hook->mobj_type < NUMMOBJTYPES)
 	{
 		/* call generic mobj hooks first */
 		calls += call_mobj_type_hooks(hook, MT_NULL);
-
-		if (hook->mobj_type < NUMMOBJTYPES)
-			calls += call_mobj_type_hooks(hook, hook->mobj_type);
-
+		calls += call_mobj_type_hooks(hook, hook->mobj_type);
 		ps_lua_mobjhooks.value.i += calls;
 	}
 	else
@@ -593,7 +605,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);
@@ -604,7 +616,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);
@@ -616,14 +628,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);
@@ -633,7 +645,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);
@@ -643,7 +655,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);
@@ -654,7 +666,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);
@@ -673,7 +685,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);
@@ -701,7 +713,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;
@@ -761,7 +773,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);
@@ -780,7 +792,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);
@@ -868,8 +880,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))
 	{
@@ -889,7 +901,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))
 	{
@@ -902,7 +914,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
@@ -931,7 +943,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);
@@ -945,7 +957,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)
 	{
@@ -975,7 +987,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
@@ -1038,7 +1050,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;
 
@@ -1074,7 +1086,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);
@@ -1092,7 +1104,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);
@@ -1141,7 +1153,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, }