Merge branch 'Saturn-Next' into Saturn

release 9.2
2025-12-06 15:45:51 +01:00 · 2025-12-06 15:33:41 +01:00 · 2025-12-06 15:33:08 +01:00
190 changed files with 5447 additions and 8711 deletions
@@ -1,46 +1,14 @@
 cmake_minimum_required(VERSION 3.5)
-
-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)
+	LANGUAGES C)

-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()
+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()

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

@@ -105,7 +73,6 @@ 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)
@@ -128,12 +95,14 @@ 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)
@@ -142,3 +111,25 @@ 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)
@@ -22,14 +22,14 @@ We also have a Flatpak available on [Flathub](https://flathub.org/en/apps/org.sr

 See [SRB2 Wiki/Source code compiling](http://wiki.srb2.org/wiki/Source_code_compiling). The compiling process for SRB2Kart is largely identical to SRB2.

-For Windows only the Makefile build system with GCC or Clang compiler is supported.
+Currently only the Makefile build system with GCC or Clang compiler is supported.
+CMake is NOT supported at the moment, but will be availible again soon.
+
 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
@@ -1,10 +1,5 @@
 ## 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 "")
@@ -1,6 +1,6 @@
 include(LibFindMacros)

-libfind_pkg_check_modules(GME_PKGCONF LIBGME)
+libfind_pkg_check_modules(GME_PKGCONF GME)

 find_path(GME_INCLUDE_DIR
 	NAMES gme.h
@@ -8,7 +8,6 @@ find_path(GME_INCLUDE_DIR
 		${GME_PKGCONF_INCLUDE_DIRS}
 		"/usr/include/gme"
 		"/usr/local/include/gme"
-	PATH_SUFFIXES gme
 )

 find_library(GME_LIBRARY
@@ -21,4 +20,4 @@ find_library(GME_LIBRARY

 set(GME_PROCESS_INCLUDES GME_INCLUDE_DIR)
 set(GME_PROCESS_LIBS GME_LIBRARY)
-libfind_process(GME)
+libfind_process(GME)
@@ -1,6 +1,6 @@
 include(LibFindMacros)

-libfind_pkg_check_modules(OPENMPT_PKGCONF LIBOPENMPT)
+libfind_pkg_check_modules(OPENMPT_PKGCONF OPENMPT)

 find_path(OPENMPT_INCLUDE_DIR
 	NAMES libopenmpt.h
@@ -8,7 +8,6 @@ find_path(OPENMPT_INCLUDE_DIR
 		${OPENMPT_PKGCONF_INCLUDE_DIRS}
 		"/usr/include/libopenmpt"
 		"/usr/local/include/libopenmpt"
-	PATH_SUFFIXES libopenmpt
 )

 find_library(OPENMPT_LIBRARY
@@ -21,4 +20,4 @@ find_library(OPENMPT_LIBRARY

 set(OPENMPT_PROCESS_INCLUDES OPENMPT_INCLUDE_DIR)
 set(OPENMPT_PROCESS_LIBS OPENMPT_LIBRARY)
-libfind_process(OPENMPT)
+libfind_process(OPENMPT)
@@ -1,33 +0,0 @@
-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()
@@ -1,4 +1,4 @@
-# Version 2.4
+# Version 2.2
 # 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,10 +52,6 @@ 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.
@@ -129,39 +125,24 @@ function (libfind_process PREFIX)

  # Process deps to add to
  foreach (i ${PREFIX} ${${PREFIX}_DEPENDENCIES})
-    if (DEFINED ${i}_INCLUDE_OPTS)
+    if (DEFINED ${i}_INCLUDE_OPTS OR DEFINED ${i}_LIBRARY_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 (DEFINED ${i}_LIBRARY)
+      # 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))
        # Singular forms can be used
-        list(APPEND libraryopts ${i}_LIBRARY)
-      else()
-        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!")
+        if (DEFINED ${i}_INCLUDE_DIR)
+          list(APPEND includeopts ${i}_INCLUDE_DIR)
        endif()
+        if (DEFINED ${i}_LIBRARY)
+          list(APPEND libraryopts ${i}_LIBRARY)
+        endif()
+      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!")
      endif()
    endif()
  endforeach()
@@ -228,12 +209,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()

@@ -2,8 +2,6 @@

 # Core sources
 set(SRB2_CORE_SOURCES
-	core/memory.cpp
-	core/thread_pool.cpp
 	am_map.c
 	b_bot.c
 	command.c
@@ -20,21 +18,17 @@ 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
@@ -46,25 +40,19 @@ 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.cpp
+	w_wad.c
 	y_inter.c
-	z_zone.cpp
+	z_zone.c
 )

 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
@@ -90,7 +78,6 @@ set(SRB2_CORE_HEADERS
 	fastcmp.h
 	filesrch.h
 	g_game.h
-	g_demo.h
 	g_input.h
 	g_state.h
 	hu_stuff.h
@@ -122,7 +109,6 @@ set(SRB2_CORE_HEADERS
 	md5.h
 	mserv.h
 	qs22j.h
-	r_skins.h
 	s_sound.h
 	screen.h
 	sounds.h
@@ -137,18 +123,18 @@ set(SRB2_CORE_HEADERS
 )

 set(SRB2_CORE_RENDER_SOURCES
-	r_bsp.cpp
+	r_bsp.c
 	r_data.c
-	r_draw.cpp
-	r_fps.cpp
-	r_main.cpp
-	r_patch.cpp
-	r_patchrotation.cpp
-	r_plane.cpp
-	r_segs.cpp
+	r_draw.c
+	r_fps.c
+	r_main.c
+	r_patch.c
+	r_patchrotation.c
+	r_plane.c
+	r_segs.c
 	r_sky.c
 	r_splats.c
-	r_things.cpp
+	r_things.c
 	r_portal.c

 	r_bsp.h
@@ -176,7 +162,7 @@ set(SRB2_CORE_GAME_SOURCES
 	p_inter.c
 	p_lights.c
 	p_map.c
-	p_maputl.cpp
+	p_maputl.c
 	p_mobj.c
 	p_polyobj.c
 	p_saveg.c
@@ -207,6 +193,10 @@ 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)
@@ -236,23 +226,10 @@ 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)
@@ -492,36 +469,16 @@ 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.cpp
+		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c
-		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp
+		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
@@ -536,6 +493,7 @@ 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
@@ -554,6 +512,7 @@ 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})
@@ -566,40 +525,25 @@ if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
 	endif()
 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)
+if(${SRB2_CONFIG_HWRENDER})
+	if(${SRB2_CONFIG_USE_FBO_OGL})
+		set(SRB2_USE_FBO_OGL ON)
+		add_definitions(-DUSE_FBO_OGL)
+	endif()
 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" 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)
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -mno-ms-bitfields)
 endif()

-# 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)
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -Wno-absolute-value)
 endif()

-add_compile_options(-g)
-
 add_definitions(-DCMAKECONFIG)

 #add_library(SRB2Core STATIC
@@ -93,8 +93,7 @@
 # NOLDWARNING=1 - ?
 # NOSDLMAIN=1 - ?
 # SDLMAIN=1 - ?
-# NOLTO=1 - Disable link time optimizations
-# USEJEMALLOC=1 Enable building with jemalloc Allocator to replace GLibc malloc, might improve performance
+# USELTO=1 - Enable building with LTO.
 #
 # Library configuration flags:
 # Everything here is an override.
@@ -261,7 +260,7 @@ debug_opts=-D_DEBUG
 else # build a normal optimized version
 debug_opts=-DNDEBUG
 opts+=-O3
-ifndef NOLTO
+ifdef USELTO
 # compile with LTO
 opts+=-flto=auto
 libs+=-flto=auto
@@ -270,20 +269,16 @@ endif

 ifdef USEASAN
 # compile with asan
-opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
+opts+=-fsanitize=address
 libs+=-fsanitize=address
 endif

 ifdef USEUBSAN
-# compile with ubsan
-opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
+# compile with asan
+opts+=-fsanitize=undefined
 libs+=-fsanitize=undefined
 endif

-ifdef USEJEMALLOC
-libs+=-ljemalloc
-endif
-
 ifneq (,$(filter $(CC) $(CXX),clang clang++))
 libs+=-fuse-ld=lld
 endif
@@ -300,7 +295,6 @@ opts+=$(debug_opts)

 opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))

-CWFLAGS+=-std=gnu17
 CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers

 opts+=$(WFLAGS) $(CFLAGS)
@@ -64,10 +64,9 @@ endif

 # This must have high to low order.
 gcc_versions:=\
-	161 160 16\
-	152 151 150 15\
+	151 150 15\
 	142 141 140 14\
-	133 132 131 130 13\
+	132 131 130 13\
 	123 122 121 120 12\
 	114 113 112 111 110 11\
 	105 104 103 102 101 100 10\
@@ -78,7 +77,7 @@ gcc_versions:=\
 	55 54 53 52 51 50\
 	49 48 47 46 45 44 43 42 41 40

-latest_gcc_version:=16.1
+latest_gcc_version:=15.1.1

 # Automatically set version flag, but not if one was
 # manually set. And don't bother if this is a clean only
@@ -8,7 +8,6 @@ passthru_opts+=\
 	HAVE_MINIUPNPC\
 	HAVE_DISCORDRPC DEVELOP\
 	NOHOLEPUNCH\
-	HAVE_IPV6\

 # build with debugging information
 ifdef DEBUGMODE
@@ -20,11 +20,7 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return

 # -W -Wno-unused
-WFLAGS:=-Wall -Wnull-dereference
-#WFLAGS+=-Wno-trigraphs
-ifdef GCC152
-WFLAGS+=-Wzero-as-null-pointer-constant
-endif
+WFLAGS:=-Wall -Wno-trigraphs
 ifndef GCC295
 #WFLAGS+=-Wno-packed
 endif
@@ -32,7 +28,7 @@ ifndef RELAXWARNINGS
 WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
-# WFLAGS+=-Wno-div-by-zero
+ WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -63,7 +59,7 @@ endif
 endif
 WFLAGS+=-Wsign-compare
 ifdef GCC91
-# WFLAGS+=-Wno-error=address-of-packed-member
+ WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
 WFLAGS+=-Wlogical-op
@@ -106,14 +102,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-#WFLAGS+=-Wno-error=format-overflow=2
+WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-#WFLAGS+=-Wno-suggest-attribute=noreturn
+WFLAGS+=-Wno-suggest-attribute=noreturn
 endif

 ifdef NOLDWARNING
@@ -131,21 +127,21 @@ ifdef GCC44
 #WFLAGS+=-Wno-error=array-bounds
 endif
 ifdef GCC46
-# WFLAGS+=-Wno-error=suggest-attribute=noreturn
+ WFLAGS+=-Wno-error=suggest-attribute=noreturn
 endif
 ifdef GCC54
-# WFLAGS+=-Wno-logical-op -Wno-error=logical-op
+ WFLAGS+=-Wno-logical-op -Wno-error=logical-op
 endif
 ifdef GCC61
-# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
+ WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
 endif
 ifdef GCC71
 WFLAGS+=-Wimplicit-fallthrough=4
 endif
 ifdef GCC81
-# WFLAGS+=-Wno-error=format-overflow
-# WFLAGS+=-Wno-format-overflow
-# WFLAGS+=-Wno-error=multistatement-macros
+ WFLAGS+=-Wno-error=format-overflow
+ WFLAGS+=-Wno-format-overflow
+ WFLAGS+=-Wno-error=multistatement-macros
 endif

 ifneq (,$(filter $(CC) $(CXX),clang clang++))
@@ -184,6 +180,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-#WFLAGS+=-Wno-logical-op
+WFLAGS+=-Wno-logical-op
 endif
 endif
@@ -226,6 +226,10 @@ 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?!");
@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
 LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
  lua_lock(L);
  luaC_checkGC(L);
-  setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len));
+  setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
  api_incr_top(L);
  lua_unlock(L);
 }
@@ -519,22 +519,6 @@ LUA_API int lua_pushthread (lua_State *L) {
 ** get functions (Lua -> stack)
 */

-static void auxgetstr (lua_State *L, TValue *t, const char *k) {
-  TValue *slot;
-  TValue key;
-  TString *str = luaS_new(L, k);
-  api_checkvalidindex(L, t);
-  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
-    setobj2s(L, L->top, slot);
-  }
-  else {
-    setsvalue(L, &key, str);
-    luaV_finishget(L, t, &key, L->top, slot);
-  }
-  api_incr_top(L);
-  lua_unlock(L);
-}
-

 LUA_API void lua_gettable (lua_State *L, int idx) {
  StkId t;
@@ -547,8 +531,15 @@ LUA_API void lua_gettable (lua_State *L, int idx) {


 LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+  StkId t;
+  TValue key;
  lua_lock(L);
-  auxgetstr(L, index2adr(L, idx), k);
+  t = index2adr(L, idx);
+  api_checkvalidindex(L, t);
+  setsvalue(L, &key, luaS_new(L, k));
+  luaV_gettable(L, t, &key, L->top);
+  api_incr_top(L);
+  lua_unlock(L);
 }


@@ -20,7 +20,6 @@
 #define lauxlib_c
 #define LUA_LIB

-#include "ldebug.h"
 #include "lua.h"

 #include "lauxlib.h"
@@ -469,19 +468,8 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {


 LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
- while (l) {
-    size_t space = bufffree(B);
-    if (space == 0) {
-      luaL_prepbuffer(B);
-      lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
-      space = LUAL_BUFFERSIZE;
-    }
-    if (space > l) space = l;
-    memcpy(B->p, s, space);
-    B->p += space;
-    s += space;
-    l -= space;
-  }
+  while (l--)
+    luaL_addchar(B, *s++);
 }


@@ -698,6 +686,6 @@ static int panic (lua_State *L) {

 LUALIB_API lua_State *luaL_newstate (void) {
  lua_State *L = lua_newstate(l_alloc, NULL);
-  if (l_likely(L)) lua_atpanic(L, &panic);
+  if (L) lua_atpanic(L, &panic);
  return L;
 }
@@ -790,19 +790,18 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
    case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
    case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
    case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
-    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_MOD: case OPR_POW: {
-      codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
-      break;
-    }
-    case OPR_EQ: case OPR_LT: case OPR_LE: {
-      codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
-      break;
-    }
-    case OPR_NE: case OPR_GT: case OPR_GE: {
-      codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
-      break;
-    }
+    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
+    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
+    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
+    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
+    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
+    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
+    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
+    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
+    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
+    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
+    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
+    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
    default: lua_assert(0);
  }
 }
@@ -21,13 +21,13 @@


 /*
-** grep "ORDER OPR" if you change these enums  (ORDER OP)
+** grep "ORDER OPR" if you change these enums
 */
 typedef enum BinOpr {
  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
  OPR_CONCAT,
-  OPR_EQ, OPR_LT, OPR_LE,
-  OPR_NE, OPR_GT, OPR_GE,
+  OPR_NE, OPR_EQ,
+  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
  OPR_AND, OPR_OR,
  OPR_BAND, OPR_BOR, OPR_BXOR,
  OPR_BSHL, OPR_BSHR,
@@ -542,39 +542,16 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,


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


@@ -55,8 +55,8 @@ struct lua_longjmp {

 void luaD_seterrorobj (lua_State *L, int lerrcode, StkId oldtop) {
  switch (lerrcode) {
-    case LUA_ERRMEM: {  /* memory error? */
-      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
+    case LUA_ERRMEM: {
+      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
      break;
    }
    case LUA_ERRERR: {
@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {


 void luaD_growstack (lua_State *L, int n) {
-  if (n <= L->stacksize)  /* double size is enough? */
+  if (l_likely(n <= L->stacksize))  /* double size is enough? */
    luaD_reallocstack(L, 2*L->stacksize);
  else
    luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
    ci->top = L->top + LUA_MINSTACK;
    lua_assert(ci->top <= L->stack_last);
    ci->nresults = nresults;
-    if (l_unlikely(L->hookmask & LUA_MASKCALL))
+    if (L->hookmask & LUA_MASKCALL)
      luaD_callhook(L, LUA_HOOKCALL, -1);
    lua_unlock(L);
    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
@@ -544,7 +544,6 @@ static void atomic (lua_State *L) {
  marktmu(g);  /* mark `preserved' userdata */
  udsize += propagateall(g);  /* remark, to propagate `preserveness' */
  cleartable(g->weak);  /* remove collected objects from weak tables */
-  luaS_clearcache(g);
  /* flip current white */
  g->currentwhite = cast_byte(otherwhite(g));
  g->sweepstrgc = 0;
@@ -356,21 +356,20 @@ static int read_line (lua_State *L, FILE *f) {


 static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t tbr = n;  /* number of chars to be read */
-  size_t rlen;  /* how much to read in each cycle */
-  size_t nr;  /* number of chars actually read in each cycle */
+  size_t rlen;  /* how much to read */
+  size_t nr;  /* number of chars actually read */
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
  do {
    char *p = luaL_prepbuffer(&b);
-    if (rlen > tbr) rlen = tbr;  /* cannot read more than asked */
+    if (rlen > n) rlen = n;  /* cannot read more than asked */
    nr = fread(p, sizeof(char), rlen, f);
    luaL_addsize(&b, nr);
-    tbr -= nr;  /* still have to read 'tbr' chars */
-  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
+    n -= nr;  /* still have to read `n' chars */
+  } while (n > 0 && nr == rlen);  /* until end of count or eof */
  luaL_pushresult(&b);  /* close buffer */
-  return (tbr == 0 || tbr < n);  /* true iff read something */
+  return (n == 0 || lua_objlen(L, -1) > 0);
 }


@@ -433,13 +432,13 @@ static int f_read (lua_State *L) {

 static int io_readline (lua_State *L) {
  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
-  int success;
+  int sucess;
  if (f == NULL)  /* file is already closed? */
    luaL_error(L, "file is already closed");
-  success = read_line(L, f);
+  sucess = read_line(L, f);
  if (ferror(f))
    return luaL_error(L, "%s", strerror(errno));
-  if (success) return 1;
+  if (sucess) return 1;
  else {  /* EOF */
    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
      lua_settop(L, 0);
@@ -41,25 +41,6 @@ typedef unsigned char lu_byte;
 */
 #define IntPoint(p)  ((unsigned int)(lu_mem)(p))

-/*
-** conversion of pointer to unsigned integer: this is for hashing only;
-** there is no problem if the integer cannot hold the whole pointer
-** value. (In strict ISO C this may cause undefined behavior, but no
-** actual machine seems to bother.)
-*/
-#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
-    __STDC_VERSION__ >= 199901L
-#include <stdint.h>
-#if defined(UINTPTR_MAX)  /* even in C99 this type is optional */
-#define L_P2I	uintptr_t
-#else  /* no 'intptr'? */
-#define L_P2I	uintmax_t  /* use the largest available integer */
-#endif
-#else  /* C89 option */
-#define L_P2I	size_t
-#endif
-
-#define point2uint(p)	((unsigned int)((L_P2I)(p) & UINT_MAX))


 /* type to ensure maximum alignment */
@@ -119,17 +100,6 @@ typedef lu_int32 Instruction;
 #endif


-/*
-** Size of cache for strings in the API. 'N' is the number of
-** sets (better be a prime) and "M" is the size of each set (M == 1
-** makes a direct cache.)
-*/
-#ifndef STRCACHE_N
-#define STRCACHE_N	53
-#define STRCACHE_M	2
-#endif
-
-
 /* minimum size for string buffer */
 #ifndef LUA_MINBUFFER
 #define LUA_MINBUFFER	32
@@ -13,6 +13,8 @@
 #include "llimits.h"
 #include "lua.h"

+#define MEMERRMSG	"not enough memory"
+

 #define luaM_reallocv(L,b,on,n,e) \
 	((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ?  /* +1 to avoid warnings */ \
@@ -881,10 +881,10 @@ static const struct {
  lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
-   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
-   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
-   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
-   {2, 2}, {1, 1}                   /* and, or */
+   {10, 9}, {5, 4},                 /* power and concat (right associative) */
+   {3, 3}, {3, 3},                  /* equality and inequality */
+   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
+   {2, 2}, {1, 1}                   /* logical (and/or) */
   ,{6, 6}, {6, 6}, {6, 6},           /* bit-wise (band/bor/bxor) */
   {7, 7}, {7, 7}		    /* shl/shr */
 };
@@ -73,9 +73,10 @@ static void f_luaopen (lua_State *L, void *ud) {
  stack_init(L, L);  /* init stack */
  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
-  luaS_init(L);
+  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
+  luaS_fix(luaS_newliteral(L, MEMERRMSG));
  g->GCthreshold = 4*g->totalbytes;
 }

@@ -88,11 +88,9 @@ typedef struct global_State {
  lua_CFunction panic;  /* to be called in unprotected errors */
  TValue l_registry;
  struct lua_State *mainthread;
-  TString *memerrmsg;  /* memory-error message */
  UpVal uvhead;  /* head of double-linked list of all open upvalues */
  struct Table *mt[NUM_TAGS];  /* metatables for basic types */
  TString *tmname[TM_N];  /* array with tag-method names */
-  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
 } global_State;


@@ -18,9 +18,6 @@
 #include "lstring.h"


-#define MEMERRMSG       "not enough memory"
-
-

 void luaS_resize (lua_State *L, int newsize) {
  GCObject **newhash;
@@ -54,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
                                       unsigned int h) {
  TString *ts;
  stringtable *tb;
-  if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
+  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
    luaM_toobig(L);
  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
  ts->tsv.len = l;
@@ -75,106 +72,18 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
 }


-/*
-** Clear API string cache. (Entries cannot be empty, so fill them with
-** a non-collectable string.)
-*/
-void luaS_clearcache (global_State *g) {
-  int i, j;
-  for (i = 0; i < STRCACHE_N; i++)
-    for (j = 0; j < STRCACHE_M; j++) {
-      if (luaS_iswhite(g->strcache[i][j]))  /* will entry be collected? */
-        g->strcache[i][j] = g->memerrmsg;  /* replace it with something fixed */
-    }
-}
-
-
-/*
-** Initialize the string table and the string cache
-*/
-void luaS_init (lua_State *L) {
-  global_State *g = G(L);
-  int i, j;
-  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
-  /* pre-create memory-error message */
-  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
-  luaS_fix(g->memerrmsg);  /* it should never be collected */
-  for (i = 0; i < STRCACHE_N; i++)  /* fill cache with valid strings */
-    for (j = 0; j < STRCACHE_M; j++)
-      g->strcache[i][j] = g->memerrmsg;
-}
-
-
-// string hash taken from luaJIT
-
-/* Unaligned load of uint32_t. */
-static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
-{
-  uint32_t result;
-  memcpy(&result, ptr, 4);
-  return result;
-}
-
-// smol macro to look a little less messy lul
-#define getu8(p) *cast(const uint8_t *, p)
-
-/* Keyed sparse ARX string hash. Constant time. */
-static unsigned hash_sparse(const char *str, size_t len)
-{
-  /* Constants taken from lookup3 hash by Bob Jenkins. */
-  unsigned int a, b, h = cast(unsigned int, len);
-#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
-  if (len >= 4) {  /* Caveat: unaligned access! */
-    a  = getu32(str);
-    h ^= getu32(str+len-4);
-    b  = getu32(str+(len>>1)-2);
-    h ^= b; h -= rol(b, 14);
-    b += getu32(str+(len>>2)-1);
-  } else if (len > 0) {
-    a  = getu8(str);
-    h ^= getu8(str+len-1);
-    b  = getu8(str+(len>>1));
-    h ^= b; h -= rol(b, 14);
-  } else {
-    return 0;
-  }
-  a ^= h; a -= rol(h, 11);
-  b ^= a; b -= rol(a, 25);
-  h ^= b; h -= rol(b, 16);
-#undef rol
-  return h;
-}
-
-#undef getu8
-
-
-static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
-#if 0
+TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
+  GCObject *o;
  unsigned int h = cast(unsigned int, l);  /* seed */
  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
  size_t l1;
  for (l1=l; l1>=step; l1-=step)  /* compute hash */
    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
-  return h;
-#else
-  return hash_sparse(str, l);
-#endif
-}
-
-
-/*
-** new string (with explicit length)
-*/
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
-  unsigned int h = luaS_hash(str, l);
  for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
       o != NULL;
       o = o->gch.next) {
    TString *ts = rawgco2ts(o);
-    if (ts->tsv.hash == h &&
-        ts->tsv.len == l &&
-       (memcmp(str, getstr(ts), l) == 0)) {
+    if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
      /* string may be dead */
      if (isdead(G(L), o)) changewhite(o);
      return ts;
@@ -184,29 +93,6 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
 }


-/*
-** Create or reuse a zero-terminated string, first checking in the
-** cache (using the string address as a key). The cache can contain
-** only zero-terminated strings, so it is safe to use 'strcmp' to
-** check hits.
-*/
-TString *luaS_new (lua_State *L, const char *str) {
-  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
-  int j;
-  TString **p = G(L)->strcache[i];
-  for (j = 0; j < STRCACHE_M; j++) {
-    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
-      return p[j];  /* that is it */
-  }
-  /* normal route */
-  for (j = STRCACHE_M - 1; j > 0; j--)
-    p[j] = p[j - 1];  /* move out last element */
-  /* new element is first in the list */
-  p[0] = luaS_newlstr(L, str, strlen(str));
-  return p[0];
-}
-
-
 Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (l_unlikely(s > MAX_SIZET - sizeof(Udata)))
@@ -17,19 +17,15 @@

 #define sizeudata(u)	(sizeof(union Udata)+(u)->len)

-//#define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
+#define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
                                 (sizeof(s)/sizeof(char))-1))

-#define luaS_iswhite(x)      test2bits((x)->tsv.marked, WHITE0BIT, WHITE1BIT)
-#define luaS_fix(s)	         l_setbit((s)->tsv.marked, FIXEDBIT)
+#define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)

 LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC void luaS_clearcache (global_State *g);
-LUAI_FUNC void luaS_init (lua_State *L);
 LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
 LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
-LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);


 #endif
@@ -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, NULL) + 2;
+          return push_captures(&ms, NULL, 0) + 2;
        }
        else
          return push_captures(&ms, s1, res);
@@ -81,7 +81,6 @@ static /*const*/ Node dummynode_ = {
 /*
 ** hash for lua_Numbers
 */
-#if 0
 static Node *hashnum (const Table *t, lua_Number n) {
  unsigned int a[numints];
  int i;
@@ -91,12 +90,6 @@ static Node *hashnum (const Table *t, lua_Number n) {
  for (i = 1; i < numints; i++) a[0] += a[i];
  return hashmod(t, a[0]);
 }
-#else
-// our lua_Number is just typedef´d int32 so no need to do any of the above
-static inline Node *hashnum (const Table *t, lua_Number n) {
-  return hashmod(t, cast(unsigned int, n));
-}
-#endif



@@ -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), 1))
-#define l_unlikely(x)	(__builtin_expect(!!(x), 0))
+#define l_likely(x)	(__builtin_expect(((x) != 0), 1))
+#define l_unlikely(x)	(__builtin_expect(((x) != 0), 0))
 #else
-#define l_likely(x)		(x)
+#define l_likely(x)	(x)
 #define l_unlikely(x)	(x)
 #endif

@@ -28,7 +28,7 @@



-/* limit for table tag-method chains (to avoid infinite loops) */
+/* limit for table tag-method chains (to avoid loops) */
 #define MAXTAGLOOP	100


@@ -105,42 +105,27 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
 }


-/*
-** Finish the table access 'val = t[key]'.
-** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
-** t[k] entry (which must be nil).
-*/
-void luaV_finishget (lua_State *L, TValue *t, TValue *key, StkId val,
-                     TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  TValue *tm;  /* metamethod */
+void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
+  int loop;
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    if (slot == NULL) {  /* 't' is not a table? */
-      lua_assert(!ttistable(t));
-      tm = luaT_gettmbyobj(L, t, TM_INDEX);
-      if (l_unlikely(ttisnil(tm)))
-        luaG_typeerror(L, t, "index");  /* no metamethod */
-      /* else will try the metamethod */
-    }
-    else {  /* 't' is a table */
-      lua_assert(ttisnil(slot));
-      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        setnilvalue(val);  /* result is nil */
+    TValue *tm;
+    if (ttistable(t)) {  /* `t' is a table? */
+      Table *h = hvalue(t);
+      const TValue *res = luaH_get(h, key); /* do a primitive get */
+      if (!ttisnil(res) ||  /* result is no nil? */
+          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
+        setobj2s(L, val, res);
        return;
      }
-      /* else will try the metamethod */
+      /* else will try the tag method */
    }
-    if (ttisfunction(tm)) {  /* is metamethod a function? */
-      callTMres(L, val, tm, t, key);  /* call it */
+    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
+      luaG_typeerror(L, t, "index");
+    if (ttisfunction(tm)) {
+      callTMres(L, val, tm, t, key);
      return;
    }
-    t = tm;  /* else try to access 'tm[key]' */
-    if (luaV_fastget(L, t, key, slot, luaH_get)) {  /* fast track? */
-      setobj2s(L, val, slot);  /* done */
-      return;
-    }
-    /* else repeat (tail call 'luaV_finishget') */
+    t = tm;  /* else repeat with `tm' */
  }
  luaG_runerror(L, "loop in gettable");
 }
@@ -154,12 +139,8 @@ void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
      Table *h = hvalue(t);
      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
      /* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
-      if (ttisnil(oldval)) {
-        tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */
-      } else {
-        tm = fasttm(L, h->metatable, TM_USEDINDEX);
-      }
-      if (tm == NULL) { /* no metamethod? */
+      if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
+         ((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
        setobj2t(L, oldval, val);
        luaC_barriert(L, h, val);
        return;
@@ -385,7 +366,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,


 #define arith_op(op,tm) { \
-        StkId ra = RA(i); \
        TValue *rb = RKB(i); \
        TValue *rc = RKC(i); \
        if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -397,14 +377,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
      }


-/*
-** copy of 'luaV_gettable', but protecting call to potential metamethod
-** (which can reallocate the stack)
-*/
-#define gettableProtected(L,t,k,v)  { TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else Protect(luaV_finishget(L,t,k,v,slot)); }
-

 void luaV_execute (lua_State *L, int nexeccalls) {
  LClosure *cl;
@@ -414,12 +386,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
 reentry:  /* entry point */
  lua_assert(isLua(L->ci));
  pc = L->savedpc;
-  cl = &clvalue(L->ci->func)->l;  /* local reference to function's closure */
-  k = cl->p->k;  /* local reference to function's constant table */
-  base = L->base;  /* local copy of function's base */
+  cl = &clvalue(L->ci->func)->l;
+  base = L->base;
+  k = cl->p->k;
  /* main loop of interpreter */
  for (;;) {
    const Instruction i = *pc++;
+    StkId ra;
    if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
        (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
      traceexec(L, pc);
@@ -429,28 +402,26 @@ void luaV_execute (lua_State *L, int nexeccalls) {
      }
      base = L->base;
    }
+    /* warning!! several calls may realloc the stack and invalidate `ra' */
+    ra = RA(i);
    lua_assert(base == L->base && L->base == L->ci->base);
    lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
    lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
    switch (GET_OPCODE(i)) {
      case OP_MOVE: {
-        StkId ra = RA(i);
        setobjs2s(L, ra, RB(i));
        continue;
      }
      case OP_LOADK: {
-        StkId ra = RA(i);
        setobj2s(L, ra, KBx(i));
        continue;
      }
      case OP_LOADBOOL: {
-        StkId ra = RA(i);
        setbvalue(ra, GETARG_B(i));
        if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
        continue;
      }
      case OP_LOADNIL: {
-        StkId ra = RA(i);
        TValue *rb = RB(i);
        do {
          setnilvalue(rb--);
@@ -458,13 +429,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_GETUPVAL: {
-        StkId ra = RA(i);
        int b = GETARG_B(i);
        setobj2s(L, ra, cl->upvals[b]->v);
        continue;
      }
      case OP_GETGLOBAL: {
-        StkId ra = RA(i);
        TValue g;
        TValue *rb = KBx(i);
        sethvalue(L, &g, cl->env);
@@ -473,14 +442,10 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_GETTABLE: {
-        StkId ra = RA(i);
-        StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        gettableProtected(L, rb, rc, ra);
+        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
        continue;
      }
      case OP_SETGLOBAL: {
-        StkId ra = RA(i);
        TValue g;
        sethvalue(L, &g, cl->env);
        lua_assert(ttisstring(KBx(i)));
@@ -488,21 +453,16 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_SETUPVAL: {
-        StkId ra = RA(i);
        UpVal *uv = cl->upvals[GETARG_B(i)];
        setobj(L, uv->v, ra);
        luaC_barrier(L, uv, ra);
        continue;
      }
      case OP_SETTABLE: {
-        StkId ra = RA(i);
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        Protect(luaV_settable(L, ra, rb, rc));
+        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
        continue;
      }
      case OP_NEWTABLE: {
-        StkId ra = RA(i);
        int b = GETARG_B(i);
        int c = GETARG_C(i);
        sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -510,11 +470,9 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_SELF: {
-        StkId ra = RA(i);
        StkId rb = RB(i);
-        TValue *rc = RKC(i);
-        setobjs2s(L, ra + 1, rb);
-        gettableProtected(L, rb, rc, ra);
+        setobjs2s(L, ra+1, rb);
+        Protect(luaV_gettable(L, rb, RKC(i), ra));
        continue;
      }
      case OP_ADD: {
@@ -530,7 +488,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_DIV: {
-        StkId ra = RA(i);
        TValue *rb = RKB(i);
        TValue *rc = RKC(i);
        if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -546,7 +503,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_MOD: {
-        StkId ra = RA(i);
        TValue *rb = RKB(i);
        TValue *rc = RKC(i);
        if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -566,27 +522,26 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_BAND: {
-        arith_op(luai_numand, TM_AND);
-        continue;
+	arith_op(luai_numand, TM_AND);
+	continue;
      }
      case OP_BOR: {
-        arith_op(luai_numor, TM_OR);
-        continue;
+	arith_op(luai_numor, TM_OR);
+	continue;
      }
      case OP_BXOR: {
-        arith_op(luai_numxor, TM_XOR);
-        continue;
+	arith_op(luai_numxor, TM_XOR);
+	continue;
      }
      case OP_BSHL: {
-        arith_op(luai_numshl, TM_SHL);
-        continue;
+	arith_op(luai_numshl, TM_SHL);
+	continue;
      }
      case OP_BSHR: {
-        arith_op(luai_numshr, TM_SHR);
-        continue;
+	arith_op(luai_numshr, TM_SHR);
+	continue;
      }
      case OP_BNOT: {
-        StkId ra = RA(i);
        TValue *rb = RB(i);
        if (ttisnumber(rb)) {
          lua_Number nb = nvalue(rb);
@@ -598,7 +553,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_UNM: {
-        StkId ra = RA(i);
        TValue *rb = RB(i);
        if (ttisnumber(rb)) {
          lua_Number nb = nvalue(rb);
@@ -610,13 +564,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_NOT: {
-        StkId ra = RA(i);
        int res = l_isfalse(RB(i));  /* next assignment may change this value */
        setbvalue(ra, res);
        continue;
      }
      case OP_LEN: {
-        StkId ra = RA(i);
        TValue *rb = RB(i);
        switch (ttype(rb)) {
          case LUA_TTABLE: {
@@ -674,14 +626,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_TEST: {
-        StkId ra = RA(i);
        if (l_isfalse(ra) != GETARG_C(i))
          dojump(L, pc, GETARG_sBx(*pc));
        pc++;
        continue;
      }
      case OP_TESTSET: {
-        StkId ra = RA(i);
        TValue *rb = RB(i);
        if (l_isfalse(rb) != GETARG_C(i)) {
          setobjs2s(L, ra, rb);
@@ -691,7 +641,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_CALL: {
-        StkId ra = RA(i);
        int b = GETARG_B(i);
        int nresults = GETARG_C(i) - 1;
        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
@@ -713,7 +662,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        }
      }
      case OP_TAILCALL: {
-        StkId ra = RA(i);
        int b = GETARG_B(i);
        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
        L->savedpc = pc;
@@ -746,7 +694,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        }
      }
      case OP_RETURN: {
-        StkId ra = RA(i);
        int b = GETARG_B(i);
        if (b != 0) L->top = ra+b-1;
        if (L->openupval) luaF_close(L, base);
@@ -762,7 +709,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        }
      }
      case OP_FORLOOP: {
-        StkId ra = RA(i);
        lua_Number step = nvalue(ra+2);
        lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
        lua_Number limit = nvalue(ra+1);
@@ -775,7 +721,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_FORPREP: {
-        StkId ra = RA(i);
        const TValue *init = ra;
        const TValue *plimit = ra+1;
        const TValue *pstep = ra+2;
@@ -792,7 +737,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_TFORLOOP: {
-        StkId ra = RA(i);
        StkId cb = ra + 3;  /* call base */
        setobjs2s(L, cb+2, ra+2);
        setobjs2s(L, cb+1, ra+1);
@@ -809,7 +753,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_SETLIST: {
-        StkId ra = RA(i);
        int n = GETARG_B(i);
        int c = GETARG_C(i);
        int last;
@@ -832,12 +775,10 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_CLOSE: {
-        StkId ra = RA(i);
        luaF_close(L, ra);
        continue;
      }
      case OP_CLOSURE: {
-        StkId ra = RA(i);
        Proto *p;
        Closure *ncl;
        int nup, j;
@@ -858,7 +799,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_VARARG: {
-        StkId ra = RA(i);
        int b = GETARG_B(i) - 1;
        int j;
        CallInfo *ci = L->ci;
@@ -22,34 +22,12 @@
 	(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))


-/*
-** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
-** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
-** return 0 (meaning it will have to check metamethod) with 'slot'
-** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
-** 'f' is the raw get function to use.
-*/
-#define luaV_fastget(L,t,k,slot,f) \
-  (!ttistable(t)  \
-   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
-      !ttisnil(slot)))  /* result not nil? */
-
-/*
-** standard implementation for 'gettable'
-*/
-#define luaV_gettable(L,t,k,v) { TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else luaV_finishget(L,t,k,v,slot); }
-
-
-
 LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
 LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
 LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
 LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
-LUAI_FUNC void luaV_finishget (lua_State *L, TValue *t, TValue *key,
-                               StkId val, TValue *tm);
+LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
+                                            StkId val);
 LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
                                            StkId val);
 LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
@@ -237,13 +237,10 @@ void COM_ImmedExecute(const char *ptext)
 	char line[1024] = "";
 	INT32 quotes;

-	const size_t txtlength = strlen(ptext);
-
-	while (i < txtlength)
+	while (i < strlen(ptext))
 	{
 		quotes = 0;
-
-		for (j = 0; i < txtlength; i++,j++)
+		for (j = 0; i < strlen(ptext); i++,j++)
 		{
 			if (ptext[i] == '\"' && !quotes && i > 0 && ptext[i-1] != ' ') // Malformed command
 				return;
@@ -655,7 +652,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 != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
 		{
 			if (strncmp(begin, head->name, szBegin) == 0)
 			{
@@ -676,7 +673,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 != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
 		{
 			CONS_Printf(alias_format, head->name, head->value);
 		}
@@ -1165,39 +1162,6 @@ 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.
@@ -1208,17 +1172,11 @@ static const char *cv_null_string = "";
  */
 consvar_t *CV_FindVar(const char *name)
 {
-	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;
 }
@@ -1233,7 +1191,7 @@ consvar_t *CV_FindVar(const char *name)
 static inline UINT16 CV_ComputeNetid(const char *s)
 {
 	UINT16 ret = 0, i = 0;
-	static const UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
+	static UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};

 	while (*s)
 	{
@@ -1252,17 +1210,11 @@ 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;
@@ -1328,11 +1280,6 @@ 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.
@@ -1638,21 +1585,9 @@ size_t CV_LoadNetVars(const UINT8 *bufstart)
 	// 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);
 	while (count--)
@@ -1855,7 +1790,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
 					if (newvalue == oldvalue)
 						break; // don't loop forever if there's none of a certain gametype

-					if (newvalue >= 0 && newvalue < NUMMAPS && !mapheaderinfo[newvalue])
+					if (newvalue >= 0 && !mapheaderinfo[newvalue])
 						continue; // Don't allocate the header.  That just makes memory usage skyrocket.

 				} while (!M_CanShowLevelInList(newvalue, gt));
@@ -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
 //===================================
@@ -11,6 +11,21 @@

 #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}"

@@ -18,10 +33,30 @@

 #else

-#define SRB2_COMP_REVISION       ""
-#define SRB2_COMP_BRANCH         ""
+/* 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 CMAKE_ASSETS_DIR         ""
+// 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

 #endif
 #endif
@@ -46,16 +46,16 @@
 #ifdef HAVE_THREADS
 I_mutex con_mutex;

-// I_In_Exiting_Signal_Handler is an evil hack
+// g_in_exiting_signal_handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
-#else /*HAVE_THREADS*/
+#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
+#else/*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif /*HAVE_THREADS*/
+#endif/*HAVE_THREADS*/

 static boolean con_started = false; // console has been initialised
       boolean con_startup = false; // true at game startup, screen need refreshing
@@ -208,6 +208,14 @@ static void CONS_Clear_f(void)
 	Unlock_state();
 }

+// Choose english keymap
+//
+/*static void CONS_English_f(void)
+{
+	shiftxform = english_shiftxform;
+	CONS_Printf(M_GetText("%s keymap.\n"), M_GetText("English"));
+}*/
+
 static char *bindtable[NUMINPUTS];

 static void CONS_Bind_f(void)
@@ -625,191 +633,72 @@ void CON_MoveConsole(void)
 	Unlock_state();
 }

-//======================================================================
-//                 KEYBOARD LAYOUTS FOR ENTERING TEXT
-//======================================================================
-
-static char english_shiftxform[] =
-{
-	0,
-	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-	31,
-	' ', '!', '"', '#', '$', '%', '&',
-	'"', // shift-'
-	'(', ')', '*', '+',
-	'<', // shift-,
-	'_', // shift--
-	'>', // shift-.
-	'?', // shift-/
-	')', // shift-0
-	'!', // shift-1
-	'@', // shift-2
-	'#', // shift-3
-	'$', // shift-4
-	'%', // shift-5
-	'^', // shift-6
-	'&', // shift-7
-	'*', // shift-8
-	'(', // shift-9
-	':',
-	':', // shift-;
-	'<',
-	'+', // shift-=
-	'>', '?', '@',
-	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
-	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-	'{', // shift-[
-	'|', // shift-backslash - OH MY GOD DOES WATCOM SUCK
-	'}', // shift-]
-	'"', '_',
-	'~', // shift-`
-	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
-	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-	'{', '|', '}', '~', 127
-};
-
-static char french_shiftxform[] =
-{
-	0,
-	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-	31,
-	' ','$', //shift-!
-	'3', //shift-"
-	'#', '$', '%',
-	'1', //shift-&
-	'4', // shift-'
-	'5', // shift-(
-	')', // shift-)
-	'*', '+',
-	'?', // shift-,
-	'6', // shift--
-	'.', '/',
-	'0', '1', '2', '3', '4', '5',
-	'6', '7', '8', '9',
-	'/', // shitf-:
-	'.', // shift-;
-	'>', // shift-<
-	'+', // shift-=
-	'>', '?', '@',
-	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
-	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-	'[', '\\', ']', '^',
-	'8', //shift-_
-	'`',
-	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
-	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-	'{', '|', '}', '~', 127,
-	128, 129,
-	'2',
-	131, 132,
-	'0',
-	134,
-	'9',
-	136, 137,
-	'7',
-	139, 140,
-	'%'
-};
-
-static char french_altgrxform[] =
-{
-	0,
-	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-	31,
-	' ', '!',
-	'#', //altgr-"
-	'#', '$', '%', '&',
-	'{', //altgr-'
-	'[', //altgr-(
-	']', //altgr-)
-	'*', '+', ',',
-	'|', //altg--
-	'.', '/',
-	'0', '1', '2', '3', '4', '5',
-	'6', '7', '8', '9',
-	':', ';', '<',
-	'}', //altgr-=
-	'>', '?', '@',
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
-	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-	'[', '\\', ']', '^',
-	'\\', //altgr-backslash
-	'`',
-	'a', 'b', 'c', 'd', 'E', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-	'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-	'{', '|', '}', '~', 127,
-	128, 129,
-	'~',
-	131, 132,
-	'@',
-	134,
-	'^',
-	136, 137,
-	'`',
-	139, 140,
-	KEY_FR_U_GRAVE
-};
-
-// fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
-static INT32 CON_FallBackFrSpecialLetter(INT32 key)
-{
-	switch (key)
-	{
-		case KEY_FR_E_AIGUE:     return 'e';
-		case KEY_FR_E_GRAVE:     return 'e';
-		case KEY_FR_C_CEDILLE:   return 'c';
-		case KEY_FR_A_GRAVE:     return 'a';
-		case KEY_FR_U_GRAVE:     return 'u';
-		default:       return key;
-	}
-}
-
-// goddang AZERTY
-static size_t CON_GetShiftSize(void)
-{
-	return ((cv_keyboardlayout.value == 3) ? sizeof(french_shiftxform) : sizeof(english_shiftxform));
-}
-
-static char *CON_Shiftform(void)
-{
-	return (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
-}
-
 INT32 CON_ShiftChar(INT32 ch)
 {
-	if (I_UseNativeKeyboard() || ch >= (INT32)CON_GetShiftSize())
+	if (I_UseNativeKeyboard())
 		return ch;

-	// warning: shiftdown is NOT a boolean, it's 1 or 2 for lshift/rshift
 	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
 	{
-		return !!shiftdown != capslock ? CON_Shiftform()[ch] : ch;
+		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];
+		}
 	}
-
-	// if we're holding shift we should still shift non letter symbols
-	if (shiftdown)
+	else	// if we're holding shift we should still shift non letter symbols
 	{
-		return CON_Shiftform()[ch];
-	}
-
-	// AZERTY
-	if (cv_keyboardlayout.value == 3)
-	{
-		if (altdown & 0x2)
-			return french_altgrxform[ch];
-
-		return CON_FallBackFrSpecialLetter(ch);
+		if (cv_keyboardlayout.value == 3)
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+			else if (altdown & 0x2)
+				ch = french_altgrxform[ch];
+			else
+				ch = HU_FallBackFrSpecialLetter(ch);
+		}
+		else
+		{
+			if (shiftdown)
+				ch = shiftxform[ch];
+		}
 	}

 	return ch;
 }

+INT32 CON_ShitAndAltGrChar(INT32 ch)
+{
+	if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
+	{
+		if (shiftdown ^ capslock)
+			ch = shiftxform[ch];
+	}
+	else	// if we're holding shift we should still shift non letter symbols
+	{
+		if (shiftdown)
+			ch = shiftxform[ch];
+		else if (altdown & 0x2)
+		{
+			ch = french_altgrxform[ch];
+		}
+		else
+		{
+			ch = HU_FallBackFrSpecialLetter(ch);
+		}
+	}
+
+	return ch;
+}

 // Clear time of console heads up messages
 //
@@ -1003,7 +892,7 @@ boolean CON_Responder(event_t *ev)
 		return true;

 	// ctrl modifier -- changes behavior, adds shortcuts
-	if (ctrldown && (cv_keyboardlayout.value != 3 || !altdown))
+	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
 	{
 		// show all cvars/commands that match what we have inputted
 		if (key == KEY_TAB)
@@ -1333,10 +1222,19 @@ void CON_LogMessage(const char *msg)
 // Console print! Wahooo! Lots o fun!
 //

-static inline void CONS_PrintMsg(char *txt)
+void CONS_Printf(const char *fmt, ...)
 {
+	va_list argptr;
+	static char *txt = NULL;
 	boolean startup;

+	if (txt == NULL)
+		txt = malloc(8192);
+
+	va_start(argptr, fmt);
+	vsnprintf(txt, 8192, fmt, argptr);
+	va_end(argptr);
+
 	// echo console prints to log file
 	DEBFILE(txt);

@@ -1362,21 +1260,6 @@ static inline void CONS_PrintMsg(char *txt)
 	}
 }

-void CONS_Printf(const char *fmt, ...)
-{
-	va_list argptr;
-	static char *txt = NULL;
-
-	if (txt == NULL)
-		txt = malloc(8192);
-
-	va_start(argptr, fmt);
-	vsnprintf(txt, 8192, fmt, argptr);
-	va_end(argptr);
-
-	CONS_PrintMsg(txt);
-}
-
 void CONS_Alert(alerttype_t level, const char *fmt, ...)
 {
 	va_list argptr;
@@ -1405,7 +1288,9 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
 			break;
 	}

-	CONS_PrintMsg(txt);
+	// I am lazy and I feel like just letting CONS_Printf take care of things.
+	// Is that okay?
+	CONS_Printf("%s", txt);
 }

 void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1423,9 +1308,11 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 	vsnprintf(txt, 8192, fmt, argptr);
 	va_end(argptr);

-	CONS_PrintMsg(txt);
+	// Again I am lazy, oh well
+	CONS_Printf("%s", txt);
 }

+
 // Print an error message, and wait for ENTER key to continue.
 // To make sure the user has seen the message
 //
@@ -13,10 +13,6 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__

-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -49,6 +45,7 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
 extern UINT8 *consolebgmap;

 INT32 CON_ShiftChar(INT32 ch);
+INT32 CON_ShitAndAltGrChar(INT32 ch);

 void CON_SetupBackColormap(void);
 void CON_ClearHUD(void); // clear heads up messages
@@ -66,8 +63,4 @@ boolean CON_Ready(void);

 void CON_LogMessage(const char *msg);

-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif
@@ -600,8 +600,6 @@ extern consvar_t cv_discordinvites;

 extern consvar_t cv_serverinfoscreen;

-extern consvar_t cv_serveraddoninfo;
-
 // Used in d_net, the only dependence
 //tic_t ExpandTics(INT32 low, tic_t basetic);
 void D_ClientServerInit(void);
@@ -656,17 +654,15 @@ void D_ResetTiccmds(void);

 tic_t GetLag(INT32 node);

-extern boolean hu_resynching;
+extern UINT8 hu_resynching;
 #ifdef SATURNPAK
-extern boolean hu_redownloadinggamestate;
+extern UINT8 hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player

-#define SAVEGAMESIZE (768*1024)
-
 typedef struct rewind_s
 {
-	UINT8 savebuffer[SAVEGAMESIZE];
+	UINT8 savebuffer[(768*1024)];
 	tic_t leveltime;
 	size_t demopos;

@@ -80,31 +80,6 @@

 #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
@@ -130,15 +105,14 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadwadcount = 0;
-static size_t postloadwadcount = 0;
+static size_t autoloadcount = 0;
+static size_t postloadcount = 0;
 //

 boolean devparm = false; // started game with -devparm

 boolean singletics = false; // timedemo
 boolean lastdraw = false;
-boolean intermissionbginit = false;

 #ifdef MOTIONBLUR
 INT32 postimgparam[MAXSPLITSCREENPLAYERS];
@@ -275,17 +249,21 @@ static void D_Renderview(void)

 	R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL));

-	if (rendermode == render_soft && cv_homremoval.value)
+	if (rendermode == render_soft)
 	{
-		if (cv_homremoval.value == 1)
+		// if this is display player 1
+		if (cv_homremoval.value)
 		{
-			// Clear the software screen buffer to remove HOM
-			memset(vid.screens[0], 31, vid.width * vid.height);
-		}
-		else if (cv_homremoval.value == 2)
-		{
-			//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
-			memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
+			if (cv_homremoval.value == 1)
+			{
+				// Clear the software screen buffer to remove HOM
+				memset(vid.screens[0], 31, vid.width * vid.height);
+			}
+			else if (cv_homremoval.value == 2)
+			{
+				//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
+				memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
+			}
 		}
 	}

@@ -319,6 +297,7 @@ static void D_Renderview(void)
 					break;
 				default: // Initialize for P1
 					viewwindowy = viewwindowx = 0;
+					objectsdrawn = 0;
 					break;
 			}

@@ -329,17 +308,19 @@ static void D_Renderview(void)
 			}
 			else if (rendermode == render_soft)
 #endif
-			{
 				R_RenderPlayerView(&players[displayplayers[i]]);
+		}
+
+		if (rendermode == render_soft)
+		{
+			if (i == 0)
+				R_ApplyViewMorph();

-				if (i == 0)
-					R_ApplyViewMorph();
 #ifdef MOTIONBLUR
-				V_DoPostProcessor(i, postimgparam[i]);
+			V_DoPostProcessor(i, postimgparam[i]);
 #else
-				V_DoPostProcessor(i, 0);
+			V_DoPostProcessor(i, 0);
 #endif
-			}
 		}
 	}

@@ -363,33 +344,6 @@ static void D_Renderview(void)
 // added comment : there is a wipe eatch change of the gamestate
 gamestate_t wipegamestate = GS_LEVEL;

-static void D_MakeIntermissionBG(void)
-{
-	if (!lastdraw)
-		return;
-
-	if (rendermode == render_none)
-	{
-		lastdraw = false;
-		intermissionbginit = false;
-		return;
-	}
-
-#ifdef HWRENDER
-	if (rendermode == render_opengl)
-	{
-		HWR_MakeScreenTexture();
-	}
-	else
-#endif
-	{
-		VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
-	}
-
-	lastdraw = false;
-	intermissionbginit = true;
-}
-
 static boolean D_Display(void)
 {
 	boolean ranwipe = false;
@@ -555,8 +509,16 @@ static boolean D_Display(void)
 			PS_START_TIMING(ps_rendercalltime);
 			D_Renderview();
 			PS_STOP_TIMING(ps_rendercalltime);
+		}

-			D_MakeIntermissionBG();
+		if (lastdraw)
+		{
+			if (rendermode == render_soft)
+			{
+				VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
+			}
+
+			lastdraw = false;
 		}

 		PS_START_TIMING(ps_uitime);
@@ -677,7 +639,7 @@ void D_SRB2Loop(void)
 	tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
 	double deltatics = 0.0;
 	double deltasecs = 0.0;
-	UINT64 precision = 0;
+	UINT64 precision;

 	boolean interp = false;
 	boolean doDisplay = false;
@@ -722,15 +684,8 @@ void D_SRB2Loop(void)
 		precise_t elapsed;
 		precise_t enterprecise, finishprecise;

-		boolean ranwipe = false;
-
 		enterprecise = I_GetPreciseTime();

-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		memset(&g_dc, 0, sizeof(g_dc));
 		Z_Frame_Reset();

@@ -738,6 +693,8 @@ void D_SRB2Loop(void)
 		const UINT32 framecap = R_GetFramerateCap();
 		capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round

+		boolean ranwipe = false;
+
 		I_UpdateTime(cv_timescale.value);

 		if (lastwipetic)
@@ -801,6 +758,11 @@ void D_SRB2Loop(void)

 				doDisplay = true;
 			}
+
+			if (!dedicated)
+			{
+				G_DeviceLEDTick();
+			}
 		}

 		if (interp)
@@ -842,13 +804,6 @@ void D_SRB2Loop(void)
 		if (takescreenshot)
 			M_DoScreenShot();

-#ifndef DEDICATED
-		if (!dedicated && renderisnewtic)
-		{
-			G_DeviceLEDTick();
-		}
-#endif
-
 		// consoleplayer -> displayplayers (hear sounds from viewpoint)
 		S_UpdateSounds(); // move positional sounds

@@ -927,9 +882,7 @@ void D_ClearState(void)

 	// okay, stop now
 	// (otherwise the game still thinks we're playing!)
-#ifdef HAVE_CURL
 	CURLAbortFile();
-#endif
 	SV_StopServer();
 	SV_ResetServer();

@@ -993,9 +946,6 @@ 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();
@@ -1057,38 +1007,25 @@ static INT32 D_DetectFileType(const char* filename)
 }

 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);

-	if (*index >= MAX_WADFILES)
-	{
-		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
-		return;
-	}
-
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}

-	if (fileType == 1)
-	{
-		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
-		return;
-	}
-
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
+			I_Error("No more free memory to AutoloadFile %s",file);

 		strcpy(newfile, file);
-		filearray[*index] = newfile;
-		(*index)++;
+		filearray[index] = newfile;
 	}
 	else
 	{
@@ -1131,7 +1068,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}

@@ -1157,34 +1094,27 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';

-		// ok so theres still issues with players adding stuff to autoload by accident
-		// sometimes this stuff contains maps
-		// you can probably imagine how that goes in a netgame....
-		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
-		{
-			CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
-			continue;
-		}
-
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}

 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
+			autoloadcount++;
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
+			postloadcount++;
 		}
 	}

-	autoloadwadfiles[autoloadwadcount] = NULL;
-	autoloadwadfilespost[postloadwadcount] = NULL;
+	autoloadwadfiles[autoloadcount] = NULL;
+	autoloadwadfilespost[postloadcount] = NULL;

 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1193,7 +1123,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadwadcount == 0)
+	if (autoloadcount == 0)
 		return;

 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1201,15 +1131,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");

-	D_CleanFile(autoloadwadfiles, autoloadwadcount);
+	D_CleanFile(autoloadwadfiles, autoloadcount);

-	autoloadwadcount = 0;
+	autoloadcount = 0;
 }

 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadwadcount == 0 || !netgame)
+	if (postloadcount == 0 || !netgame)
 		return;

 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1217,9 +1147,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");

-	D_CleanFile(autoloadwadfilespost, postloadwadcount);
+	D_CleanFile(autoloadwadfilespost, postloadcount);

-	postloadwadcount = 0;
+	postloadcount = 0;
 }

 // ==========================================================================
@@ -1228,7 +1158,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))
 	{
@@ -1256,13 +1186,17 @@ static void IdentifyVersion(void)
 #endif

 	char tempsrb2path[256] = ".";
-	if (getcwd(tempsrb2path, 256) == NULL)
-		strcpy(tempsrb2path, ".");
+	getcwd(tempsrb2path, 256);

 	// get the current directory (possible problem on NT with "." as current dir)
 	if (!srb2waddir)
 	{
-		srb2waddir = tempsrb2path;
+		if (tempsrb2path[0])
+			srb2waddir = tempsrb2path;
+		else
+		{
+			srb2waddir = ".";
+		}
 	}

 #if (1) // reduce the amount of findfile by only using full cwd in this func
@@ -1405,6 +1339,8 @@ static inline void D_MakeTitleString(char *s)
 // extra graphic patches for saturn specific thingies
 boolean xtra_speedo       = false; // extra speedometer check
 boolean xtra_speedo_clr   = false; // extra speedometer colour check
+boolean xtra_speedo3      = false; // 80x 11 extra speedometer check
+boolean xtra_speedo_clr3  = false; // 80x 11 extra speedometer colour check
 boolean achi_speedo       = false; // achiiro speedometer check
 boolean achi_speedo_clr   = false; // extra speedometer colour check
 boolean dial_speedo       = false; // dial speedometer check
@@ -1434,6 +1370,7 @@ static void D_CheckSaturnExtraFiles(void)
 	CV_PossibleValue_t minimapdot_cons_temp[NUMMINIMAPDOTSTUFF] = {{0, "Off"}, {0, NULL}, {0, NULL}, {0, NULL}, {0, NULL}};

 	unsigned last_speedo_i = 0;
+	unsigned last_driftgauge_i = 3;
 	unsigned last_inputdisplay_i = 2;
 	unsigned last_minimapdot_i = 0;
 #define PUSHCONS(cons, i, id, name) { ++i; cons[i].value = id; cons[i].strvalue = name; }
@@ -1592,6 +1529,20 @@ static void D_CheckSaturnExtraFiles(void)
 	if (found_extra3_kart)
 	{
 		mainwads++;
+
+		// 80x11 speedometer crap
+		if (W_LumpExists("SP_SM3TC"))
+		{
+			xtra_speedo3 = true;
+			PUSHCONS(speedo_cons_temp, last_speedo_i, 7, "Extra");
+			PUSHCONS(driftgaugestyle_cons_temp, last_driftgauge_i, 5, "Extra");
+		}
+
+		// 80x11 speedometer crap but colour
+		if (W_LumpExists("SC_SM3TC"))
+		{
+			xtra_speedo_clr3 = true;
+		}
 	}

 #undef PUSHCONS
@@ -1666,6 +1617,12 @@ void D_SRB2Main(void)
 	strcpy(srb2, "SRB2Kart");
 	D_MakeTitleString(srb2);

+#if defined (__OS2__) && !defined (HAVE_SDL)
+	// set PM window title
+	snprintf(pmData->title, sizeof (pmData->title), "SRB2Kart" VERSIONSTRING ": %s", title);
+	pmData->title[sizeof (pmData->title) - 1] = '\0';
+#endif
+
 	if (devparm)
 		CONS_Printf(M_GetText("Development mode ON.\n"));

@@ -1789,6 +1746,10 @@ void D_SRB2Main(void)
 	// Setup default unlockable conditions
 	M_SetupDefaultConditionSets();

+	// Setup character tables
+	// Have to be done here before files are loaded
+	M_InitCharacterTables();
+
 	// load wad, including the main wad file
 	CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n");

@@ -1908,8 +1869,7 @@ void D_SRB2Main(void)
 	if (M_CheckParm("-warp") && M_IsNextParm())
 	{
 		const char *word = M_GetNextParm();
-		pstartmap = G_FindMapByNameOrCode(word, NULL);
-
+		pstartmap = G_FindMapByNameOrCode(word, 0);
 		if (! pstartmap)
 			I_Error("Cannot find a map remotely named '%s'\n", word);
 		else
@@ -2042,13 +2002,9 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
+		char *replayname = strrchr(replayurl, '/');

-		if (!replayurl)
-			I_Error("REPLAY: Invalid URL.");
-
-		gconst char *replayname = strrchr(replayurl, '/');
-
-		if (!replayname)
+		if (!replayname || !replayurl)
 			I_Error("REPLAY: Invalid URL.");

 #define REPLAYDIR "/DownloadedReplays/"
@@ -2162,8 +2118,8 @@ void D_SRB2Main(void)

 	if (dedicated && server)
 	{
+		levelstarttic = gametic;
 		G_SetGamestate(GS_LEVEL);
-
 		if (!P_SetupLevel(false, false))
 			I_Quit(); // fail so reset game stuff
 	}
@@ -38,6 +38,8 @@ extern boolean found_extra3_kart; // for use in k_kart.c

 extern boolean xtra_speedo;       // extra speedometer check
 extern boolean xtra_speedo_clr;   // extra speedometer colour check
+extern boolean xtra_speedo3;      // 80x11 extra speedometer check
+extern boolean xtra_speedo_clr3;  // 80x11 extra speedometer colour check
 extern boolean achi_speedo;       // achiiro speedometer check
 extern boolean achi_speedo_clr;   // extra speedometer colour check
 extern boolean dial_speedo;       // dial speedometer check
@@ -59,7 +59,7 @@ static INT16 reboundsize[MAXREBOUND];
 static INT32 rebound_head, rebound_tail;

 /// \brief max length per packet
-INT16 hardware_MAXPACKETLENGTH = 0;
+INT16 hardware_MAXPACKETLENGTH;

 boolean (*I_NetGet)(void) = NULL;
 void (*I_NetSend)(void) = NULL;
@@ -96,7 +96,7 @@ INT32 ticruned = 0, ticmiss = 0;

 // globals
 INT32 getbps = 0, sendbps = 0;
-float lostpercent = 0.0f, duppercent = 0.0f, gamelostpercent = 0.0f;
+float lostpercent = 0, duppercent = 0, gamelostpercent = 0;
 INT32 packetheaderlength = 0;

 boolean Net_GetNetStat(void)
@@ -612,8 +612,12 @@ void Net_WaitAllAckReceived(UINT32 timeout)

 static void InitNode(node_t *node)
 {
-	memset(node, 0, sizeof(node_t));
+	node->acktosend_head = node->acktosend_tail = 0;
+	memset(node->acktosend, 0, sizeof(node->acktosend));
+	node->firstacktosend = 0;
 	node->nextacknum = 1;
+	node->remotefirstack = 0;
+	node->flags = 0;
 }

 static void InitAck(void)
@@ -27,6 +27,7 @@ extern "C" {
 // SINT8 is used for nodes sometimes >:(
 #define MAXNETNODES 127
 #define BROADCASTADDR MAXNETNODES
+#define NETSPLITSCREEN // Kart's splitscreen netgame feature

 #define STATLENGTH (TICRATE*2)

@@ -21,7 +21,10 @@ extern "C" {

 #include "command.h"

-void SendWeaponPref(UINT8 splitplayer);
+void SendWeaponPref(void);
+void SendWeaponPref2(void);
+void SendWeaponPref3(void);
+void SendWeaponPref4(void);

 // console vars
 extern consvar_t cv_playername;
@@ -93,6 +96,11 @@ extern consvar_t cv_pause;
 extern consvar_t cv_restrictskinchange, cv_allowteamchange, cv_ingamecap, cv_respawntime;
 extern consvar_t cv_spectatorreentry, cv_antigrief;

+/*extern consvar_t cv_teleporters, cv_superring, cv_supersneakers, cv_invincibility;
+extern consvar_t cv_jumpshield, cv_watershield, cv_ringshield, cv_forceshield, cv_bombshield;
+extern consvar_t cv_1up, cv_eggmanbox;
+extern consvar_t cv_recycler;*/
+
 // SRB2kart items
 extern consvar_t cv_sneaker, cv_rocketsneaker, cv_invincibility, cv_banana;
 extern consvar_t cv_eggmanmonitor, cv_orbinaut, cv_jawz, cv_mine;
@@ -150,7 +158,6 @@ extern consvar_t cv_pingstyle;

 //extern consvar_t cv_smallpos;
 extern consvar_t cv_showminimapnames;
-extern consvar_t cv_showminimapfinished;
 extern consvar_t cv_minihead;
 extern consvar_t cv_showminimapangle;

@@ -288,7 +295,7 @@ typedef union {
 // add game commands, needs cleanup
 void D_RegisterServerCommands(void);
 void D_RegisterClientCommands(void);
-void D_SendPlayerConfig(UINT8 splitplayer);
+void D_SendPlayerConfig(void);
 void Command_ExitGame_f(void);
 void Command_Retry_f(void);
 void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore
@@ -116,8 +116,6 @@ static I_mutex downloadmutex;
 #endif
 char downloaddir[512] = "DOWNLOAD";

-INT32 addontypes[NUMADDONTYPES] = {0};
-
 file_download_t filedownload = {};

 #ifdef HAVE_CURL
@@ -133,12 +131,8 @@ static UINT32 curl_origtotalfilesize;
 static char *curl_realname = NULL;
 fileneeded_t *curl_curfile = NULL;
 HTTP_login *curl_logins = NULL;
-
-static void CURLGetFile(void);
 #endif

-static addontype_t GetAddonType(const char *name);
-
 /** Fills a serverinfo packet with information about wad files loaded.
  *
  * \todo Give this function a better name since it is in global scope.
@@ -229,11 +223,8 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
 		fileneeded[i].willsend = (UINT8)(filestatus >> 4);
 		fileneeded[i].totalsize = READUINT32(p); // The four next bytes are the file size
 		fileneeded[i].file = NULL; // The file isn't open yet
-		READSTRINGL(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name
+		READSTRINGN(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name
 		READMEM(p, fileneeded[i].md5sum, 16); // The last 16 bytes are the file checksum
-
-		// Should be good place to calculate that?
-		fileneeded[i].type = GetAddonType(fileneeded[i].filename);
 	}
 }

@@ -582,48 +573,6 @@ INT32 CL_CheckFiles(void)
 		return 1; //everything is FS_OPEN or FS_FOUND, proceed to loading
 }

-static addontype_t GetAddonType(const char *name)
-{
-	const char *prefix = strchr(name, '_');
-
-	// Doesn't have prefix (no '_' character or it is too far and is probably not for prefix but for something like version)
-	// KRBCL_ is longest prefix i can think of so this should be enough
-	if (prefix == NULL || prefix - name > 5)
-		return ADDON_MISC;
-
-	// Skip 'K'
-	if (*name == 'K')
-		++name;
-
-	switch (*name)
-	{
-		case 'L':
-			return ADDON_SCRIPT;
-		break;
-
-		case 'R':
-		case 'B':
-			return ADDON_MAP;
-		break;
-
-		case 'C':
-			return ADDON_CHARACTER;
-		break;
-	}
-
-	return ADDON_MISC;
-}
-
-void CL_CheckAddonTypes(void)
-{
-	memset(&addontypes, 0, sizeof(addontypes));
-
-	for (INT32 i = 0; i < fileneedednum; i++)
-	{
-		addontypes[fileneeded[i].type]++;
-	}
-}
-
 // Load it now
 boolean CL_LoadServerFiles(void)
 {
@@ -1009,7 +958,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download base-game file: \"%s\"", filename);
+		I_Error("Tried to download \"%s\"", filename);

 	if (filenum >= fileneedednum)
 	{
@@ -1068,21 +1017,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);
@@ -1130,14 +1079,12 @@ 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);
@@ -1151,16 +1098,17 @@ 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);
-			memmove(s, ns, len+1);
-
+#if 0
+				memcpy(s, ns, len+1);
+#else
+				memmove(s, ns, len+1);
+#endif
 			return;
 		}
-	}
 }

 // Returns the length in characters of the last element of a path.
@@ -1214,12 +1162,8 @@ 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)

-	// 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
+	// skip for startup, our mainwads wont be in there
+	if (loaded_config)
 	{
 		if (cv_addons_option.value == 3 && *cv_addons_folder.string != '\0')
 		{
@@ -1356,7 +1300,6 @@ 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);
@@ -1365,7 +1308,6 @@ void CURLPrepareFile(const char* url, int dfilenum)
 		{
 			multi_handle = curl_multi_init();
 		}
-
 		if (!multi_handle)
 		{
 			I_OutputMsg("libcurl: curl_multi_init() failed\n");
@@ -1494,7 +1436,7 @@ void CURLAbortFile(void)
 #endif
 }

-static void CURLGetFile(void)
+void CURLGetFile(void)
 {
 #ifdef HAVE_THREADS
 	I_lock_mutex(&downloadmutex);
@@ -1536,8 +1478,7 @@ static void CURLGetFile(void)
 				e = m->easy_handle;
 				easyres = m->data.result;

-				char *filename = malloc(strlen(curl_realname)+1);
-				strcpy(filename, curl_realname);
+				char *filename = Z_StrDup(curl_realname);
 				nameonly(filename);

 				if (easyres != CURLE_OK)
@@ -1575,7 +1516,7 @@ static void CURLGetFile(void)
 					}
 				}

-				free(filename);
+				Z_Free(filename);
 				curl_curfile->file = NULL;
 				filedownload.remaining--;
 				mc = curl_multi_remove_handle(multi_handle, e);
@@ -40,15 +40,6 @@ typedef enum
 	FS_FALLBACK, // HTTP failed
 } filestatus_t;

-typedef enum addontype_e
-{
-	ADDON_SCRIPT,
-	ADDON_MAP,
-	ADDON_CHARACTER,
-	ADDON_MISC,
-	NUMADDONTYPES,
-} addontype_t;
-
 typedef struct
 {
 	UINT8 willsend; // Is the server willing to send it?
@@ -60,13 +51,11 @@ typedef struct
 	UINT32 totalsize;
 	filestatus_t status; // The value returned by recsearch
 	boolean justdownloaded; // To prevent late fragments from causing an I_Error
-	addontype_t type;
 } fileneeded_t;

 extern INT32 fileneedednum;
 extern fileneeded_t fileneeded[MAX_WADFILES];
 extern char downloaddir[512];
-extern INT32 addontypes[NUMADDONTYPES];

 typedef struct
 {
@@ -102,7 +91,6 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
 void CL_PrepareDownloadSaveGame(const char *tmpsave);

 INT32 CL_CheckFiles(void);
-void CL_CheckAddonTypes(void);
 boolean CL_LoadServerFiles(void);
 void SV_SendRam(INT32 node, void *data, size_t size, freemethod_t freemethod,
 	UINT8 fileid);
@@ -131,6 +119,7 @@ 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
@@ -1,75 +1,21 @@
 # Declare dedicated interface sources

-set(SRB2_DEDICATED_SOURCES
-	i_system.c
-	i_main.c
-	i_video.c
-	i_sound.c
-	i_threads.c
-	dosstr.c
-	endtxt.c
-)
+target_sourcefile(c)

-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})
+target_sources(SRB2SDL2 PRIVATE)

 if(${CMAKE_SYSTEM} MATCHES Windows)
-	set(SRB2_DEDICATED_TOTAL_SOURCES ${SRB2_DEDICATED_TOTAL_SOURCES}
-		${CMAKE_SOURCE_DIR}/src/win32/win_dbg.c
-		${CMAKE_SOURCE_DIR}/src/win32/Srb2win.rc
-	)
+	target_sources(SRB2SDL2 PRIVATE
+		../win32/win_dbg.c
+		../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 srb2kartd)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
 elseif(${CMAKE_SYSTEM} MATCHES Linux)
-	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2kartd)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2dlegacy)
 else()
-	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"
-	)
+	set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
 endif()

 if(${CMAKE_SYSTEM} MATCHES Darwin)
@@ -78,27 +24,25 @@ 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()

-if(${SRB2_HAVE_LIBBACKTRACE})
-	target_link_libraries(SRB2SDL2 PRIVATE ${LIBBACKTRACE_LIBRARIES})
-endif()
+#target_link_libraries(SRB2SDL2 PRIVATE SRB2Core)
+
+set_target_properties(SRB2SDL2 PROPERTIES VERSION ${SRB2_VERSION})

 if(${CMAKE_SYSTEM} MATCHES Windows)
 	target_link_libraries(SRB2SDL2 PRIVATE
@@ -116,34 +60,19 @@ target_include_directories(SRB2SDL2 PRIVATE

 target_compile_definitions(SRB2SDL2 PRIVATE
 	-DDEDICATED
-	-DHAVE_THREADS
 )

-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()
+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)
@@ -167,8 +167,6 @@ 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"
@@ -180,6 +178,10 @@ 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)
@@ -194,6 +196,8 @@ UINT8 keyboard_started = false;

 #ifdef HAVE_TERMIOS
 // TERMIOS console code from Quake3: thank you!
+boolean stdin_active = true;
+
 typedef struct
 {
 	size_t cursor;
@@ -695,7 +699,11 @@ void I_JoyScale4(void)


 */
-void I_ShutdownJoystick(UINT8 index)
+void I_ShutdownJoystick(void)
+{
+}
+
+void I_GetJoystickEvents(UINT8 index)
 {
 	(void)index;
 }
@@ -735,22 +743,6 @@ const char *I_GetJoyName(INT32 joyindex)
 	return NULL;
 }

-void I_SetJoystickFocus(void)
-{
-}
-
-boolean I_GamepadHasLED(INT32 playernum)
-{
-	(void)playernum;
-	return false;
-}
-
-boolean I_GamepadHasRumble(INT32 playernum)
-{
-	(void)playernum;
-	return false;
-}
-
 void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
 {
 	(void)playernum;
@@ -1000,7 +992,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }

-static volatile sig_atomic_t g_in_exiting_signal_handler = false;
+boolean g_in_exiting_signal_handler = false;

 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1023,13 +1015,8 @@ static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_ms
 			sigmsg = ("SIGSEGV - SRB2Kart-Saturn has attempted to access a memory location that it shouldn't and needs to close.");
 			break;
 #ifdef SIGTERM
-		case SIGTERM: // Software termination signal from terminate
-			sigmsg = ("SIGTERM - SRB2Kart-Saturn was terminated by a terminate signal.");
-			break;
-#endif
-#ifdef SIGKILL
-		case SIGKILL: // Software termination signal from kill
-			sigmsg = ("SIGKILL - SRB2Kart-Saturn was terminated by a kill signal.");
+		case SIGTERM: // Software termination signal from kill
+			sigmsg = ("SIGTERM - SRB2Kart-Saturn was terminated by a kill signal.");
 			break;
 #endif
 #ifdef SIGBREAK
@@ -1069,11 +1056,6 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }

-boolean I_In_Exiting_Signal_Handler(void)
-{
-	return g_in_exiting_signal_handler;
-}
-
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1093,17 +1075,11 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif

-static volatile sig_atomic_t interrupted = 0;
-
-boolean I_Interrupted(void)
+FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
 {
-	return interrupted;
-}
-
-static void quit_handler(int num)
-{
-	(void)num;
-	interrupted = 1;
+	signal(num, SIG_DFL); //default signal action
+	raise(num);
+	I_Quit();
 }

 #ifdef HAVE_LIBBACKTRACE
@@ -1362,28 +1338,18 @@ static void I_Fork(void)
 			I_RegisterChildSignals();
 			break;
 		default:
-			// ignore those, those are handled by child process
-			// otherwise parent might exit before it
-			// and the below stuff wont run and your terminal will be left in an awkward state
-#ifdef SIGINT
-			signal(SIGINT,   SIG_IGN);
-#endif
-#ifdef SIGBREAK
-			signal(SIGBREAK, SIG_IGN);
-#endif
-#ifdef SIGTERM
-			signal(SIGTERM,  SIG_IGN);
-#endif
 			if (logstream)
 				fclose(logstream);/* the child has this */

 			c = wait(&status);
+
 #ifdef LOGMESSAGES
 			/* By the way, exit closes files. */
 			logstream = fopen(logfilename, "at");
 #else
 			logstream = 0;
 #endif
+
 			if (c == -1)
 			{
 				kill(child, SIGKILL);
@@ -1443,8 +1409,8 @@ void I_Quit(void)
 	/* prevent recursive I_Quit() */
 	if (quiting)
 		goto death;
-
 	quiting = false;
+	I_ShutdownConsole();
 	M_SaveConfig(NULL); //save game config, cvars..
 	D_SaveBan(); // save the ban list
 	G_SaveGameData(false); // Tails 12-08-2002
@@ -1460,18 +1426,16 @@ void I_Quit(void)
 	// use this for 1.28 19990220 by Kin
 	I_ShutdownGraphics();
 	I_ShutdownSystem();
-
 	/* if option -noendtxt is set, don't print the text */
 	if (!M_CheckParm("-noendtxt") && W_CheckNumForName("ENDOOM") != LUMPERROR)
 	{
 		printf("\r");
 		ShowEndTxt();
 	}
-
 	if (myargmalloc)
 		free(myargv); // Deallocate allocated memory
-
 death:
+	W_Shutdown();
 	exit(0);
 }

@@ -1517,6 +1481,7 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)

 			I_OutputMsg("SRB2Kart %s Recursive Error", buffer);

+			W_Shutdown();
 			exit(-1); // recursive errors detected
 		}
 	}
@@ -1534,6 +1499,8 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
 #endif
 	// ---

+	I_ShutdownConsole();
+
 	M_SaveConfig(NULL); // save game config, cvars..
 	D_SaveBan(); // save the ban list
 	G_SaveGameData(false); // Tails 12-08-2002
@@ -1549,6 +1516,8 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
 	I_ShutdownGraphics();
 	I_ShutdownSystem();

+	W_Shutdown();
+
 #if defined (PARANOIA) && defined (__CYGWIN__)
 	*(INT32 *)2 = 4; //Alam: Debug!
 #endif
@@ -1654,10 +1623,9 @@ void I_ShutdownSystem(void)
 {
 	INT32 c;

-#ifdef NEWSIGNALHANDLER
-	if (M_CheckParm("-nofork"))
+#ifndef NEWSIGNALHANDLER
+	I_ShutdownConsole();
 #endif
-		I_ShutdownConsole();

 	for (c = MAX_QUIT_FUNCS-1; c >= 0; c--)
 		if (quit_funcs[c])
@@ -13,10 +13,6 @@
 #ifndef __DEHACKED_H__
 #define __DEHACKED_H__

-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "m_fixed.h" // for get_number
 #include "info.h"

@@ -75,9 +71,4 @@ typedef struct
 } MYFILE;
 #define myfeof(a) (a->data + a->size <= a->curpos)
 char *myfgets(char *buf, size_t bufsize, MYFILE *f);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif
@@ -61,7 +61,7 @@ enum
 typedef struct
 {
 	INT16 x, y;
-} ATTRPACK  mapvertex_t;
+}ATTRPACK  mapvertex_t;

 // A SideDef, defining the visual appearance of a wall,
 // by setting textures and offsets.
@@ -40,45 +40,22 @@
 #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>

-#include <limits.h>
+#define _USE_MATH_DEFINES // fixes M_PI errors in r_plane.c for Visual Studio
+#ifdef __cplusplus
+#include <cmath>
+#else
+#include <math.h>
 #endif

 #include <sys/types.h>
@@ -130,10 +107,10 @@ extern char  logfilename[1024];
 #else
 #define VERSION    1 // Game version
 #define SUBVERSION 6 // more precise version number
-#define VERSIONSTRING "Saturn v9.3"
-#define VERSIONSTRINGW L"Saturn v9.3"
+#define VERSIONSTRING "Saturn v9.2"
+#define VERSIONSTRINGW L"Saturn v9.2"

-#define SATURN_TESTING // comment out for saturn release builds!
+//#define SATURN_TESTING // comment out for saturn release builds!

 // Hey! If you change this, add 1 to the MODVERSION below! Otherwise we can't force updates!
 // And change CMakeLists.txt (not src/, but in root), for CMake users!
@@ -516,6 +493,22 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);

+/* http://www.cse.yorku.ca/~oz/hash.html */
+static inline
+UINT32 quickncasehash (const char *p, size_t n)
+{
+	size_t i = 0;
+	UINT32 x = 5381;
+
+	while (i < n && p[i])
+	{
+		x = (x * 33) ^ tolower(p[i]);
+		i++;
+	}
+
+	return x;
+}
+
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))
@@ -573,13 +566,6 @@ INT32 I_GetKey(void);
 // 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__))
@@ -54,6 +54,7 @@ extern INT16 maptol;
 extern UINT8 globalweather;
 extern INT32 curWeather;
 extern INT32 cursaveslot;
+extern INT16 lastmapsaved;
 extern boolean gamecomplete;

 #define PRECIP_NONE  0
@@ -77,6 +78,7 @@ extern boolean imcontinuing; // Temporary flag while continuing
 extern UINT8 modeattacking;

 // menu demo things
+extern UINT8  numDemos;
 extern UINT32 demoDelayTime;
 extern UINT32 demoIdleTime;

@@ -112,8 +114,8 @@ extern UINT8 paused; // Game paused?
 extern UINT8 window_notinfocus; // are we in focus? (backend independant -- handles auto pausing and display of "focus lost" message)

 extern boolean nodrawers;
+extern boolean noblit;
 extern boolean lastdraw;
-extern boolean intermissionbginit;

 #ifdef MOTIONBLUR
 extern INT32 postimgparam[MAXSPLITSCREENPLAYERS];
@@ -203,6 +205,12 @@ extern struct quake
 	fixed_t radius, intensity;
 } quake;

+// NiGHTS grades
+typedef struct
+{
+	UINT32 grade[6]; // D, C, B, A, S, X (F: failed to reach any of these)
+} nightsgrades_t;
+
 // Custom Lua values
 // (This is not ifdeffed so the map header structure can stay identical, just in case.)
 typedef struct
@@ -253,16 +261,28 @@ typedef struct
 	UINT8 numlaps;        ///< Number of laps in circuit mode, unless overridden.
 	SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no.
 	UINT8 levelselect;    ///< Is this map available in the level select? If so, which map list is it available in?
+	SINT8 bonustype;      ///< What type of bonus does this level have? (-1 for null.)
+	SINT8 saveoverride;   ///< Set how the game is allowed to save (1 for always, -1 for never, 0 is 2.1 default)
+
 	UINT8 levelflags;     ///< LF_flags:  merged eight booleans into one UINT8 for space, see below
 	UINT8 menuflags;      ///< LF2_flags: options that affect record attack / nights mode menus

+	// NiGHTS stuff.
+	UINT8 numGradedMares;   ///< Internal. For grade support.
+	nightsgrades_t *grades; ///< NiGHTS grades. Allocated dynamically for space reasons. Be careful.
+
 	// SRB2kart
+	//boolean automap;    ///< Displays a level's white map outline in modified games
 	fixed_t mobj_scale;   ///< Replacement for TOL_ERZ3

 	mapheader_lighting_t lighting;			///< Wall and sprite lighting
 	mapheader_lighting_t lighting_encore;	///< Alternative lighting for Encore mode
 	boolean use_encore_lighting;			///< Whether to use separate Encore lighting

+	// Music stuff.
+	UINT32 musinterfadeout;  ///< Fade out level music on intermission screen in milliseconds
+	char musintername[7];    ///< Intermission screen music.
+
 	// Lua stuff.
 	// (This is not ifdeffed so the map header structure can stay identical, just in case.)
 	UINT8 numCustomOptions;     ///< Internal. For Lua custom value support.
@@ -359,6 +379,8 @@ typedef struct
 {
 	tic_t time; ///< Time in which the level was finished.
 	tic_t lap;  ///< Best lap time for this level.
+	//UINT32 score; ///< Score when the level was finished.
+	//UINT16 rings; ///< Rings when the level was finished.
 } recorddata_t;

 /** Setup for one NiGHTS map.
@@ -372,19 +394,34 @@ typedef struct
 #define GRADE_A 5
 #define GRADE_S 6

+/*typedef struct
+{
+	// 8 mares, 1 overall (0)
+	UINT8	nummares;
+	UINT32	score[9];
+	UINT8	grade[9];
+	tic_t	time[9];
+} nightsdata_t;*/
+
+//extern nightsdata_t *nightsrecords[NUMMAPS];
 extern recorddata_t *mainrecords[NUMMAPS];

 // mapvisited is now a set of flags that says what we've done in the map.
 #define MV_VISITED     1
 #define MV_BEATEN      2
 #define MV_ALLEMERALDS 4
+//#define MV_ULTIMATE     8
+//#define MV_PERFECT     16
 #define MV_MAX         7 // used in gamedata check
 extern UINT8 mapvisited[NUMMAPS];

-extern UINT32 token;     ///< Number of tokens collected in a level
+// Temporary holding place for nights data for the current map
+//nightsdata_t ntemprecords;
+
+extern UINT32 token; ///< Number of tokens collected in a level
 extern UINT32 tokenlist; ///< List of tokens collected
-extern INT32  tokenbits; ///< Used for setting token bits
-extern INT32  sstimer;   ///< Time allotted in the special stage
+extern INT32 tokenbits; ///< Used for setting token bits
+extern INT32 sstimer; ///< Time allotted in the special stage
 extern UINT32 bluescore; ///< Blue Team Scores
 extern UINT32 redscore;  ///< Red Team Scores

@@ -400,6 +437,9 @@ extern boolean CheckForReverseGravity;
 extern UINT16 invulntics;
 extern UINT16 sneakertics;
 extern UINT16 flashingtics;
+extern UINT16 tailsflytics;
+extern UINT16 underwatertics;
+extern UINT16 spacetimetics;
 extern UINT16 extralifetics;

 // SRB2kart
@@ -421,6 +461,7 @@ extern UINT8 introtoplay;
 extern UINT8 creditscutscene;

 extern UINT8 use1upSound;
+extern UINT8 maxXtraLife; // Max extra lives from rings

 extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations

@@ -485,6 +526,7 @@ extern UINT32 timesBeatenWithEmeralds;
 //  WAD, partly set at startup time.

 extern tic_t gametic;
+#define localgametic leveltime

 // Player spawn spots.
 extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative
@@ -68,21 +68,8 @@ extern "C" {
 	#define strnicmp(x,y,n) strncasecmp(x,y,n)
 #endif

-// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
-// to not cause warnings or compile issues on older glibc versions we do this silly thing
-// to not have a gazillion glibc version checks
-#if defined(__GLIBC_PREREQ)
-#if __GLIBC_PREREQ(2, 43)
-	#define gconst const
-#else
-	#define gconst
-#endif
-#else
-	#define gconst
-#endif
-
-#ifndef _GNU_SOURCE
 char *nongnu_strcasestr(const char *in, const char *what);
+#ifndef _GNU_SOURCE
 #define strcasestr nongnu_strcasestr
 #endif

@@ -140,9 +127,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)

 /* Boolean type definition */
-#include <stdbool.h>

 #ifndef _WIN32
+#include <stdbool.h>
 // dont use stdbools _BOOL type
 // its smaller (1 byte) than the old interger bool (4 bytes)
 // which results in packed struct sizes being mismatched between vanilla and this
@@ -150,7 +137,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
 // which we cant use as enumeration constants
 typedef int32_t boolean;
 #else
-#define boolean int32_t
+#define false FALSE
+#define true TRUE
+#define boolean BOOL
 #endif

 /* 7.18.2.1  Limits of exact-width integer types */
@@ -1110,6 +1110,14 @@ void F_TitleScreenTicker(boolean run)
 			return;
 		}

+		// Replay intro when done cycling through demos
+		/*if (curDemo == numDemos) -- uuuh... we have a LOT of maps AND a big devteam... probably not gonna see a repeat unless you're super unlucky :V
+		{
+			curDemo = 0;
+			F_StartIntro();
+			return;
+		}*/
+
 		mapname = G_BuildMapName(G_RandMap(TOL_RACE, -2, false, 0, false, NULL)+1);

 		numstaff = 1;
@@ -1164,7 +1172,9 @@ void F_StartWaitingPlayers(void)
 	randskin = M_RandomKey(numskins);
 	boolean waithires = skins[randskin].flags && SF_HIRES;

-	Z_Free(waitcolormap);
+	if (waitcolormap)
+		Z_Free(waitcolormap);
+
 	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0);

 	if (waithires)
@@ -1308,7 +1318,7 @@ boolean F_ContinueResponder(event_t *event)
 	keypressed = true;
 	imcontinuing = true;
 	continuetime = TICRATE;
-	S_StartSound(NULL, sfx_itemup);
+	S_StartSound(0, sfx_itemup);
 	return true;
 }

@@ -361,11 +361,6 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
 	// on for fade-to-black
 	for (;;)
 	{
-		if (I_Interrupted())
-		{
-			I_Quit();
-		}
-
 		// get fademask first so we can tell if it exists or not
 		fmask = F_GetFadeMask(wipetype, wipeframe++);

@@ -10,7 +10,7 @@ FUNCINLINE static ATTRINLINE boolean fasticmp(const char *s, const char *c)
 }

 // case-sensitive of the above
-FUNCINLINE static ATTRINLINE PUREFUNC boolean fastcmp(const char *s, const char *c)
+FUNCINLINE static ATTRINLINE 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 PUREFUNC boolean fastcmp(const char *s, const char

 // length-limited of the above
 // only true if both strings are at least l characters long AND match, case-sensitively!
-FUNCINLINE static ATTRINLINE PUREFUNC boolean fastncmp(const char *s, const char *c, UINT16 l)
+FUNCINLINE static ATTRINLINE 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
@@ -49,7 +49,7 @@ size_t menupathindex[menudepth] = {};
 size_t menudepthleft = menudepth;

 char menusearchbuf[MAXSTRINGLENGTH+1];
-textinput_t menusearch = {};
+textinput_t menusearch;

 char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
 size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
@@ -111,12 +111,10 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
 	char *searchname;
 	int depthleft = maxsearchdepth;
 	char searchpath[MAXFILEPATH];
-	size_t *searchpathindex = NULL;
+	size_t *searchpathindex;

 	dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*));
 	searchpathindex = (size_t *)malloc(maxsearchdepth * sizeof(size_t));
-	if (!searchpathindex)
-		I_Error("out of memory while searching for file %s\n", filename);

 	strcpy(searchpath, startpath);
 	searchpathindex[--depthleft] = strlen(searchpath) + 1;
@@ -273,13 +271,10 @@ 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) != NULL);
-
+		return (strstr(localhaystack, needle) != 0);
 	return (!strncmp(localhaystack, needle, menusearch.length));
 }

@@ -319,7 +314,8 @@ void closefilemenu(boolean validsize)
 		coredirmenu = NULL;
 	}

-	Z_Free(refreshdirname);
+	if (refreshdirname)
+		Z_Free(refreshdirname);
 	refreshdirname = NULL;
 }

@@ -347,7 +343,8 @@ void searchfilemenu(char *tempname)

 	if (!menusearch.length)
 	{
-		Z_Free(dirmenu);
+		if (dirmenu)
+			Z_Free(dirmenu);
 		dirmenu = coredirmenu;
 		sizedirmenu = sizecoredirmenu;

@@ -389,8 +386,8 @@ void searchfilemenu(char *tempname)
 				I_Error("searchfilemenu(): could not create \"No results...\".");
 		sizedirmenu = 1;
 		dir_on[menudepthleft] = 0;
-		Z_Free(tempname);
-
+		if (tempname)
+			Z_Free(tempname);
 		return;
 	}

@@ -505,8 +502,8 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
 	{
 		closedir(dirhandle);
 		closefilemenu(false);
-		Z_Free(tempname);
-
+		if (tempname)
+			Z_Free(tempname);
 		return false;
 	}

@@ -55,8 +55,6 @@
 #include "k_stats.h" // SRB2kart
 #include "r_fps.h" // frame interpolation/uncapped

-#include <errno.h>
-
 #ifdef HAVE_DISCORDRPC
 #include "discord.h"
 #endif
@@ -66,15 +64,17 @@
 #include <locale.h>

 // menu demo things
+UINT8  numDemos      = 0; //3; -- i'm FED UP of losing my skincolour to a broken demo. change this back when we make new ones
 UINT32 demoDelayTime = 15*TICRATE;
 UINT32 demoIdleTime  = 3*TICRATE;

 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 = {};
+savebuffer_t demobuf = {0};
 static UINT8 *demotime_p, *demoinfo_p;
 static UINT8 *demoend;
 static UINT8 demoflags;
@@ -1651,12 +1651,10 @@ void G_RecordDemo(const char *name)
 		maxsize = cv_maxdemosize.value*1024*1024;

 		demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL);
+		demoend = demobuf.buffer + maxsize;

 		if (demobuf.buffer)
-		{
-			demoend = demobuf.buffer + maxsize;
 			demo.recording = true;
-		}
 		else
 			CONS_Alert(CONS_ERROR, "Failed to allocate demo buffer\n");
 	}
@@ -1994,6 +1992,7 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)
 	UINT8 totalfiles, filesloaded, nmusfilecount;
 	char filename[MAX_WADPATH];
 	UINT8 md5sum[16];
+	boolean toomany = false;
 	boolean alreadyloaded;
 	UINT8 i, j;
 	UINT8 error = 0;
@@ -2003,44 +2002,53 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)

 	for (i = 0; i < totalfiles; ++i)
 	{
-		strlcpy(filename, (char *)(*pp), sizeof filename);
-		SKIPSTRING((*pp));
+		if (toomany)
+			SKIPSTRING((*pp));
+		else
+		{
+			strlcpy(filename, (char *)(*pp), sizeof filename);
+			SKIPSTRING((*pp));
+		}

 		READMEM((*pp), md5sum, 16); // hue hue peepee

-		alreadyloaded = false;
-		nmusfilecount = 0;
-
-		for (j = 0; j < numwadfiles; ++j)
+		if (!toomany)
 		{
-			if (wadfiles[j]->important && j > mainwads)
-				nmusfilecount++;
-			else
-				continue;
+			alreadyloaded = false;
+			nmusfilecount = 0;

-			if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0)
+			for (j = 0; j < numwadfiles; ++j)
 			{
-				alreadyloaded = true;
+				if (wadfiles[j]->important && j > mainwads)
+					nmusfilecount++;
+				else
+					continue;

-				if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER)
-					error |= DFILE_ERROR_OUTOFORDER;
+				if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0)
+				{
+					alreadyloaded = true;

-				break;
+					if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER)
+						error |= DFILE_ERROR_OUTOFORDER;
+
+					break;
+				}
 			}
-		}

-		if (alreadyloaded)
-		{
-			filesloaded++;
-			continue;
-		}
+			if (alreadyloaded)
+			{
+				filesloaded++;
+				continue;
+			}

-		if (numwadfiles >= MAX_WADFILES)
+			if (numwadfiles >= MAX_WADFILES)
+				error = DFILE_ERROR_CANNOTLOAD;
+			else if (!quick && findfile(filename, md5sum, false) != FS_FOUND)
+				error = DFILE_ERROR_CANNOTLOAD;
+			else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER)
+				error |= DFILE_ERROR_NOTLOADED;
+		} else
 			error = DFILE_ERROR_CANNOTLOAD;
-		else if (!quick && findfile(filename, md5sum, false) != FS_FOUND)
-			error = DFILE_ERROR_CANNOTLOAD;
-		else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER)
-			error |= DFILE_ERROR_NOTLOADED;
 	}

 	// Get final file count
@@ -2393,69 +2401,49 @@ static long G_GetCreationTime(char *filepath)

 static char *G_GetDemoDate(menudemo_t *pdemo)
 {
-	char *endPos = NULL;
-	static char datetime[11];
+	char *datetime;
+	datetime = malloc(sizeof(pdemo->date)); // mallocma balls
+
+	// no mallocma balls... :c
+	if (!datetime)
+	{
+		return NULL;
+	}
+
 	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 defined (_WIN32)
-		// if we cant get a filename try just getting the file creation time
+		// if we cant get a filename try just getting the file create time
 		file_time = G_GetCreationTime(pdemo->filepath);
 		goto skipfilenametime;
-#else
-		return NULL;
-#endif
 	}
+#else
+	if (!filename)
+	{
+		free(datetime);
+		return NULL;
+	}
+#endif

 	// get the actual filename Zzz...
 	nameonly(filename);

-	// 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
-	}
+	// convert it to long Zzz....
+	file_time = strtol(filename, NULL, 10);
+	free(filename); // dont need this anymore a

 #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
@@ -2468,10 +2456,14 @@ 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
 	}
@@ -2480,27 +2472,17 @@ 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
-	{
-		const char *locale = setlocale(LC_TIME, NULL);
+		format = strstr(setlocale(LC_TIME, NULL), "en_US") ? "%m.%d.%Y" : "%d.%m.%Y";

-		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;
-	}
+	strftime(datetime, sizeof(pdemo->date), format, tm_buf);

 	return datetime;
 }
@@ -2509,7 +2491,6 @@ 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");
@@ -2548,13 +2529,13 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 			memcpy(pdemo->title, info_p, 64);

 			// demo date
+			char *demodate;
 			demodate = G_GetDemoDate(pdemo);

 			if (demodate)
-			{
-				strlcpy(pdemo->date, demodate, sizeof(pdemo->date));
-			}
+				strncpy(pdemo->date, demodate, sizeof(pdemo->date));

+			free(demodate);
 			break;
 #ifdef DEMO_COMPAT_100
 		case 0x0001:
@@ -2595,7 +2576,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();

@@ -2606,7 +2587,7 @@ void G_DoPlayDemo(char *defdemoname)
 	if (defdemoname == NULL)
 	{
 		demobuf.p = demobuf.buffer;
-		pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed
+		pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed
 	}
 	else
 	{
@@ -2618,7 +2599,7 @@ void G_DoPlayDemo(char *defdemoname)
 			n++;

 		pdemoname = ZZ_Alloc(strlen(n)+1);
-		strcpy(pdemoname, n);
+		strcpy(pdemoname,n);

 		M_SetPlaybackMenuPointer();

@@ -2814,7 +2795,7 @@ void G_DoPlayDemo(char *defdemoname)
 	demobuf.p += 4; // Extrainfo location

 	// ...*map* not loaded?
-	if (!gamemap || (gamemap > NUMMAPS) || (W_CheckNumForName(G_BuildMapName(gamemap)) == LUMPERROR))
+	if (!gamemap || (gamemap > NUMMAPS) || !mapheaderinfo[gamemap-1] || !(mapheaderinfo[gamemap-1]->menuflags & LF2_EXISTSHACK))
 	{
 		snprintf(msg, 1024, M_GetText("%s features a course that is not currently loaded.\n"), pdemoname);
 		CONS_Alert(CONS_ERROR, "%s", msg);
@@ -2855,16 +2836,6 @@ void G_DoPlayDemo(char *defdemoname)
 			return;
 		}

-		// ...*map* not loaded?
-		if (!gamemap || (gamemap > NUMMAPS) || !mapheaderinfo[gamemap-1] || !(mapheaderinfo[gamemap-1]->menuflags & LF2_EXISTSHACK))
-		{
-			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;
-		}
-
 		// Set color
 		for (i = 0; i < MAXSKINCOLORS; i++)
 		{
@@ -3080,9 +3051,6 @@ post_compat:
 	if (cv_director.value)
 		CV_SetValue(&cv_director, 0);

-	if (demo.timing)
-		G_DoneLevelLoad();
-
 	demo.deferstart = true;
 }
 #undef SKIPERRORS
@@ -3510,11 +3478,10 @@ static INT32 restorecv_vidwait;
 void G_TimeDemo(const char *name)
 {
 	nodrawers = M_CheckParm("-nodraw");
-
+	noblit = M_CheckParm("-noblit");
 	restorecv_vidwait = cv_vidwait.value;
 	if (cv_vidwait.value)
 		CV_Set(&cv_vidwait, "0");
-
 	demo.timing = true;
 	singletics = true;
 	framecount = 0;
@@ -61,6 +61,7 @@

 gameaction_t gameaction = 0;
 gamestate_t gamestate = GS_NULL;
+UINT8 ultimatemode = false;

 boolean botingame = false;
 UINT8 botskin = 0;
@@ -68,6 +69,9 @@ UINT8 botcolor = 0;

 JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};

+// 1024 bytes is plenty for a savegame
+#define SAVEGAMESIZE (1024)
+
 // SRB2kart
 char gamedatafilename[64] = "kartdata.dat";
 char timeattackfolder[64] = "kart";
@@ -86,6 +90,7 @@ INT16 maptol = 0;
 UINT8 globalweather = 0;
 INT32 curWeather = PRECIP_NONE;
 INT32 cursaveslot = -1; // Auto-save 1p savegame slot
+INT16 lastmapsaved = 0; // Last map we auto-saved at
 boolean gamecomplete = false;

 UINT16 mainwads = 0;
@@ -95,6 +100,7 @@ boolean savemoddata = false;
 UINT8 paused = 0;
 UINT8 modeattacking = ATTACKING_NONE;
 boolean imcontinuing = false;
+boolean runemeraldmanager = false;

 boolean netgame = false; // only true if packets are broadcast
 boolean multiplayer = false;
@@ -106,6 +112,7 @@ INT32 consoleplayer = 0; // player taking events and displaying
 INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed

 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)
@@ -125,7 +132,7 @@ UINT8 skincolor_bluering = SKINCOLOR_STEEL;
 tic_t countdowntimer = 0;
 boolean countdowntimeup = false;

-cutscene_t *cutscenes[128] = {};
+cutscene_t *cutscenes[128];

 INT16 nextmapoverride = 0;
 boolean skipstats = false;
@@ -137,7 +144,7 @@ mobj_t *blueflag = NULL;
 mapthing_t *rflagpoint = NULL;
 mapthing_t *bflagpoint = NULL;

-struct quake quake = {};
+struct quake quake;

 // Map Header Information
 mapheader_t* mapheaderinfo[NUMMAPS] = {};
@@ -183,6 +190,9 @@ boolean CheckForReverseGravity = false;
 UINT16 invulntics = 20*TICRATE;
 UINT16 sneakertics = 20*TICRATE;
 UINT16 flashingtics = 3*TICRATE/2; // SRB2kart
+UINT16 tailsflytics = 8*TICRATE;
+UINT16 underwatertics = 30*TICRATE;
+UINT16 spacetimetics = 11*TICRATE + (TICRATE/2);
 UINT16 extralifetics = 4*TICRATE;

 // SRB2kart
@@ -200,7 +210,10 @@ const INT32 wipeoutslowtime = 20;
 const INT32 wantedreduce = 5*TICRATE;
 const INT32 wantedfrequency = 10*TICRATE;

+INT32 gameovertics = 15*TICRATE;
+
 UINT8 use1upSound = 0;
+UINT8 maxXtraLife = 2; // Max extra lives from rings

 UINT8 introtoplay = 0;
 UINT8 creditscutscene = 0;
@@ -215,7 +228,7 @@ tic_t racecountdown = 0, exitcountdown = 0; // for racing
 fixed_t gravity = 0;
 fixed_t mapobjectscale = FRACUNIT;

-struct maplighting maplighting = {};
+struct maplighting maplighting;

 INT16 autobalance = 0; //for CTF team balance
 INT16 teamscramble = 0; //for CTF team scramble
@@ -441,14 +454,6 @@ 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};

@@ -510,8 +515,11 @@ void G_ClearRecords(void)
 	INT16 i;
 	for (i = 0; i < NUMMAPS; ++i)
 	{
-		Z_Free(mainrecords[i]);
-		mainrecords[i] = NULL;
+		if (mainrecords[i])
+		{
+			Z_Free(mainrecords[i]);
+			mainrecords[i] = NULL;
+		}
 	}
 }

@@ -792,10 +800,6 @@ 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;
@@ -858,8 +862,9 @@ 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.
@@ -894,11 +899,15 @@ 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 ((cmd->driftturn || cmd->buttons)
+	if ((moveinput || cmd->buttons)
 		&& displayplayers[0] != consoleplayer && ssplayer == 1)
 	{
 		if (cv_director.value)
@@ -910,63 +919,6 @@ 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
@@ -1114,7 +1066,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)
 		{
@@ -1195,8 +1147,6 @@ 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
@@ -1290,6 +1240,8 @@ static void G_DoLoadLevel(boolean resetplayer)
 	// Make sure objectplace is OFF when you first start the level!
 	OP_ResetObjectplace();

+	levelstarttic = gametic; // for time calculation
+
 	if (wipegamestate == GS_LEVEL)
 		wipegamestate = -1; // force a wipe

@@ -3343,6 +3295,18 @@ static void G_DoStartVote(void)
 	gameaction = ga_nothing;
 }

+//
+// G_UseContinue
+//
+void G_UseContinue(void)
+{
+	if (gamestate == GS_LEVEL && !netgame && !multiplayer)
+	{
+		gameaction = ga_startcont;
+		lastdraw = true;
+	}
+}
+
 static void G_DoStartContinue(void)
 {
 	I_Assert(!netgame && !multiplayer);
@@ -3381,7 +3345,7 @@ static void G_DoContinued(void)
 	token = 0;

 	// Reset # of lives
-	pl->lives = 3;
+	pl->lives = (ultimatemode) ? 1 : 3;

 	D_MapChange(gamemap, gametype, false, false, 0, false, false);

@@ -3471,7 +3435,7 @@ void G_LoadGameData(void)
 	INT32 i, j;
 	UINT8 modded = false;
 	UINT8 rtemp;
-	savebuffer_t save = {};
+	savebuffer_t save = {0};

 	//For records
 	tic_t rectime;
@@ -3604,7 +3568,7 @@ void G_SaveGameData(boolean force)
 	size_t length;
 	INT32 i, j;
 	UINT8 btemp;
-	savebuffer_t save = {};
+	savebuffer_t save = {0};
 	(void)force;
 	char backupfile[MAX_WADPATH+4];

@@ -3775,7 +3739,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	size_t length;
 	char vcheck[VERSIONSIZE];
 	char savename[255];
-	savebuffer_t save = {};
+	savebuffer_t save = {0};

 	// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
 	memset(&savedata, 0, sizeof(savedata));
@@ -3861,7 +3825,7 @@ void G_SaveGame(UINT32 savegameslot)
 	boolean saved;
 	char savename[256] = "";
 	const char *backup;
-	savebuffer_t save = {};
+	savebuffer_t save = {0};

 	sprintf(savename, savegamename, savegameslot);
 	backup = va("%s",savename);
@@ -3875,7 +3839,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;

-		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
+		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -4025,6 +3989,7 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
 	if (W_CheckNumForName(mapname) == LUMPERROR)
 	{
 		I_Error("Internal game map '%s' not found\n", mapname);
+		Command_ExitGame_f();
 		return;
 	}

@@ -4125,13 +4090,12 @@ 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(NULL, " "))
+			qp = strtok(0, " "))
 	{
 		if (( sp = strcasestr(s, qp) ))
 		{
@@ -4140,12 +4104,10 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
-
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
-
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4214,7 +4176,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 			{
 				newmapnum = mapnum;
 				newmapname = realmapname;
-				realmapname = NULL;
+				realmapname = 0;
 				Z_Free(apromapname);
 				if (!wanttable)
 					break;
@@ -4235,7 +4197,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 				{
 					apromapnum = mapnum;
 					apromapname = realmapname;
-					realmapname = NULL;
+					realmapname = 0;
 				}
 			}
 			else/* ...match individual keywords */
@@ -39,8 +39,12 @@ extern INT32 player_name_changes[MAXPLAYERS];
 extern player_t players[MAXPLAYERS];
 extern boolean playeringame[MAXPLAYERS];

+// gametic at level start
+extern tic_t levelstarttic;
+
 // for modding?
 extern INT16 prevmap, nextmap;
+extern INT32 gameovertics;
 extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard display)
 extern INT16 rw_maximums[NUM_WEAPONS];

@@ -70,8 +74,6 @@ 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
@@ -126,7 +128,6 @@ 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;

@@ -248,6 +249,7 @@ UINT8 G_GetGametypeColor(INT16 gt);
 void G_ExitLevel(void);
 void G_NextLevel(void);
 void G_Continue(void);
+void G_UseContinue(void);
 void G_AfterIntermission(void);
 void G_EndGame(void); // moved from y_inter.c/h and renamed

@@ -81,10 +81,6 @@ 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_gamepadifunfocused = {"gamepadunfocused",  "Off", CV_SAVE|CV_CALL, CV_OnOff, I_SetJoystickFocus, 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)
@@ -934,17 +930,12 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)

 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);

-	if (cv_gamepadled[playernum].value == 0 || (window_notinfocus && cv_gamepadledifunfocused.value == 0)
+	if (cv_gamepadled[playernum].value == 0
 	 || color >= MAXTRANSLATIONS)
 	{
 		return;
 	}

-	if (!I_GamepadHasLED(playernum))
-	{
-		return;
-	}
-
 	// so we can override this
 	skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
 	byte_color = V_GetColor(colortranslations[skincolor][8]).s;
@@ -954,8 +945,6 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)

 static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
 {
-	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
-
 	if (cv_gamepadled[playernum].value == 0)
 	{
 		I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
@@ -980,22 +969,17 @@ void G_DeviceLEDTick(void)
 	for (i = 0; i <= splitscreen; i++)
 	{
 		if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
-		{
 			continue;
-		}
-
-		// does not have a configurable led! :c
-		if (!I_GamepadHasLED(i))
-		{
-			continue;
-		}

 		newcolor = G_GetSkinColorForGamepad(i);

+		// compiler be absolutely tripping
+		// delet this if this gets fixed within gcc
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
 		if (curcolor[i] == newcolor) // dont update if same colour
-		{
 			continue;
-		}
+#pragma GCC diagnostic pop

 		G_SetPlayerGamepadIndicatorColor(i, newcolor);
 		curcolor[i] = newcolor;
@@ -1010,7 +994,6 @@ void G_ResetDeviceLED(void)

 static void G_ResetPlayerDeviceRumble(INT32 playernum)
 {
-	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 	I_GamepadRumble(playernum, 0, 0, 0);
 }

@@ -1028,7 +1011,7 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
 {
 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);

-	if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0))
+	if (cv_rumble[playernum].value == 0)
 	{
 		return;
 	}
@@ -1071,12 +1054,6 @@ void G_DeviceRumbleTick(void)
 			continue;
 		}

-		// does not support rumble! :c
-		if (!I_GamepadHasRumble(i))
-		{
-			continue;
-		}
-
 		if (camera[i].freecam)
 		{
 			continue;
@@ -116,10 +116,6 @@ extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
 extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS];
 extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];

-extern consvar_t cv_gamepadifunfocused;
-extern consvar_t cv_gamepadledifunfocused;
-extern consvar_t cv_rumbleifunfocused;
-
 extern INT32 mousex, mousey;

 extern INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET];
@@ -52,6 +52,7 @@ typedef enum
 } gameaction_t;

 extern gamestate_t gamestate;
+extern UINT8 ultimatemode; // was sk_insane
 extern gameaction_t gameaction;

 extern boolean botingame;
@@ -391,7 +391,7 @@ void HWR_RenderBatches(void)
 				nextSurfaceInfo = nextEntry->surf;

 				if (nextPolyFlags & PF_NoTexture)
-					nextTexture = NULL;
+					nextTexture = 0;

 				if (useshader && currentShader != nextShader)
 				{
@@ -15,6 +15,8 @@

 #ifdef HWRENDER

+#include <unordered_set>
+
 #include "hw_main.h"
 #include "hw_glob.h"
 #include "hw_gl.h"
@@ -98,7 +100,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
 			position = 0;
 		}

-		position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
+		position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);

 		if (position + count >= pblockheight)
 			count = pblockheight - position;
@@ -162,7 +164,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -212,7 +214,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = (UINT8 *)(mipmap->data);
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -288,7 +290,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	INT32 blocksize = (glMipmap->width * glMipmap->height);

 	bpp = format2bpp(glMipmap->format);
-	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
+	block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));

 	switch (bpp)
 	{
@@ -325,7 +327,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];

 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
+	gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);

 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -344,7 +346,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif

-	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
 	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));

@@ -377,7 +379,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
+		pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;

 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -413,7 +415,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;

 		// setup the texture info
-		glMipmap->format = (GLTextureFormat_t)(patchformat);
+		glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);

 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -455,7 +457,7 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;

-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);

 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
@@ -471,7 +473,7 @@ void HWR_FreeTexture(patch_t *patch)

 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+		GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);

 		HWR_FreeTextureColormaps(patch);

@@ -497,7 +499,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;

-	pat = (GLPatch_t *)(patch->hardware);
+	pat = static_cast<GLPatch_t *>(patch->hardware);
 	if (!pat)
 		return;

@@ -612,20 +614,25 @@ void HWR_FreeMapTextures(void)
 	gl_numtextures = 0;
 }

-#define NAME    flatcheck
-#define KEY_TY  UINT32
-#define HASH_FN vt_hash_integer
-#define CMPR_FN vt_cmpr_integer
-#include "../verstable.h"
-
 static void HWR_PrecacheLevelFlats(void)
 {
 	// lookup for flats that may´ve been already loaded
-	flatcheck flatpresent;
-	flatcheck_init(&flatpresent);
+	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
+	std::unordered_set<UINT32> flatpresent;
+	lumpnum_t lump;
 	size_t i, j;
 	INT32 k;

+	auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
+	{
+		// flat already loaded?
+		if (flatpresent.count(lump) == 0)
+		{
+			HWR_GetFlat(lump, noencoremap);
+			flatpresent.insert(lump);
+		}
+	};
+
 	// special case for encore
 #ifdef GLENCORE
 	if (encoremap)
@@ -642,24 +649,16 @@ static void HWR_PrecacheLevelFlats(void)
 				const INT32 pic = ceiling ? sec->ceilingpic : sec->floorpic;

 				const levelflat_t *levelflat = &levelflats[pic];
+				lump = levelflat->lumpnum;

-				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-				{
-					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
-					flatcheck_insert(&flatpresent, levelflat->lumpnum);
-				}
+				load_flat(lump, R_NoEncore(sec, ceiling));

 				if (levelflat->speed) // is it an animated flat ?
 				{
 					// start from 0, occasionally basenumlump != flat->lumpnum
 					for (k = 0; k < levelflat->numpics; k++)
 					{
-						lumpnum_t lump = levelflat->baselumpnum + k;
-						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-						{
-							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
-							flatcheck_insert(&flatpresent, lump);
-						}
+						load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
 					}
 				}
 			}
@@ -673,30 +672,20 @@ static void HWR_PrecacheLevelFlats(void)
 		for (i = 0; i < numlevelflats; i++)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
+			lump = levelflat->lumpnum;

-			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-			{
-				HWR_GetFlat(levelflat->lumpnum, false);
-				flatcheck_insert(&flatpresent, levelflat->lumpnum);
-			}
+			load_flat(lump, false);

 			if (levelflat->speed) // is it an animated flat ?
 			{
 				// start from 0, occasionally basenumlump != flat->lumpnum
 				for (k = 0; k < levelflat->numpics; k++)
 				{
-					lumpnum_t lump = levelflat->baselumpnum + k;
-					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-					{
-						HWR_GetFlat(lump, false);
-						flatcheck_insert(&flatpresent, lump);
-					}
+					load_flat(levelflat->baselumpnum + k, false);
 				}
 			}
 		}
 	}
-
-	flatcheck_cleanup(&flatpresent);
 }

 static void HWR_PrecacheLevelTextures(void)
@@ -706,7 +695,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;

-	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
+	texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");

@@ -881,7 +870,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();

 	gl_numtextures = pnumtextures;
-	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
+	gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t

 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -978,7 +967,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));

 #ifdef GLENCORE
-	flat = (UINT8 *)(glMipmap->data);
+	flat = static_cast<UINT8 *>(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1022,7 +1011,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+		glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
 		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
@@ -1046,7 +1035,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);

 	if (!glMipmap->downloaded)
 	{
@@ -1067,7 +1056,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
+	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
 	HWR_MakePatch(patch, glPatch, glMipmap, true);

 	// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1103,7 +1092,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)

 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = (GLPatch_t *)(patch->hardware);
+	glPatch = static_cast<GLPatch_t *>(patch->hardware);

 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1139,12 +1128,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 	//              (it have a liste of mipmap)
 	//    this malloc is cleared in HWR_FreeColormapCache
 	//    (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
-	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
+	newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;

-	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
 	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));

@@ -1167,7 +1156,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 	{
 		void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
 		Patch_Create(NULL, 0, ptr);
-		Patch_AllocateHardwarePatch((patch_t *)(ptr));
+		Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
 	}

 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1184,7 +1173,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
+	UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1340,7 +1329,7 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = (UINT8 *)(Z_Malloc(
+	UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
 		HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
 		PU_STATIC, NULL));
 #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1385,7 +1374,7 @@ void HWR_SetMapPalette(void)
 		if (palsize < 768) // 256 * 3
 			I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");

-		RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
+		RGB_data = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
 		// we got the RGB palette now, but we need it in RGBA format.
 		for (i = 0; i < 256; i++)
 		{
@@ -1420,7 +1409,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
+	RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));

 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.
@@ -319,24 +319,23 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 	double clipfov;
 	double floatangle;
 	angle_t a1;
-	float tilt;
+
+	float tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
+
+	if (tilt > 90.0f)
+		tilt = 90.0f;

 	// If the pitch is larger than this you can look all around at a FOV of 90
 	if (abs((signed)tiltangle) > 46 * ANG1)
 		return 0xffffffff;

-	tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
-
-	if (tilt > 90.0f)
-		tilt = 90.0f;
-
 	// 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_PI;
 	floatangle = 2.0 + (45.0 + ((double)tilt / 1.9)) * clipfov / 90.0;
 	if (floatangle >= 180.0)
 		return 0xffffffff;
-	a1 = (angle_t)lrint(ANG1 * floatangle);
+	a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle);
 	return a1;
 }

@@ -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;
@@ -32,6 +32,20 @@

 #include <fcntl.h>

+typedef struct
+{
+	UINT8 id_field_length ; // 1
+	UINT8 color_map_type  ; // 2
+	UINT8 image_type      ; // 3
+	UINT8 dummy[5]        ; // 4,  8
+	INT16 x_origin        ; // 9, 10
+	INT16 y_origin        ; //11, 12
+	INT16 width           ; //13, 14
+	INT16 height          ; //15, 16
+	UINT8 image_pix_size  ; //17
+	UINT8 image_descriptor; //18
+} ATTRPACK TGAHeader; // sizeof is 18
+
 static const UINT8 softwaretranstogl[11]    = {  0, 25, 51, 76,102,127,153,178,204,229,255};
 static const UINT8 softwaretranstogl_hi[11] = {  0, 51,102,153,204,255,255,255,255,255,255};
 static const UINT8 softwaretranstogl_lo[11] = {  0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
@@ -43,7 +57,8 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 {
 	FOutVector v[4];
 	FBITFIELD flags;
-	float cx, cy;
+	float cx = FIXED_TO_FLOAT(x);
+	float cy = FIXED_TO_FLOAT(y);
 	UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
 	UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT);
 	GLPatch_t *hwrPatch;
@@ -57,9 +72,6 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 	if (alphalevel >= 10 && alphalevel < 13)
 		return;

-	cx = FIXED_TO_FLOAT(x);
-	cy = FIXED_TO_FLOAT(y);
-
 	const float fvw = (float)vid.width;
 	const float fvh = (float)vid.height;

@@ -138,7 +150,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 				if (!column->topdelta)
 				{
 					const UINT8 *source = (const UINT8 *)(column) + 3;
-					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
+					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
 				}
 			}

@@ -210,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)
@@ -232,7 +244,8 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 {
 	FOutVector v[4];
 	FBITFIELD flags;
-	float cx, cy;
+	float cx = FIXED_TO_FLOAT(x);
+	float cy = FIXED_TO_FLOAT(y);
 	UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
 	GLPatch_t *hwrPatch;

@@ -245,9 +258,6 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 	if (alphalevel >= 10 && alphalevel < 13)
 		return;

-	cx = FIXED_TO_FLOAT(x);
-	cy = FIXED_TO_FLOAT(y);
-
 	const float fvw = (float)vid.width;
 	const float fvh = (float)vid.height;

@@ -292,7 +302,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 				if (!column->topdelta)
 				{
 					const UINT8 *source = (const UINT8 *)(column) + 3;
-					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
+					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
 				}
 			}

@@ -375,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)
@@ -480,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;
@@ -533,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
@@ -588,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;

@@ -692,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)
@@ -810,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)
@@ -954,20 +964,6 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
 #endif

 #ifndef USE_PNG
-typedef struct
-{
-	UINT8 id_field_length ; // 1
-	UINT8 color_map_type  ; // 2
-	UINT8 image_type      ; // 3
-	UINT8 dummy[5]        ; // 4,  8
-	INT16 x_origin        ; // 9, 10
-	INT16 y_origin        ; //11, 12
-	INT16 width           ; //13, 14
-	INT16 height          ; //15, 16
-	UINT8 image_pix_size  ; //17
-	UINT8 image_descriptor; //18
-} ATTRPACK TGAHeader; // sizeof is 18
-
 // --------------------------------------------------------------------------
 // save screenshots with TGA format
 // --------------------------------------------------------------------------
@@ -32,12 +32,8 @@ void GL_SetSpecialState(hwdspecialstate_t IdState, INT32 Value);
 void GL_SetTransform(FTransform *stransform);
 void GL_SetBlend(FBITFIELD PolyFlags);
 void GL_SetPalette(RGBA_t *palette);
-
 void GL_ClearBuffer(FBOOLEAN ColorMask, FBOOLEAN DepthMask, FBOOLEAN StencilMask, FRGBAFloat * ClearColor);

-void GL_EnableStencilTest(void);
-void GL_DisableStencilTest(void);
-
 void GL_DrawPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags);
 void GL_DrawIndexedTriangles(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, unsigned int *IndexArray);
 void GL_Draw2DLine(F2DCoord *v1, F2DCoord *v2, RGBA_t Color);
@@ -67,7 +63,7 @@ void GL_FlushScreenTextures(void);
 void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags);
 void GL_DoScreenWipe(int wipeStart, int wipeEnd);
 void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize);
-void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height);
+void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean useshader);

 void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]);

@@ -76,7 +72,6 @@ void GL_LoadShader(int slot, char *code, hwdshaderstage_t stage);
 boolean GL_CompileShader(int slot);
 void GL_SetShader(int slot);
 void GL_UnSetShader(void);
-void GL_EnableShader(void);

 void GL_SetShaderInfo(hwdshaderinfo_t info, INT32 value);

@@ -85,9 +80,6 @@ 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
@@ -34,8 +34,8 @@ typedef struct gl_vissprite_s
 	float gz, gzt;
 	float tz;
 	float scale;
-	//float spritexscale, spriteyscale;
-	//float spritexoffset, spriteyoffset;
+	float spritexscale, spriteyscale;
+	float spritexoffset, spriteyoffset;
 	patch_t *gpatch;
 	boolean flip;
 	UINT8 translucency;       //alpha level 0-255
@@ -14,7 +14,6 @@
 #ifdef HWRENDER

 #include <algorithm>
-#include <vector>

 #include "../doomstat.h"
 #include "../doomdef.h"
@@ -101,8 +100,7 @@ sector_t *gl_backsector = NULL;
 static constexpr float clipping_distances[] = {1024.0f, 2048.0f, 4096.0f, 6144.0f, 8192.0f, 12288.0f, 16384.0f};
 // values for bsp culling
 // slightly higher than the far clipping plane to compensate for impreciseness
-static constexpr INT32 bsp_culling_distances[] = {
-	(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
+static constexpr INT32 bsp_culling_distances[] = {(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
 	(6144+512)*FRACUNIT, (8192+512)*FRACUNIT, (12288+512)*FRACUNIT, (16384+512)*FRACUNIT};

 // Performance stats
@@ -242,6 +240,7 @@ consvar_t cv_glportals = {"gr_portals", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,

 consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_glflashpal = {"gr_flashpal", "On", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};

 consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL};

@@ -254,11 +253,11 @@ static void CV_screentextures_OnChange(void)
 	{
 		if (cv_glpaletterendering.value != 0)
 			CV_SetValue(&cv_glpaletterendering, 0);
+
 #ifdef USE_FBO_OGL
 		if (cv_glframebuffer.value != 0)
 			CV_SetValue(&cv_glframebuffer, 0);
 #endif
-		intermissionbginit = false;
 	}
 	GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value);
 	M_UpdateOGLMenu();
@@ -275,7 +274,6 @@ static void CV_glframebuffer_OnChange(void)
 	I_DownSample();
 	RefreshOGLSDLSurface();
 	M_UpdateOGLMenu();
-	intermissionbginit = false;
 }
 #endif

@@ -389,11 +387,11 @@ void HWR_ObjectLightLevelPost(gl_vissprite_t *spr, const sector_t *sector, INT32
 			extralight = FixedMul(extralight, std::min(std::max(0, *lightlevel), 255) * FRACUNIT / 255);

 			// simple OGL approximation
-			const fixed_t tr = R_QuickCamDist(spr->mobj->x, spr->mobj->y);
-			const fixed_t xscale = FixedDiv((vid.width / 2) << FRACBITS, tr);
+			fixed_t tr = R_QuickCamDist(spr->mobj->x, spr->mobj->y);
+			fixed_t xscale = FixedDiv((vid.width / 2) << FRACBITS, tr);

 			// Less change in contrast at further distances, to counteract DOOM diminished light
-			const fixed_t n = FixedDiv(FixedMul(xscale, LIGHTRESOLUTIONFIX), ((MAXLIGHTSCALE-1) << LIGHTSCALESHIFT));
+			fixed_t n = FixedDiv(FixedMul(xscale, LIGHTRESOLUTIONFIX), ((MAXLIGHTSCALE-1) << LIGHTSCALESHIFT));
 			extralight = FixedMul(extralight, std::min(n, FRACUNIT));

 			// Contrast is stronger for normal sprites, stronger than wall lighting is at the same distance
@@ -511,12 +509,12 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
 {
 	INT16 finallight = lightnum;

-	if (cv_glfakecontrast.value == 0 || (colormap && HWR_ShouldUsePaletteRendering()))
+	if (cv_glfakecontrast.value == 0 || (HWR_ShouldUsePaletteRendering() && colormap))
 		return (FUINT)finallight;

 	if (seg != NULL && P_ApplyLightOffsetFine(lightnum, seg->frontsector))
 	{
-		const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);
+		INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);

 		finallight += offset;
 		finallight = CLAMP(finallight, 0 , 255);
@@ -534,7 +532,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t

 	if (slope != NULL && sector != NULL && P_ApplyLightOffsetFine(lightnum, sector))
 	{
-		const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);
+		INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);

 		finallight += (fof ? -offset : offset);
 		finallight = CLAMP(finallight, 0 , 255);
@@ -551,7 +549,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
 // Render a floor or ceiling convex polygon
 static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
 {
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FOutVector *v3d;
 	polyvertex_t *pv;
 	pslope_t *slope = NULL;
@@ -588,11 +586,15 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 	const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;

 	// Get the slope pointer to simplify future code
-	if (!isceiling && sec->f_slope)
+	if (sec->f_slope && !isceiling)
 		slope = sec->f_slope;
-	else if (isceiling && sec->c_slope)
+	else if (sec->c_slope && isceiling)
 		slope = sec->c_slope;

+	// Set fixedheight to the slope's height from our viewpoint, if we have a slope
+	if (slope)
+		fixedheight = P_GetSlopeZAt(slope, viewx, viewy);
+
 	height = FixedToFloat(fixedheight);

 	// Allocate plane-vertex buffer if we need to
@@ -684,19 +686,18 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 			vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\
 			vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\
 		}\
-\
-		if (slope)\
-		{\
-			fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
-			height = FixedToFloat(fixedheight);\
-		}\
 \
 		vert->x = (vx);\
 		vert->y = height;\
 		vert->z = (vy);\
 \
+		if (slope)\
+		{\
+			fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
+			vert->y = FixedToFloat(fixedheight);\
+		}\
 }
-	for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++, v3d++, pv++)
+	for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++,pv++)
 		SETUP3DVERT(v3d, pv->x, pv->y);

 	if (slope)
@@ -1376,9 +1377,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	extracolormap_t *colormap = gl_frontsector->extra_colormap;
 	lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap);

-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;

-	Surf.PolyColor.s.alpha = 255;
+	if (gl_frontsector)
+		Surf.PolyColor.s.alpha = 255;

 	const INT32 gl_midtexture = R_GetTextureNum(gl_sidedef->midtexture);
 	GLMapTexture_t *glTex = NULL;
@@ -1421,11 +1423,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 					{
 						draw_sky_walls(0, 1, worldhigh, worldhighslope);
 					}
-
-					// hack to allow height changes in outdoor areas
-					// This is what gets rid of the upper textures if there should be sky
-					worldtop = worldhigh;
-					worldtopslope = worldhighslope;
 				}
 				else
 				{
@@ -1470,6 +1467,15 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 			}
 		}

+		// hack to allow height changes in outdoor areas
+		// This is what gets rid of the upper textures if there should be sky
+		if (gl_frontsector->ceilingpic == skyflatnum
+			&& gl_backsector->ceilingpic  == skyflatnum)
+		{
+			worldtop = worldhigh;
+			worldtopslope = worldhighslope;
+		}
+
 		gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);

 		// check TOP TEXTURE
@@ -1778,10 +1784,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		// Single sided line... Deal only with the middletexture (if one exists)
 		if (gl_midtexture && gl_linedef->special != HORIZONSPECIAL) // Ignore horizon line for OGL
 		{
-			fixed_t texturevpeg;
-
 			glTex = HWR_GetTexture(gl_midtexture, noencore);

+			fixed_t texturevpeg;
+
 			// PEGGING
 			if ((gl_linedef->flags & (ML_DONTPEGBOTTOM|ML_EFFECT2)) == (ML_DONTPEGBOTTOM|ML_EFFECT2))
 				texturevpeg = gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight + gl_sidedef->rowoffset;
@@ -1868,13 +1874,12 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	//Hurdler: 3d-floors test
 	if (!gl_drawing_stencil && gl_backsector && gl_frontsector->tag != gl_backsector->tag && (gl_backsector->ffloors || gl_frontsector->ffloors))
 	{
-		ffloor_t *rover;
-		fixed_t highcut = 0, lowcut = 0;
+		ffloor_t * rover;
+		fixed_t    highcut = 0, lowcut = 0;
 		fixed_t lowcutslope = 0, highcutslope = 0;

 		// Used for height comparisons and etc across FOFs and slopes
 		fixed_t high1, highslope1, low1, lowslope1;
-		fixed_t high2, highslope2, low2, lowslope2;

 		INT32 texnum;

@@ -1887,6 +1892,19 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		{
 			for (rover = gl_backsector->ffloors; rover; rover = rover->next)
 			{
+				boolean bothsides = false;
+				// Skip if it exists on both sectors.
+				ffloor_t * r2;
+				for (r2 = gl_frontsector->ffloors; r2; r2 = r2->next)
+					if (rover->master == r2->master)
+					{
+						bothsides = true;
+						break;
+					}
+
+				if (bothsides)
+					continue;
+
 				const ffloortype_e roverflags = rover->flags;

 				if (!(roverflags & FF_EXISTS) || !(roverflags & FF_RENDERSIDES) || (roverflags & FF_INVERTSIDES))
@@ -1898,45 +1916,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				if ((high1 < lowcut || highslope1 < lowcutslope) || (low1 > highcut || lowslope1 > highcutslope))
 					continue;

-				ffloor_t * r2;
-				for (r2 = gl_frontsector->ffloors; r2; r2 = r2->next)
-				{
-					if (r2->master == rover->master) // Skip if same control line.
-						break;
-
-					const ffloortype_e r2flags = r2->flags;
-
-					if (!(r2flags & FF_EXISTS) || !(r2flags & FF_RENDERSIDES))
-						continue;
-
-					if (rover->flags & FF_EXTRA)
-					{
-						if (!(r2flags & FF_CUTEXTRA))
-							continue;
-
-						if (r2flags & FF_EXTRA && (r2flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG)))
-							continue;
-					}
-					else
-					{
-						if (!(r2flags & FF_CUTSOLIDS))
-							continue;
-					}
-
-					SLOPEPARAMS(*r2->t_slope, high2, highslope2, *r2->topheight)
-					SLOPEPARAMS(*r2->b_slope, low2,  lowslope2,  *r2->bottomheight)
-
-					if ((high2 < lowcut || highslope2 < lowcutslope) || (low2 > highcut || lowslope2 > highcutslope))
-						continue;
-					if ((high1 > high2 || highslope1 > highslope2) || (low1 < low2 || lowslope1 < lowslope2))
-						continue;
-
-					break;
-				}
-
-				if (r2)
-					continue;
-
 				side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);

 				boolean do_texture_skew;
@@ -2073,6 +2052,19 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		{
 			for (rover = gl_frontsector->ffloors; rover; rover = rover->next)
 			{
+				boolean bothsides = false;
+				// Skip if it exists on both sectors.
+				ffloor_t * r2;
+				for (r2 = gl_backsector->ffloors; r2; r2 = r2->next)
+					if (rover->master == r2->master)
+					{
+						bothsides = true;
+						break;
+					}
+
+				if (bothsides)
+					continue;
+
 				const ffloortype_e roverflags = rover->flags;

 				if (!(roverflags & FF_EXISTS) || !(roverflags & FF_RENDERSIDES) || !(roverflags & FF_ALLSIDES))
@@ -2084,44 +2076,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				if ((high1 < lowcut || highslope1 < lowcutslope) || (low1 > highcut || lowslope1 > highcutslope))
 					continue;

-				ffloor_t * r2;
-				for (r2 = gl_backsector->ffloors; r2; r2 = r2->next)
-				{
-					if (r2->master == rover->master) // Skip if same control line.
-						break;
-
-					const ffloortype_e r2flags = r2->flags;
-
-					if (!(r2flags & FF_EXISTS) || !(r2flags & FF_RENDERSIDES))
-						continue;
-
-					if (rover->flags & FF_EXTRA)
-					{
-						if (!(r2flags & FF_CUTEXTRA))
-							continue;
-
-						if (r2flags & FF_EXTRA && (r2flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG)))
-							continue;
-					}
-					else
-					{
-						if (!(r2flags & FF_CUTSOLIDS))
-							continue;
-					}
-
-					SLOPEPARAMS(*r2->t_slope, high2, highslope2, *r2->topheight)
-					SLOPEPARAMS(*r2->b_slope, low2,  lowslope2,  *r2->bottomheight)
-
-					if ((high2 < lowcut || highslope2 < lowcutslope) || (low2 > highcut || lowslope2 > highcutslope))
-						continue;
-					if ((high1 > high2 || highslope1 > highslope2) || (low1 < low2 || lowslope1 < lowslope2))
-						continue;
-
-					break;
-				}
-				if (r2)
-					continue;
-
 				side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);

 				boolean do_texture_skew;
@@ -2260,7 +2214,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom

 static inline boolean HWR_UsePortals(void)
 {
-	return supportstencil && gl_maphasportals && cv_glportals.value;
+	return supportstencil && cv_glportals.value && gl_maphasportals;
 }

 // From PrBoom:
@@ -2404,8 +2358,7 @@ static inline void DoAddLine(seg_t* line, angle_t angle1, angle_t angle2)
 	// SoM: Backsector needs to be run through R_FakeFlat
 	static sector_t tempsec;

-	auto do_addline = [&](bool dontdraw)
-	{
+	auto do_addline = [&](bool dontdraw) {
 		// Single sided line?
 		if (!line->backsector)
 		{
@@ -2672,8 +2625,8 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	float           scrollx = 0.0f, scrolly = 0.0f;
 	float           anglef  = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
 	angle_t         angle = 0;
-	FSurfaceInfo    Surf = {};
-	float           tempxsow, tempytow;
+	FSurfaceInfo    Surf;
+	fixed_t         tempxsow, tempytow;
 	size_t          nrPlaneVerts;

 	static FOutVector *planeVerts = NULL;
@@ -2686,6 +2639,14 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 	if (nrPlaneVerts < 3) // not even a triangle ?
 		return;

+	if (nrPlaneVerts > INT16_MAX) // FIXME: exceeds plVerts size
+	{
+		CONS_Debug(DBG_RENDER, "polygon size of %s exceeds max value of %d vertices\n", sizeu1(nrPlaneVerts), UINT16_MAX);
+		return;
+	}
+
+	const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
+
 	// Allocate plane-vertex buffer if we need to
 	if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
 	{
@@ -2694,8 +2655,6 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
 		Z_Malloc(numAllocedPlaneVerts * sizeof(FOutVector), PU_LEVEL, &planeVerts);
 	}

-	const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
-
 	height = FixedToFloat(fixedheight);

 	len = W_LumpLength(lumpnum);
@@ -2833,8 +2792,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2855,8 +2815,9 @@ static void HWR_AddPolyObjectPlanes(void)
 			light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
 			if (po_ptrs[i]->translucency > 0)
 			{
-				FSurfaceInfo Surf = {};
+				FSurfaceInfo Surf;
 				FBITFIELD blendmode;
+				memset(&Surf, 0x00, sizeof(Surf));
 				blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
 				HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
 												(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2933,7 +2894,7 @@ static void HWR_Subsector(size_t num)
 	static sector_t tempsec; //SoM: 4/7/2000
 	INT32 floorlightlevel;
 	INT32 ceilinglightlevel;
-	INT32 locFloorHeight = 0, locCeilingHeight = 0;
+	INT32 locFloorHeight, locCeilingHeight;
 	INT32 cullFloorHeight, cullCeilingHeight;
 	INT32 light = 0;
 	extracolormap_t *floorcolormap;
@@ -2979,12 +2940,11 @@ static void HWR_Subsector(size_t num)

 	cullFloorHeight   = P_GetSectorFloorZAt  (gl_frontsector, viewx, viewy);
 	cullCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, viewx, viewy);
+	locFloorHeight    = P_GetSectorFloorZAt  (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
+	locCeilingHeight  = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);

 	if (gl_frontsector->ffloors)
 	{
-		locFloorHeight    = P_GetSectorFloorZAt  (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
-		locCeilingHeight  = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
-
 		boolean anyMoved = gl_frontsector->moved;

 		if (anyMoved == false)
@@ -3039,7 +2999,8 @@ static void HWR_Subsector(size_t num)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false));
 				HWR_RenderPlane(sub, &extrasubsectors[num], false,
-					gl_frontsector->floorheight,
+					// Hack to make things continue to work around slopes.
+					locFloorHeight == cullFloorHeight ? locFloorHeight : gl_frontsector->floorheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap);
 			}
@@ -3054,7 +3015,8 @@ static void HWR_Subsector(size_t num)
 			{
 				HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true));
 				HWR_RenderPlane(sub, &extrasubsectors[num], true,
-					gl_frontsector->ceilingheight,
+					// Hack to make things continue to work around slopes.
+					locCeilingHeight == cullCeilingHeight ? locCeilingHeight : gl_frontsector->ceilingheight,
 					// We now return you to your regularly scheduled rendering.
 					PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap);
 			}
@@ -3408,7 +3370,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 {
 	float this_scale = 1.0f;
 	FOutVector swallVerts[4];
-	FSurfaceInfo sSurf = {};
+	FSurfaceInfo sSurf;
 	FBITFIELD blendmode = 0;
 	fixed_t floorheight, mobjfloor;
 	pslope_t *floorslope;
@@ -3644,7 +3606,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	FOutVector baseWallVerts[4]; // This is what the verts should end up as
 	patch_t *gpatch;
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	extracolormap_t *colormap;
 	INT32 lightlevel;
 	boolean lightset = true;
@@ -3673,7 +3635,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);

-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);

 	// Draw shadow BEFORE sprite
 	if (UNLIKELY(cv_shadow.value // Shadows enabled
@@ -3771,15 +3733,8 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 		blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
 	}

-	if (sprmo->player)
-	{
-		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
-		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
-
-		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
-	}
+	if (cv_playerfade.value && sprmo->player)
+		Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);

 	if (HWR_UseShader())
 	{
@@ -3801,7 +3756,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 	{
 		const fixed_t h = P_GetLightZAt(&sector->lightlist[i], sprmo->x, sprmo->y);

-		if (h > temp)
+		if (!(h <= temp))
 			continue;

 		if (!lightset)
@@ -3863,7 +3818,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
 		wallVerts[1].y = endbot;

 		// The x and y only need to be adjusted in the case that it's not a papersprite
-		if (cv_glspritebillboarding.value && !cv_glshearing.value && !papersprite)
+		if (cv_glspritebillboarding.value && sprmo && !papersprite)
 		{
 			// Get the x and z of the vertices so billboarding draws correctly
 			realheight = realbot - realtop;
@@ -3929,14 +3884,14 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;
 	FBITFIELD blend = 0;

 	INT32 shader = SHADER_NONE;

 	mobj_t *sprmo = spr->mobj;

-	if (!sprmo->subsector)
+	if (UNLIKELY(!sprmo->subsector))
 		return;

 	const boolean papersprite = (sprmo->frame & FF_PAPERSPRITE);
@@ -3961,7 +3916,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);

-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);

 	// create the sprite billboard
 	//
@@ -4068,15 +4023,8 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 		blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
 	}

-	if (sprmo->player)
-	{
-		// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
-		if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
-
-		if (cv_playerfade.value)
-			Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
-	}
+	if (cv_playerfade.value && sprmo->player)
+		Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);

 	if (HWR_UseShader())
 	{
@@ -4094,13 +4042,13 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	FOutVector wallVerts[4];
 	patch_t *gpatch; // sprite patch converted to hardware
 	GLPatch_t *hwrpatch;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;

 	INT32 shader = SHADER_NONE;

 	const precipmobj_t *sprmo = spr->precip;

-	if (!sprmo->subsector)
+	if (UNLIKELY(!sprmo->subsector))
 		return;

 	// cache sprite graphics
@@ -4111,7 +4059,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	HWR_GetMappedPatch(gpatch, spr->colormap);

-	hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware);
+	hwrpatch = ((GLPatch_t *)gpatch->hardware);

 	// create the sprite billboard
 	//
@@ -4226,7 +4174,6 @@ static int CompareVisSprites(const void *p1, const void *p2)
 static void HWR_SortVisSprites(void)
 {
 	UINT32 i;
-
 	for (i = 0; i < gl_visspritecount; i++)
 	{
 		gl_vsprorder[i] = HWR_GetVisSprite(i);
@@ -4295,17 +4242,26 @@ typedef struct

 // initial size of drawnode array
 #define DRAWNODES_INIT_SIZE 64
-// no reason to waste all the allocations since every map will have atleast one translucent thing
-static std::vector<gl_drawnode_t> drawnodes;
+gl_drawnode_t *drawnodes = NULL;
+INT32 numdrawnodes = 0;
+INT32 alloceddrawnodes = 0;

 static void *HWR_CreateDrawNode(gl_drawnode_type_t type)
 {
 	gl_drawnode_t *drawnode;
-	drawnodes.reserve(DRAWNODES_INIT_SIZE);

-	drawnodes.emplace_back();
+	if (!drawnodes)
+	{
+		alloceddrawnodes = DRAWNODES_INIT_SIZE;
+		drawnodes = static_cast<gl_drawnode_t*>(Z_Malloc(alloceddrawnodes * sizeof(gl_drawnode_t), PU_LEVEL, &drawnodes));
+	}
+	else if (numdrawnodes >= alloceddrawnodes)
+	{
+		alloceddrawnodes *= 2;
+		Z_Realloc(drawnodes, alloceddrawnodes * sizeof(gl_drawnode_t), PU_LEVEL, &drawnodes);
+	}

-	drawnode = &drawnodes.back();
+	drawnode = &drawnodes[numdrawnodes++];
 	drawnode->type = type;

 	// not sure if returning different pointers to a union is necessary
@@ -4318,7 +4274,6 @@ static void *HWR_CreateDrawNode(gl_drawnode_type_t type)
 		case DRAWNODE_WALL:
 			return &drawnode->u.wall;
 	}
-
 	return NULL;
 }

@@ -4382,13 +4337,11 @@ static int CompareDrawNodePlanes(const void *p1, const void *p2)
 // Sorts and renders the list of drawnodes for the scene being rendered.
 static void HWR_RenderDrawNodes(void)
 {
-	size_t i = 0, run_start = 0;
-	static std::vector<INT32> sortindex(DRAWNODES_INIT_SIZE);
+	INT32 i = 0, run_start = 0;

 	// Array for storing the rendering order.
 	// A list of indices into the drawnodes array.
-
-	const size_t numdrawnodes = drawnodes.size();
+	INT32 *sortindex;

 	if (!numdrawnodes)
 		return;
@@ -4397,7 +4350,7 @@ static void HWR_RenderDrawNodes(void)

 	PS_START_TIMING(ps_hw_nodesorttime);

-	sortindex.resize(numdrawnodes);
+	sortindex = static_cast<INT32*>(Z_Malloc(sizeof(INT32) * numdrawnodes, PU_STATIC, NULL));

 	// Reversed order
 	for (i = 0; i < numdrawnodes; i++)
@@ -4413,7 +4366,7 @@ static void HWR_RenderDrawNodes(void)
 		if (drawnodes[sortindex[run_start]].type == DRAWNODE_PLANE)
 		{
 			// found it, now look for run end
-			size_t run_end; // (inclusive)
+			INT32 run_end; // (inclusive)

 			for (i = run_start+1; i < numdrawnodes; i++)
 			{
@@ -4426,7 +4379,7 @@ static void HWR_RenderDrawNodes(void)
 			if (run_end > run_start) // if there are multiple consecutive planes, not just one
 			{
 				// consecutive run of planes found, now sort it
-				qs22j(sortindex.data() + run_start, run_end - run_start + 1, sizeof(INT32), CompareDrawNodePlanes);
+				qs22j(sortindex + run_start, run_end - run_start + 1, sizeof(INT32), CompareDrawNodePlanes);
 			}

 			run_start = run_end + 1; // continue looking for runs coming right after this one
@@ -4498,9 +4451,12 @@ static void HWR_RenderDrawNodes(void)

 	PS_STOP_TIMING(ps_hw_nodedrawtime);

-	drawnodes.clear(); // clear so our size is 0 again!
+	numdrawnodes = 0;
+
+	Z_Free(sortindex);
 }

+
 // --------------------------------------------------------------------------
 //  Draw all vissprites
 // --------------------------------------------------------------------------
@@ -4818,9 +4774,11 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	)
 	{
 		ang = R_PointToAngle(interp.x, interp.y);
+
 #ifdef ROTSPRITE
 		camang = ang;
 #endif
+
 		ang -= interp.angle;

 		if (mirrored)
@@ -4835,7 +4793,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		flip = sprframe->flip; // Will only be 0x00 or 0xFF

 		if (papersprite && ang < ANGLE_180)
-			flip ^= 0xFF;
+			flip ^= 0xFFFF;
 	}
 	else
 	{
@@ -4855,9 +4813,9 @@ static void HWR_ProjectSprite(mobj_t *thing)
 			flip ^= (1<<rot);
 	}

-	spr_width     = spritecachedinfo[lumpoff].width;
-	spr_height    = spritecachedinfo[lumpoff].height;
-	spr_offset    = spritecachedinfo[lumpoff].offset;
+	spr_width = spritecachedinfo[lumpoff].width;
+	spr_height = spritecachedinfo[lumpoff].height;
+	spr_offset = spritecachedinfo[lumpoff].offset;
 	spr_topoffset = spritecachedinfo[lumpoff].topoffset;

 #ifdef ROTSPRITE
@@ -4943,11 +4901,11 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	// if the sprite is out of our view, dont need to draw it X)
 	if (!gld_SphereInFrustum(
 							(FixedToFloat(interp.x)) + cos_inv_yaw * (x1 + x2) / 2.0f,
-							 FixedToFloat(interp.z) + (y1 + y2) / 2.0f,
-							 FixedToFloat(interp.y) - sin_inv_yaw * (x1 + x2) / 2.0f,
-							 //1.5 == sqrt(2) + small delta for MF_FOREGROUND
-							 std::max<float>(FixedToFloat(spr_width)  * spritexscale,
-											 FixedToFloat(spr_height) * spriteyscale) / 2.0f * 1.5f))
+							FixedToFloat(interp.z) + (y1 + y2) / 2.0f,
+							FixedToFloat(interp.y) - sin_inv_yaw * (x1 + x2) / 2.0f,
+							//1.5 == sqrt(2) + small delta for MF_FOREGROUND
+							std::max<float>(FixedToFloat(spr_width)  * spritexscale,
+											FixedToFloat(spr_height) * spriteyscale) / 2.0f * 1.5f))
 	{
 		return;
 	}
@@ -5006,10 +4964,10 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	vis->flip = flip;

 	vis->scale = thing_scale;
-	/*vis->spritexscale = spritexscale;
+	vis->spritexscale = spritexscale;
 	vis->spriteyscale = spriteyscale;
 	vis->spritexoffset = FixedToFloat(spr_offset);
-	vis->spriteyoffset = FixedToFloat(spr_topoffset);*/
+	vis->spriteyoffset = FixedToFloat(spr_topoffset);

 #ifdef ROTSPRITE
 	if (rotsprite != NULL)
@@ -5138,9 +5096,9 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 	lumpoff = sprframe->lumpid[0];
 	flip = sprframe->flip; // Will only be 0x00 or 0xFF

-	spr_width     = spritecachedinfo[lumpoff].width;
-	spr_height    = spritecachedinfo[lumpoff].height;
-	spr_offset    = spritecachedinfo[lumpoff].offset;
+	spr_width = spritecachedinfo[lumpoff].width;
+	spr_height = spritecachedinfo[lumpoff].height;
+	spr_offset = spritecachedinfo[lumpoff].offset;
 	spr_topoffset = spritecachedinfo[lumpoff].topoffset;

 	if (flip)
@@ -5163,11 +5121,11 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)

 	if (!gld_SphereInFrustum(
 							(FixedToFloat(interp.x)) + cos_inv_yaw * (x1 + x2) / 2.0f,
-							 FixedToFloat(interp.z) + (y1 + y2) / 2.0f,
-							 FixedToFloat(interp.y) - sin_inv_yaw * (x1 + x2) / 2.0f,
-							 //1.5 == sqrt(2) + small delta for MF_FOREGROUND
-							 std::max<float>(FixedToFloat(spr_width)  * thing_scale,
-											 FixedToFloat(spr_height) * thing_scale) / 2.0f * 1.5f))
+							FixedToFloat(interp.z) + (y1 + y2) / 2.0f,
+							FixedToFloat(interp.y) - sin_inv_yaw * (x1 + x2) / 2.0f,
+							//1.5 == sqrt(2) + small delta for MF_FOREGROUND
+							std::max<float>(FixedToFloat(spr_width)  * thing_scale,
+											FixedToFloat(spr_height) * thing_scale) / 2.0f * 1.5f))
 	{
 		return;
 	}
@@ -5280,6 +5238,7 @@ void HWR_ClearSkyDome(void)
 	sky->loops = NULL;
 	sky->data = NULL;

+	sky->vbo = 0;
 	sky->rows = sky->columns = 0;
 	sky->loopcount = 0;

@@ -5427,7 +5386,7 @@ static void HWR_SetTransformAiming(FTransform *trans)
 		fixed_t fixedaiming = AIMINGTODY(aimingangle);
 		trans->viewaiming = FixedToFloat(fixedaiming) * (static_cast<float>(vid.width) / static_cast<float>(vid.height)) / (static_cast<float>(BASEVIDWIDTH) / static_cast<float>(BASEVIDHEIGHT));
 		if (splitscreen == 1) // only for 2 player splitscreen
-			trans->viewaiming *= 2.125f; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
+			trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
 		trans->shearing = true;
 		gl_aimingangle = 0;
 	}
@@ -5532,7 +5491,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	player_t *viewplayer = &players[displayplayers[viewssnum]];
 	const float fpov = FixedToFloat(R_GetPlayerFov(viewplayer));

-	auto reset_viewstate = [&]()
+	auto reset_viewstate = [&](const float fpov)
 	{
 		HWR_SetTransform(fpov);
 		HWR_ClearSprites();
@@ -5552,7 +5511,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 			currentportallist = &portallist;
 			HWR_SetPortalState(GLPORTAL_SEARCH);

-			reset_viewstate();
+			reset_viewstate(fpov);

 			if (rootportal)
 			{
@@ -5578,7 +5537,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
 	// draw normal things in current frame in current incremented stencil buffer area
 	HWR_SetStencilState(HWR_STENCIL_NORMAL, stencil_level);

-	reset_viewstate();
+	reset_viewstate(fpov);

 	if constexpr (Type == RenderViewpointType::kPortal)
 	{
@@ -5691,12 +5650,6 @@ extern "C" {
 // ==========================================================================
 static void HWR_RenderFrame(boolean skybox, boolean drawsky)
 {
-	// NetUpdate below may cause this to be false midrender if toggled
-	const boolean useportals = HWR_UsePortals();
-
-	if (useportals)
-		GL_EnableStencilTest();
-
 	// Clear view, set viewport (glViewport), set perspective...
 	HWR_ClearView();

@@ -5714,7 +5667,7 @@ static void HWR_RenderFrame(boolean skybox, boolean drawsky)
 					 viewwindowy,
 					(viewwindowx + viewwidth),
 					(viewwindowy + viewheight),
-					 ZCLIP_PLANE, clipping_distances[renderdist - 1]);
+					ZCLIP_PLANE, clipping_distances[renderdist - 1]);
 		current_bsp_culling_distance = bsp_culling_distances[renderdist- 1];
 	}

@@ -5722,14 +5675,11 @@ static void HWR_RenderFrame(boolean skybox, boolean drawsky)
 	NetUpdate();

 	portalclipline = NULL;
-	if (useportals)
+	if (UNLIKELY(HWR_UsePortals()))
 		HWR_RenderViewpoint<RenderViewpointType::kPortal>(NULL, 0, !skybox);
 	else
 		HWR_RenderViewpoint<RenderViewpointType::kNormal>(NULL, 0, !skybox);

-	if (useportals)
-		GL_DisableStencilTest();
-
 	// Check for new console commands.
 	NetUpdate();
 }
@@ -5906,6 +5856,7 @@ void HWR_AddCommands(void)

 	CV_RegisterVar(&cv_glpaletterendering);
 	CV_RegisterVar(&cv_glpalettedepth);
+	CV_RegisterVar(&cv_glflashpal);
 }

 // --------------------------------------------------------------------------
@@ -5985,7 +5936,7 @@ static void COM_HWR_glinfo(void)
 		// if the GPU is super new and supports a bajillion extensions - xyzzy

 		char *copy = strdup((const char*)gl_extensions);
-		char *ext;
+		char *ext = strtok(copy, " ");

 		if (copy == NULL)
 		{
@@ -5993,8 +5944,6 @@ static void COM_HWR_glinfo(void)
 			return;
 		}

-		ext = strtok(copy, " ");
-
 		do
 		{
 			CONS_Printf(" - %s\n", ext);
@@ -6064,7 +6013,7 @@ static void HWR_DoPostProcessor(void)
 {
 	// Armageddon Blast Flash!
 	// Could this even be considered postprocessor?
-	if (!HWR_ShouldUsePaletteRendering())
+	if (!HWR_PalRenderFlashpal())
 	{
 		const player_t *player = &players[displayplayers[viewssnum]];

@@ -6077,7 +6026,7 @@ static void HWR_DoPostProcessor(void)
 				{-4.0f, -4.0f, 4.0f, 0.0f, 0.0f}
 			};

-			FSurfaceInfo Surf = {};
+			FSurfaceInfo Surf;

 			// This won't change if the flash palettes are changed unfortunately, but it works for its purpose
 			if (player->flashpal == PAL_NUKE)
@@ -6096,66 +6045,64 @@ static void HWR_DoPostProcessor(void)
 		}
 	}

-	// screen textures are needed for the rest of the effects
-	if (cv_glscreentextures.value != 2)
+	if (cv_glscreentextures.value != 2) // screen textures are needed for the rest of the effects
 		return;

-	// Not supported in splitscreen - someone want to add support?
-	if (splitscreen || cv_reducevfx.value)
-		return;
-
-	//UINT8 viewnum = R_GetViewNumber();
+	//UINT8 viewnum = R_GetViewNumber(); // see below
 	//camera_t *thiscam = &camera[viewnum];
 	const camera_t *thiscam = &camera[0];

-	if (!(thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT))
-		return;
+	// Not supported in splitscreen - someone want to add support?
+	const boolean screenwave = (!splitscreen && (thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT));

 	// Capture the screen for intermission and screen waving
-	if (gamestate != GS_INTERMISSION)
+	if ((lastdraw || screenwave) && gamestate != GS_INTERMISSION)
 		GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);

 	// Drunken vision! WooOOooo~
-	// 10 by 10 grid. 2 coordinates (xy)
-	float v[SCREENVERTS][SCREENVERTS][2];
-	float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
-
-	UINT8 x, y;
-	float WAVELENGTH;
-	float AMPLITUDE;
-	float FREQUENCY;
-
-	// Modifies the wave.
-	if (thiscam->postimg & POSTIMG_WATER)
+	if (screenwave)
 	{
-		WAVELENGTH = 5.0f;
-		AMPLITUDE = 40.0f;
-		FREQUENCY = 8.0f;
-	}
-	else
-	{
-		WAVELENGTH = 10.0f;
-		AMPLITUDE = 60.0f;
-		FREQUENCY = 4.0f;
-	}
+		// 10 by 10 grid. 2 coordinates (xy)
+		float v[SCREENVERTS][SCREENVERTS][2];
+		float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));

-	//static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek
+		UINT8 x, y;
+		float WAVELENGTH;
+		float AMPLITUDE;
+		float FREQUENCY;

-	for (x = 0; x < SCREENVERTS; x++)
-	{
-		for (y = 0; y < SCREENVERTS; y++)
+		// Modifies the wave.
+		if (thiscam->postimg & POSTIMG_WATER)
 		{
-			// Change X position based on its Y position.
-			v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
-			v[x][y][1] = y-4.5f; // (y / scale)
+			WAVELENGTH = 5.0f;
+			AMPLITUDE = 40.0f;
+			FREQUENCY = 8.0f;
 		}
+		else
+		{
+			WAVELENGTH = 10.0f;
+			AMPLITUDE = 60.0f;
+			FREQUENCY = 4.0f;
+		}
+
+		//static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek
+
+		for (x = 0; x < SCREENVERTS; x++)
+		{
+			for (y = 0; y < SCREENVERTS; y++)
+			{
+				// Change X position based on its Y position.
+				v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
+				v[x][y][1] = y-4.5f; // (y / scale)
+			}
+		}
+
+		GL_PostImgRedraw(v);
+
+		// Capture the screen again for screen waving on the intermission
+		if (gamestate != GS_INTERMISSION)
+			GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
 	}
-
-	GL_PostImgRedraw(v);
-
-	// Capture the screen again for screen waving on the intermission
-	if (gamestate != GS_INTERMISSION)
-		GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
 	// Flipping of the screen isn't done here anymore
 }

@@ -151,19 +151,14 @@ FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t do
 	GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize);
 }

-FUNCINLINE static ATTRINLINE void HWR_MakeScreenTexture(void)
-{
-	GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
-}
-
 FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void)
 {
 	GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2);
 }

-FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height)
+FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height, boolean useshader)
 {
-	GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height);
+	GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height, useshader);
 }

 // hw_main.c: Segs
@@ -213,6 +208,7 @@ extern consvar_t cv_glportals;

 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
+extern consvar_t cv_glflashpal;

 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -224,6 +220,11 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }

+FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
+{
+	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
+}
+
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {
@@ -579,7 +579,7 @@ md2found:
 	fclose(f);
 }

-void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
+void HWR_AddPlayerMD2(int skin, boolean local) // For MD2's that were added after startup
 {
 	FILE *f;
 	char name[20], filename[32];
@@ -693,15 +693,17 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
 	GLPatch_t *hwrBlendPatch = blendgpatch->hardware;
 	UINT16 w = gpatch->width, h = gpatch->height;
 	UINT32 size = w*h;
-	RGBA_t *image, *blendimage, *cur;
-	RGBA_t blendcolor = {};
+	RGBA_t *image, *blendimage, *cur, blendcolor;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	UINT8 translation[17] = {}; // First the color index
-	UINT8 cutoff[17] = {}; // Brightness cutoff before using the next color
+	UINT8 translation[17]; // First the color index
+	UINT8 cutoff[17]; // Brightness cutoff before using the next color
 	UINT8 translen = 0;
 	UINT8 i;
-	UINT8 colorbrightnesses[17] = {};
-	UINT8 color_match_lookup[256] = {}; // optimization attempt
+	UINT8 colorbrightnesses[17];
+	UINT8 color_match_lookup[256]; // optimization attempt
+
+	memset(translation, 0, sizeof(translation));
+	memset(cutoff, 0, sizeof(cutoff));

 	if (glMipmap->width == 0)
 	{
@@ -714,10 +716,14 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
 		glMipmap->format = GL_TEXFMT_RGBA;
 	}

-	Z_Free(glMipmap->data);
-	glMipmap->data = NULL;
+	if (glMipmap->data)
+	{
+		Z_Free(glMipmap->data);
+		glMipmap->data = NULL;
+	}

-	cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
+	cur = Z_Malloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
+	memset(cur, 0x00, size*4);

 	image = hwrPatch->mipmap->data;
 	blendimage = hwrBlendPatch->mipmap->data;
@@ -1031,6 +1037,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
 	GLPatch_t *glPatch = patch->hardware;
 	GLMipmap_t *glMipmap, *newMipmap;

+
 	if (blendgpatch == NULL || colormap == colormaps || colormap == NULL)
 	{
 		// Don't do any blending
@@ -1099,7 +1106,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 	INT32 frame = 0;
 	INT32 nextFrame = -1;
 	FTransform p;
-	FSurfaceInfo Surf = {};
+	FSurfaceInfo Surf;

 	if (!cv_glmdls.value || spr->precip)
 		return;
@@ -1191,15 +1198,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 			Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
 		}

-		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);
-		}
+		if (cv_playerfade.value && spr->mobj->player)
+			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
@@ -1336,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 = spr->mobj->state->var2;
-			tics = (INT32)spr->mobj->anim_duration;
+			durs = (float)spr->mobj->state->var2;
+			tics = (float)spr->mobj->anim_duration;
 		}

 		//FIXME: this is not yet correct
@@ -1468,115 +1468,4 @@ 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
@@ -45,9 +45,6 @@ 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"
@@ -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, NULL);
+	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);

 	//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, NULL);
+		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
 		strcpy(texturefilename, texPos);
 	}
 	else
 	{
 		namelen = strlen(fileName) + 1;
-		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, NULL);
+		texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
 		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, NULL);
+	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, 0);
 	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, NULL);
+	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);

 	// 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, NULL);
+		retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, 0);
 		retModel->meshes[0].numVertices = header->numXYZ;
-		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL);
+		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);

 		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, NULL);
-			retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, NULL);
+			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);

 			//			if (retModel->materials[0].lightmap)
 			//				retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
-			retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, NULL);
+			retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, 0);

 			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, NULL);
-		retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL);
+		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);

 		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, NULL);
-			retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL);
+			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);
 			//			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;
@@ -154,7 +154,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 	char *buffer;
 	int surfEnd;
 	int i, t;
-	//int matCount;
+	int matCount;
 	FILE *f;

 	if (!latlnginit)
@@ -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, NULL);
+	retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);

 	// 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, NULL);
+	retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);

 	for (t = 0; t < retModel->numMaterials; t++)
 	{
@@ -225,9 +225,9 @@ 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, NULL);
+	retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, 0);

-	//matCount = 0;
+	matCount = 0;
 	for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++)
 	{
 		int j;
@@ -237,7 +237,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)

 		mdShader = (md3Shader*)((char*)mdS + mdS->offsetShaders);

-		for (j = 0; j < mdS->numShaders; j++ /*, matCount++*/)
+		for (j = 0; j < mdS->numShaders; j++, matCount++)
 		{
 			size_t len = strlen(mdShader[j].name);
 			mdShader[j].name[len-1] = 'z';
@@ -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, NULL);
+			retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, 0);
 			retModel->meshes[i].numVertices = mdS->numVerts;
-			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, NULL);
+			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, 0);
 			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, NULL);
-				retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, NULL);
+				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);

 //				if (retModel->materials[0].lightmap)
 //					retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag);
-				retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, NULL);
+				retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, 0);
 				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, NULL);
-			retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, NULL);
+			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);

 			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, NULL);
-				retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL);
+				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);
 //				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;
@@ -503,6 +503,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
 		}
 	}*/

+
 	free(buffer);

 	return retModel;
@@ -189,7 +189,7 @@ model_t *LoadModel(const char *filename, int ztag)
 		return NULL;
 	}

-	model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, NULL);
+	model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, 0);
 	strcpy(model->mdlFilename, filename);

 	Optimize(model);
@@ -237,7 +237,7 @@ void GenerateVertexNormals(model_t *model)
 		{
 			mdlframe_t *frame = &mesh->frames[j];
 			int memTag = PU_STATIC;
-			float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, NULL);
+			float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, 0);
 			int k;
 			float *vertPtr = frame->vertices;
 			float *oldNormals;
@@ -309,7 +309,7 @@ static boolean AddMaterialToList(materiallist_t **head, material_t *material)
 	}

 	// Didn't find it, so add to the list
-	newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, NULL);
+	newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, 0);
 	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, NULL);
+	newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, 0);

 	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, NULL);
-		newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, NULL);
+		newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
+		newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
 		curFrame = &newMesh->frames[0];

 		curFrame->material = curMat;
-		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);
+		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);

 		// Now traverse the meshes of the model, adding in
 		// vertices/normals/uvs that match the current material
@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	gconst char *location = strstr(str1, str2);
+	char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else
@@ -365,17 +365,13 @@ static void HWR_CompileShader(int index)
 	if (vertex_source)
 	{
 		char *preprocessed = HWR_PreprocessShader(vertex_source);
-		if (!preprocessed)
-			return;
-
+		if (!preprocessed) return;
 		GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_VERTEX);
 	}
 	if (fragment_source)
 	{
 		char *preprocessed = HWR_PreprocessShader(fragment_source);
-		if (!preprocessed)
-			return;
-
+		if (!preprocessed) return;
 		GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_FRAGMENT);
 	}

@@ -391,10 +387,8 @@ void HWR_CompileShaders(void)
 	{
 		int custom_index = gl_shadertargets[i].custom_shader;
 		HWR_CompileShader(i);
-
 		if (!gl_shaders[i].compiled)
 			CONS_Alert(CONS_ERROR, "HWR_CompileShaders: Compilation failed for base %s shader!\n", shaderxlat[i].type);
-
 		if (custom_index != -1)
 		{
 			HWR_CompileShader(custom_index);
@@ -78,23 +78,33 @@
 // Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro.
 #define GLSL_DOOM_COLORMAP_DITHER \
 	"float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
-	"float patscale = min(scr_resolution.x / 1280.0, scr_resolution.y / 720.0);\n" \
-	"patscale = max(floor(patscale + 0.5), 1.0);\n" \
-	"patscale = 1.0 / patscale;\n" \
-	"ivec2 p = ivec2(mod(floor(position * patscale), 4.0));\n" \
-	"float depthfactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \
+	"float endResolutionx = scr_resolution.x;\n" \
+	"float endResolutiony = scr_resolution.y;\n" \
+	"if (scr_resolution.x > 1280.0) {\n" \
+		"endResolutionx = scr_resolution.x * 0.5;\n" \
+	"}\n" \
+	"if (scr_resolution.y > 720.0) {\n" \
+		"endResolutiony = scr_resolution.y * 0.5;\n" \
+	"}\n" \
+	"float zFactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \
+	"int scaleFactor = int(mix(1.0, 8.0, zFactor));\n" \
+	"endResolutionx = endResolutionx * scaleFactor;\n" \
+	"endResolutiony = endResolutiony * scaleFactor;\n" \
+	"vec2 normalizedPosition = position * vec2(endResolutionx / scr_resolution.x, endResolutiony / scr_resolution.y);\n" \
+	"int x = int(mod(normalizedPosition.x, 4.0));\n" \
+	"int y = int(mod(normalizedPosition.y, 4.0));\n" \
 	"float bayerMatrix[4*4] = float[4*4](\n" \
 		"0.0, 8.0, 2.0, 10.0,\n" \
 		"12.0, 4.0, 14.0, 6.0,\n" \
 		"3.0, 11.0, 1.0, 9.0,\n" \
 		"15.0, 7.0, 13.0, 5.0\n" \
 	");\n" \
-	"float threshold = 16.0;\n" \
 	"#ifdef SRB2_PALETTE_RENDERING\n" \
-	"threshold = 11.0;\n" \
+	"float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 11.0);\n" \
+	"#else\n" \
+	"float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 16.0);\n" \
 	"#endif\n" \
-	"threshold = (1.0 - pow(depthfactor, 2.0)) * (bayerMatrix[p.y*4 + p.x] / threshold);\n" \
-	"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, depthfactor);\n"
+	"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, zFactor);\n"

 #define GLSL_DOOM_COLORMAP_NODITHER \
 	"return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
@@ -98,10 +98,10 @@ static size_t textureBufferSize = 0;
 static LTListItem *LightTablesTail = NULL;
 static LTListItem *LightTablesHead = NULL;

-static RGBA_t screenPalette[256] = {}; // the palette for the postprocessing step in palette rendering
+static RGBA_t screenPalette[256] = {0}; // 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] = {0}; // the palette for converting textures to RGBA

 static GLint gltexformat = GL_RGB5_A1;
 GLint   screen_width     = 0;               // used by Draw2DLine()
@@ -127,9 +127,9 @@ GLuint gl_num_extensions;
 int majorGL = 0, minorGL = 0;

 //Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
-GLfloat modelMatrix[16] = {};
-GLfloat projMatrix[16] = {};
-static GLint viewport[4];
+GLfloat modelMatrix[16] = {0};
+GLfloat projMatrix[16] = {0};
+static GLint   viewport[4];

 #ifdef USE_FBO_OGL
 enum
@@ -171,7 +171,7 @@ boolean supportstencil = false;
 //			flush all of the stored textures, leaving them unavailable at times such as between levels
 //			These need to start at 0 and be set to their number, and be reset to 0 when deleted so that Intel GPUs
 //			can know when the textures aren't there, as textures are always considered resident in their virtual memory
-static GLuint screenTextures[NUMSCREENTEXTURES] = {};
+static GLuint screenTextures[NUMSCREENTEXTURES] = {0};

 #define byte2float(byte) (GLfloat)(byte / 255.0f)

@@ -404,14 +404,6 @@ 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;
@@ -753,7 +745,7 @@ typedef struct gl_shaderstate_s
 static gl_shaderstate_t gl_shaderstate;

 // Shader info
-static float shader_leveltime = 0.0f;
+static float shader_leveltime = 0;
 static float shader_light_x = 0.0f;
 static float shader_light_y = 0.0f;
 static float shader_light_z = 0.0f;
@@ -866,8 +858,6 @@ void SetupGLFunc4(void)
 	GetGLfunc(glUniform3fv);
 	GetGLfunc(glGetUniformLocation);

-	GetGLfunc(glOrtho);
-
 #ifdef GLDEBUGMESSAGE
 	GetGLfunc(glDebugMessageCallback);
 #endif
@@ -1068,13 +1058,6 @@ void GL_SetShader(int slot)
 	gl_shadersenabled = false;
 }

-void GL_EnableShader(void)
-{
-	// we can just use GL_Shader_SetUniforms as itll enable the shader for us
-	// and handle any failures
-	GL_Shader_SetUniforms(NULL, NULL, NULL, NULL);
-}
-
 void GL_UnSetShader(void)
 {
 	if (gl_shadersenabled) // don't repeatedly call glUseProgram if not needed
@@ -1284,7 +1267,7 @@ void GL_SetStates(void)

 	pglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

-	pglDisable(GL_STENCIL_TEST);
+	pglEnable(GL_STENCIL_TEST);
 	pglEnable(GL_DEPTH_TEST);    // check the depth buffer
 	pglDepthMask(GL_TRUE);       // enable writing to depth buffer
 	pglClearDepth(1.0f);
@@ -1314,16 +1297,6 @@ void GL_SetStates(void)
 #endif
 }

-void GL_EnableStencilTest(void)
-{
-	pglEnable(GL_STENCIL_TEST);
-}
-
-void GL_DisableStencilTest(void)
-{
-	pglDisable(GL_STENCIL_TEST);
-}
-
 // -----------------+
 // DeleteTexture    : Deletes a texture from the GPU and frees its data
 // -----------------+
@@ -1400,19 +1373,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	gconst GLubyte *where, *terminator;
+	GLubyte         *where, *terminator;

 	if (!extension || !start)
 		return 0;

-	where = (gconst GLubyte *)strchr(extension, ' ');
+	where = (GLubyte *) strchr(extension, ' ');

 	if (where || *extension == '\0')
 		return 0;

 	for (;;)
 	{
-		where = (gconst GLubyte *)strstr((const char *)start, extension);
+		where = (GLubyte *) strstr((const char *) start, extension);

 		if (!where)
 			break;
@@ -3117,39 +3090,6 @@ 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     :
 // -----------------+
@@ -3260,6 +3200,14 @@ static void GL_Framebuffer_Generate(void)
 	if (!framebufferobject.fboobj)
 		pglGenFramebuffers(1, &framebufferobject.fboobj);

+	if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
+	{
+		// if this fails, dont retry it a gazillion times
+		// this wouldnt recover
+		supportFBO = false;
+		return;
+	}
+
 	// Bind the framebuffer
 	pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);

@@ -3311,18 +3259,6 @@ static void GL_Framebuffer_Generate(void)
 		pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
 	}

-	if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
-	{
-		//pglGetError(); TODO:implement this or smth
-		GL_MSG_Error("GL_Framebuffer_Generate: Failed to create Framebuffer Object");
-
-		// if this fails, dont retry it a gazillion times
-		// this wouldnt recover
-		supportFBO = false;
-		pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
-		return;
-	}
-
 	// Unbind the framebuffer
 	pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);

@@ -3345,10 +3281,6 @@ void GL_Framebuffer_Enable(void)

 	GL_Framebuffer_Generate();

-	// failed
-	if (!supportFBO || !framebufferobject.init)
-		return;
-
 	pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
 	pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
 }
@@ -3616,30 +3548,22 @@ 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]);

-	uint32_t r = rand();
+	const float stride = 2.f/scrwh;

-	const float ystep = 2.f/scrwh * (float)vid.udup/4.f;
-
-	for (i = 0; i < 1; i += ystep)
+	for (i = 0; i < 1; i += stride)
 	{
-		// avoid calling rand thousands of times
-		r ^= r >> 13;
-		r ^= r >> 11;
-		r ^= r << 21;
-
-		fix[2] = (float)(r & 127) / -22000.f * xfix;
+		fix[2] = (float)(rand() % 128) / -22000.f * xfix;
 		fix[0] = fix[2];
 		fix[6] = fix[0] + xfix;
 		fix[4] = fix[2] + xfix;
@@ -3657,8 +3581,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;
@@ -3681,14 +3605,13 @@ 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;
@@ -3707,7 +3630,6 @@ 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);
@@ -3743,11 +3665,11 @@ void GL_MakeScreenTexture(int tex)
 	tex_downloaded = screenTextures[tex];
 }

-void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
+void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean useshader)
 {
 	float xfix, yfix;
 	float origaspect, newaspect;
-	float xoff = 1.0f, yoff = 1.0f; // xoffset and yoffset for the polygon to have black bars around the screen
+	float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen

 	static float off[12] =
 	{
@@ -3770,19 +3692,19 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
 	if (origaspect < newaspect)
 	{
 		xoff = origaspect / newaspect;
-		yoff = 1.0f;
+		yoff = 1;
 	}
 	else if (origaspect > newaspect)
 	{
-		xoff = 1.0f;
+		xoff = 1;
 		yoff = newaspect / origaspect;
 	}

 	// float off[12];
 	off[0] = off[3]  = -xoff;
 	off[1] = off[10] = -yoff;
-	off[4] = off[7]  =  yoff;
-	off[6] = off[9]  =  xoff;
+	off[4] = off[7]  = yoff;
+	off[6] = off[9]  = xoff;

 	// float fix[8];
 	fix[3] = fix[5] = yfix;
@@ -3796,6 +3718,9 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)

 	pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]);

+	if (useshader)
+		pglUseProgram(gl_shaders[SHADER_PALETTE_POSTPROCESS].program); // Final postprocess step of palette rendering, after everything else has been drawn.
+
 	pglColor4ubv(white);

 	pglTexCoordPointer(2, GL_FLOAT, 0, fix);
@@ -3803,6 +3728,9 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)

 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);

+	if (useshader)
+		pglUseProgram(0);
+
 	tex_downloaded = screenTextures[tex];
 }

@@ -189,7 +189,7 @@ HMS_connect (const char *format, ...)
 	seek = strlen(hms_api) + 1;/* + '/' */

 	va_start (ap, format);
-	url = malloc(seek + vsnprintf(NULL, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
+	url = malloc(seek + vsnprintf(0, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
 	va_end (ap);

 	sprintf(url, "%s/", hms_api);
@@ -225,10 +225,9 @@ HMS_connect (const char *format, ...)
 	{
 		cc = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-#ifdef LOGMESSAGES
+
 		cc = curl_easy_setopt(curl, CURLOPT_STDERR, logstream);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-#endif
 	}

 	if (M_CheckParm("-bindaddr") && M_IsNextParm())
@@ -318,7 +317,6 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
-	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }
@@ -473,8 +471,8 @@ HMS_fetch_servers (msg_server_t *list, int query_id)
 			*end = '\0';

 			address = strtok(p, " ");
-			port    = strtok(NULL, " ");
-			contact = strtok(NULL, "");
+			port    = strtok(0, " ");
+			contact = strtok(0, "");

 			if (address && port)
 			{
@@ -541,7 +539,7 @@ HMS_compare_mod_version (char *buffer, size_t buffer_size)
 	if (HMS_do(hms))
 	{
 		version      = strtok(hms->buffer, " ");
-		version_name = strtok(NULL, "\n");
+		version_name = strtok(0, "\n");

 		if (version && version_name)
 		{
@@ -97,6 +97,7 @@ static textinput_t w_chat;
 static boolean headsupactive = false;
 boolean hu_showscores = false; // draw rankings
 static char hu_tick;
+static tic_t hu_emoteanim = 0;
 emote_autocomplete_t emote_autocomplete = {0};

 static huddrawlist_h luahuddrawlist_scores = NULL;
@@ -115,8 +116,155 @@ static patch_t *songcreditbg = NULL;
 // -------
 static void HU_DrawRankings(void);

+
 consvar_t cv_showspecstuff = {"showspecstuff", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};

+//======================================================================
+//                 KEYBOARD LAYOUTS FOR ENTERING TEXT
+//======================================================================
+
+char *shiftxform = NULL;
+
+char english_shiftxform[] =
+{
+	0,
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+	31,
+	' ', '!', '"', '#', '$', '%', '&',
+	'"', // shift-'
+	'(', ')', '*', '+',
+	'<', // shift-,
+	'_', // shift--
+	'>', // shift-.
+	'?', // shift-/
+	')', // shift-0
+	'!', // shift-1
+	'@', // shift-2
+	'#', // shift-3
+	'$', // shift-4
+	'%', // shift-5
+	'^', // shift-6
+	'&', // shift-7
+	'*', // shift-8
+	'(', // shift-9
+	':',
+	':', // shift-;
+	'<',
+	'+', // shift-=
+	'>', '?', '@',
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'{', // shift-[
+	'|', // shift-backslash - OH MY GOD DOES WATCOM SUCK
+	'}', // shift-]
+	'"', '_',
+	'~', // shift-`
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'{', '|', '}', '~', 127
+};
+
+char french_shiftxform[] =
+{
+	0,
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+	31,
+	' ','$', //shift-!
+	'3', //shift-"
+	'#', '$', '%',
+	'1', //shift-&
+	'4', // shift-'
+	'5', // shift-(
+	')', // shift-)
+	'*', '+',
+	'?', // shift-,
+	'6', // shift--
+	'.', '/',
+	'0', '1', '2', '3', '4', '5',
+	'6', '7', '8', '9',
+	'/', // shitf-:
+	'.', // shift-;
+	'>', // shift-<
+	'+', // shift-=
+	'>', '?', '@',
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'[', '\\', ']', '^',
+	'8', //shift-_
+	'`',
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'{', '|', '}', '~', 127,
+	128, 129,
+	'2',
+	131, 132,
+	'0',
+	134,
+	'9',
+	136, 137,
+	'7',
+	139, 140,
+	'%'
+};
+
+char french_altgrxform[] =
+{
+	0,
+	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+	31,
+	' ', '!',
+	'#', //altgr-"
+	'#', '$', '%', '&',
+	'{', //altgr-'
+	'[', //altgr-(
+	']', //altgr-)
+	'*', '+', ',',
+	'|', //altg--
+	'.', '/',
+	'0', '1', '2', '3', '4', '5',
+	'6', '7', '8', '9',
+	':', ';', '<',
+	'}', //altgr-=
+	'>', '?', '@',
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+	'[', '\\', ']', '^',
+	'\\', //altgr-backslash
+	'`',
+	'a', 'b', 'c', 'd', 'E', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+	'{', '|', '}', '~', 127,
+	128, 129,
+	'~',
+	131, 132,
+	'@',
+	134,
+	'^',
+	136, 137,
+	'`',
+	139, 140,
+	KEY_FR_U_GRAVE
+};
+
+//fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
+INT32 HU_FallBackFrSpecialLetter(INT32 key)
+{
+	switch(key){
+		case KEY_FR_E_AIGUE:     return 'e';
+		case KEY_FR_E_GRAVE:     return 'e';
+		case KEY_FR_C_CEDILLE:   return 'c';
+		case KEY_FR_A_GRAVE:     return 'a';
+		case KEY_FR_U_GRAVE:     return 'u';
+		default:       return key;
+	}
+}
+
 static char cechotext[1024];
 static tic_t cechotimer = 0;
 static tic_t cechoduration = 5*TICRATE;
@@ -260,6 +408,9 @@ void HU_Init(void)
 	COM_AddCommand("csay", Command_CSay_f);
 	RegisterNetXCmd(XD_SAY, Got_Saycmd);

+	// set shift translation table
+	shiftxform = english_shiftxform;
+
 	if (dedicated || rendermode == render_none)
 		return;

@@ -285,6 +436,11 @@ void HU_Start(void)
 	headsupactive = true;
 }

+void HU_Shiftform(void)
+{
+	shiftxform = (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
+}
+
 //======================================================================
 //                            EXECUTION
 //======================================================================
@@ -341,9 +497,7 @@ static void HU_removeChatText_Log(void)
 	{
 		chat_log[i] = chat_log[i+1];
 	}
-
 	chat_nummsg_log--; // lost 1 msg.
-	chat_log[chat_nummsg_log] = NULL;
 }

 static void Chatlogsize_OnChange(void)
@@ -362,7 +516,6 @@ static void Chatlogsize_OnChange(void)
 	if (new_chat_log == NULL)
 	{
        free(chat_log);
-		chat_log = NULL;
 		return;
 	}
 	chat_log = new_chat_log;
@@ -388,8 +541,6 @@ void HU_AddChatText(const char *text, boolean playsound)
 		HU_removeChatText_Log();

 	chat_log[chat_nummsg_log] = malloc(HU_MSGBUFSIZE);
-	if (!chat_log[chat_nummsg_log])
-		I_Error("HU_AddChatText: out of memory for chat log\n");
 	strcpy(chat_log[chat_nummsg_log], text);
 	++chat_nummsg_log;

@@ -445,12 +596,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;
@@ -464,23 +615,17 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		strlcat(msg, COM_Argv(ix + usedargs), msgspace);
 	}

-	const size_t msglength = strlen(msg);
-
-	if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
+	if (strlen(msg) > 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.
-		CLEANUP(pfree) char *nodenum = (char*)malloc(3);
-		if (!nodenum)
-			I_Error("DoSayCommand: out of memory for sending pm\n");
-
+		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] == ' ')
@@ -489,21 +634,23 @@ 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!
@@ -514,13 +661,12 @@ 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, msglength + 1 + msg-buf);
+	SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
 }

 /** Send a message to everyone.
@@ -756,7 +902,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 	target = READSINT8(*p);
 	flags = READUINT8(*p);
 	msg = buf;
-	READSTRINGN(*p, msg, HU_MAXMSGLEN + 1);
+	READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);

 	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
 	{
@@ -771,12 +917,10 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 		return;
 	}

-	const size_t msglength = strlen(msg);
-
 	//check for invalid characters (0x80 or above)
 	{
 		size_t i;
-		const size_t j = msglength;
+		const size_t j = strlen(msg);
 		for (i = 0; i < j; i++)
 		{
 			if (msg[i] & 0x80)
@@ -823,7 +967,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
 	}

 	// Handle "/me" actions, but only in messages to everyone.
-	if (target == 0 && msglength > 4 && strnicmp(msg, "/me ", 4) == 0)
+	if (target == 0 && strlen(msg) > 4 && strnicmp(msg, "/me ", 4) == 0)
 	{
 		msg += 4;
 		action = true;
@@ -924,7 +1068,8 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)

 		HU_AddChatText(va(fmt2, prefix, cstart, dispname, textcolor, msg), cv_chatnotifications.value); // add to chat

-		Z_Free(tempchar);
+		if (tempchar)
+			Z_Free(tempchar);
 	}
 #ifdef _DEBUG
 	// I just want to point out while I'm here that because the data is still
@@ -944,6 +1089,7 @@ void HU_Ticker(void)
 		return;

 	hu_tick++;
+	hu_emoteanim++;
 	hu_tick &= 7; // currently only to blink chat input cursor

 	if (PLAYER1INPUTDOWN(gc_scores))
@@ -979,8 +1125,7 @@ void HU_Ticker(void)
 		}
 	}

-	if (cechotimer > 0)
-		--cechotimer;
+	if (cechotimer > 0) --cechotimer;

 	// Animate the desynch dots
 	if (hu_resynching
@@ -1004,12 +1149,10 @@ 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 < chatlength; i++) // iterate through message and eradicate all spaces that don't belong.
+	for (; i < strlen(w_chat_buf); 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.

@@ -1018,7 +1161,6 @@ static boolean HU_clearChatSpaces(void)
 			nothingbutspaces = false;
 		}
 	}
-
 	return nothingbutspaces;
 }

@@ -1065,11 +1207,11 @@ static void HU_SendChatMessage(void)
 		return;
 	}

-	const size_t msglength = strlen(msg);
+	size_t len = strlen(msg);

-	if (msglength >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
+	if (len >= 5 && strnicmp(msg, "/mute", 5) == 0) // Used /mute
 	{
-		if (msglength > 6)
+		if (len > 6)
 			DoMute(msg+6);
 		else
 			HU_AddChatText("\x82NOTICE: \x80Usage: /mute <name|node>", false);
@@ -1077,13 +1219,11 @@ static void HU_SendChatMessage(void)
 		return;
 	}

-	if (msglength > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
+	if (len > 4 && strnicmp(msg, "/pm", 3) == 0) // used /pm
 	{
 		INT32 spc = 1; // used if nodenum[1] is a space.
 		const char *newmsg;
-		CLEANUP(pfree) char *nodenum = (char*)malloc(3);
-		if (!nodenum)
-			I_Error("HU_SendChatMessage: out of memory for sending pm\n");
+		CLEANUP(pfree) char *nodenum = (char*) malloc(3);

 		// what we're gonna do now is check if the node exists
 		// with that logic, characters 4 and 5 are our numbers:
@@ -1337,7 +1477,6 @@ static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 			x = 0;
 		}
 	}
-
 	return newstring;
 }

@@ -1376,7 +1515,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
 			{
@@ -1408,25 +1547,24 @@ 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;
-		Z_Free(msg);
+		if (msg)
+			Z_Free(msg);
 	}

 	y = chaty - charheight*(msglines+1);

+#ifdef NETSPLITSCREEN
 	if (splitscreen)
 	{
 		y -= BASEVIDHEIGHT/2;
@@ -1434,6 +1572,7 @@ static void HU_drawMiniChat(void)
 			y += 16;
 	}
 	else
+#endif
 		y -= (cv_kartspeedometer.value ? 16 : 0);

 	dx = 0;
@@ -1452,7 +1591,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
 			{
@@ -1497,17 +1636,16 @@ static void HU_drawMiniChat(void)

 			dx += charwidth;
 			prev_linereturn = false;
-
 			if (dx >= boxw)
 			{
 				dx = 0;
 				dy += charheight;
 			}
 		}
-
 		dy += charheight;
 		dx = 0;
-		Z_Free(msg);
+		if (msg)
+			Z_Free(msg);
 	}

 	// decrement addy and make that shit smooth:
@@ -1531,15 +1669,18 @@ static void HU_drawChatLog(INT32 offset)
 	if (chat_scroll > chat_maxscroll)
 		chat_scroll = chat_maxscroll;

+#ifdef NETSPLITSCREEN
 	if (splitscreen)
 	{
 		boxh = max(6, boxh/2);
 		if (splitscreen > 1)
 			boxw = max(64, boxw/2);
 	}
+#endif

 	y = chaty - offset*charheight - (chat_scroll*charheight) - boxh*charheight - 12;

+#ifdef NETSPLITSCREEN
 	if (splitscreen)
 	{
 		y -= BASEVIDHEIGHT/2;
@@ -1547,6 +1688,7 @@ static void HU_drawChatLog(INT32 offset)
 			y += 16;
 	}
 	else
+#endif
 		y -= (cv_kartspeedometer.value ? 16 : 0);


@@ -1555,7 +1697,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;
@@ -1564,7 +1706,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
 			{
@@ -1609,10 +1751,10 @@ static void HU_drawChatLog(INT32 offset)
 				dy += charheight;
 			}
 		}
-
 		dy += charheight;
 		dx = 0;
-		Z_Free(msg);
+		if (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.
@@ -1655,12 +1797,12 @@ 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;
 	const char *mute = "Chat has been muted.";

+#ifdef NETSPLITSCREEN
 	if (splitscreen)
 	{
 		y -= BASEVIDHEIGHT/2;
@@ -1671,6 +1813,7 @@ static void HU_DrawChat(void)
 		}
 	}
 	else
+#endif
 		y -= (cv_kartspeedometer.value ? 16 : 0);

 	if (teamtalk)
@@ -1765,13 +1908,71 @@ static void HU_DrawChat(void)
 		}
 	}

+	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
+	{
+		emote_t *suggest;
+		int skip = 0;
+
+		const char *complete;
+		int complete_len;
+
+		if (emote_autocomplete.complete[0])
+		{
+			complete = emote_autocomplete.complete;
+			complete_len = strlen(complete);
+		}
+		else
+		{
+			complete = &w_chat_buf[emote_autocomplete.emotestart];
+			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
+		}
+
+		// A bit of copy-paste from /pm code :p
+		INT32 suggesty = chaty - charheight - 1;
+		size_t longest_suggestion_length = 0;
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
+			++skip;
+		}
+
+		skip = 0;
+
+#ifdef NETSPLITSCREEN
+		if (splitscreen)
+		{
+			suggesty -= BASEVIDHEIGHT/2;
+			if (splitscreen > 1)
+				suggesty += 16;
+		}
+		else
+#endif
+			suggesty -= (cv_kartspeedometer.value ? 16 : 0);
+
+		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
+		{
+			V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*skip), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			// Highlight currently suggested emote
+			int hlflag = 0;
+			if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
+				hlflag = V_YELLOWMAP;
+
+			V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
+			M_DrawEmote(chatx + boxw + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
+
+			++skip;
+		}
+	}
+
 	// handle /pm list. It's messy, horrible and I don't care.
 	if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
 	{
 		INT32 count = 0;
 		INT32 p_dispy = chaty - charheight - 1;
 		size_t longest_name_length = 0;
-
+#ifdef NETSPLITSCREEN
 		if (splitscreen)
 		{
 			p_dispy -= BASEVIDHEIGHT/2;
@@ -1779,18 +1980,18 @@ static void HU_DrawChat(void)
 				p_dispy += 16;
 		}
 		else
+#endif
 			p_dispy -= (cv_kartspeedometer.value ? 16 : 0);

 		// Find longest player name, for drawing background for /pm list later
 		for (i = 0; i < MAXPLAYERS; i++)
 		{
-			if (!playeringame[i])
-				continue;
+			if (!playeringame[i]) continue;

 			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;
@@ -1845,72 +2046,9 @@ static void HU_DrawChat(void)

 		if (count == 0) // no results.
 		{
-			pm_offset = 48 + 2;
 			V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
 			V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
 		}
-		else
-		{
-			pm_offset = (longest_name_length+4)*4 + 2;
-		}
-	}
-
-	if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
-	{
-		emote_t *suggest;
-		int skip = 0;
-
-		const char *complete;
-		int complete_len;
-
-		if (emote_autocomplete.complete[0])
-		{
-			complete = emote_autocomplete.complete;
-			complete_len = strlen(complete);
-		}
-		else
-		{
-			complete = &w_chat_buf[emote_autocomplete.emotestart];
-			complete_len = w_chat.cursor - emote_autocomplete.emotestart;
-		}
-
-		// A bit of copy-paste from /pm code :p
-		INT32 suggesty = chaty - charheight - 1;
-		size_t longest_suggestion_length = 0;
-
-		while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
-		{
-			longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
-			++skip;
-		}
-
-		INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
-
-		skip = 0;
-
-		if (splitscreen)
-		{
-			suggesty -= BASEVIDHEIGHT/2;
-			if (splitscreen > 1)
-				suggesty += 16;
-		}
-		else
-			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.
@@ -42,6 +42,15 @@
 #define CRED_FONTEND 'Z' // the last font character
 #define CRED_FONTSIZE (CRED_FONTEND - CRED_FONTSTART + 1)

+extern char *shiftxform; // english translation shift table
+extern char english_shiftxform[];
+
+extern char french_shiftxform[];
+extern char french_altgrxform[];
+
+//fallback for special letter non displayable in the game (i.e.: 'é','à',etc.)
+INT32 HU_FallBackFrSpecialLetter(INT32 key);
+
 //------------------------------------
 //        sorted player lines
 //------------------------------------
@@ -59,7 +68,12 @@ typedef struct
 #define HU_MAXMSGLEN 223
 #define HU_MSGBUFSIZE 255
 #define MAX_CHAT_BUFSIZE 256		// that's enough messages, right? We'll delete the older ones when that gets out of hand.
+#define NETSPLITSCREEN // why the hell WOULDN'T we want this?
+#ifdef NETSPLITSCREEN
 #define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
+#else
+#define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
+#endif
 #define CHAT_MUTE (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))	// this still allows to open the chat but not to type. That's used for scrolling and whatnot.
 #define OLD_MUTE (OLDCHAT && cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))	// this is used to prevent oldchat from opening when muted.

@@ -96,6 +110,8 @@ void HU_LoadGraphics(void);
 // reset heads up when consoleplayer respawns.
 void HU_Start(void);

+void HU_Shiftform(void);
+
 boolean HU_Responder(event_t *ev);
 void HU_Ticker(void);
 void HU_TickSongCredits(void);
@@ -104,6 +120,8 @@ void HU_Drawer(void);
 char HU_dequeueChatChar(void);
 void HU_clearChatChars(void);
 void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags);	// Lat': Ping drawer for scoreboard.
+//void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer);
+//void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
 void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 hilicol);
 void HU_DrawEmeralds(INT32 x, INT32 y, INT32 pemeralds);
 const char *HU_SkinColorToConsoleColor(skincolors_t color);
@@ -44,6 +44,9 @@ extern "C" {

 struct JoyType_s
 {
+	/*! if true, we MUST Poll() to get new joystick data,
+	that is: we NEED the DIRECTINPUTDEVICE2 ! (watchout NT compatibility) */
+	INT32 bJoyNeedPoll;
 	/*! this joystick is a gamepad, read: digital axes
 	if FALSE, interpret the joystick event data as JOYAXISRANGE (see above) */
 	INT32 bGamepadStyle;
@@ -29,10 +29,6 @@ extern "C" {
 */
 #define MAX_QUIT_FUNCS     16

-void I_GetConsoleEvents(void);
-
-extern boolean consolevent;
-extern boolean framebuffer;

 /**	\brief Graphic system had started up
 */
@@ -43,7 +39,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;

 /** \brief Set to true when inside a signal handler that will exit the program. */
-boolean I_In_Exiting_Signal_Handler(void);
+extern boolean g_in_exiting_signal_handler;

 /**	\brief	The I_GetFreeMem function

@@ -148,11 +144,6 @@ extern INT32 numcontrollers;
 */
 const char *I_GetJoyName(INT32 joyindex);

-void I_SetJoystickFocus(void);
-
-boolean I_GamepadHasLED(INT32 playernum);
-boolean I_GamepadHasRumble(INT32 playernum);
-
 void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
 void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue);

@@ -200,10 +191,6 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);

-/**	\brief To check if a Interrupt or Terminate Signal was fired
- */
-boolean I_Interrupted(void);
-
 /**	\brief	The I_GetDiskFreeSpace function

 	\param	freespace	a INT64 pointer to hold the free space amount
@@ -392,9 +392,6 @@ static const char *SOCK_GetNodeAddress(INT32 node)
 	if (node == 0)
 		return "self";

-	if (node < 0 || node > MAXNETNODES)
-		return NULL;
-
 	if (!nodeconnected[node])
 		return NULL;

@@ -499,10 +496,8 @@ static void cleanupnodes(void)

 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
-	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
-	}
 }

 static SINT8 getfreenode(void)
@@ -512,13 +507,11 @@ static SINT8 getfreenode(void)
 	cleanupnodes();

 	for (j = 0; j < MAXNETNODES; j++)
-	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
-	}

 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -819,7 +812,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (numnode <= 0 || numnode > MAXNETNODES)
+	if (!numnode || numnode > MAXNETNODES)
 		return;

 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1439,12 +1432,14 @@ static void SOCK_RegisterHolePunch(void)

 static boolean SOCK_OpenSocket(void)
 {
-	memset(clientaddress, 0, sizeof(clientaddress));
+	size_t i;
+
+	memset(clientaddress, 0, sizeof (clientaddress));

-	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
+	for (i = 1; i < MAXNETNODES; i++)
+		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
-
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1484,7 +1479,7 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;

-	if (node < 0 || node > MAXNETNODES)
+	if (node > MAXNETNODES)
 		return false;

 	ban = numbans;
@@ -1515,8 +1510,11 @@ static boolean SOCK_SetBanUsername(const char *username)
 		username = "Direct IP ban";
 	}

-	Z_Free(banned[numbans - 1].username);
-	banned[numbans - 1].username = NULL;
+	if (banned[numbans - 1].username)
+	{
+		Z_Free(banned[numbans - 1].username);
+		banned[numbans - 1].username = NULL;
+	}

 	banned[numbans - 1].username = Z_StrDup(username);

@@ -1530,8 +1528,11 @@ static boolean SOCK_SetBanReason(const char *reason)
 		reason = "No reason given";
 	}

-	Z_Free(banned[numbans - 1].reason);
-	banned[numbans - 1].reason = NULL;
+	if (banned[numbans - 1].reason)
+	{
+		Z_Free(banned[numbans - 1].reason);
+		banned[numbans - 1].reason = NULL;
+	}

 	banned[numbans - 1].reason = Z_StrDup(reason);

@@ -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};
@@ -125,6 +125,8 @@ boolean I_CheckNativeRes(void);

 void I_SetBorderlessWindow(void);

+void I_HandleControllerHatRepeat(void);
+
 #ifdef USE_FBO_OGL

 void RefreshOGLSDLSurface(void);
@@ -133,15 +135,6 @@ 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
@@ -19,8 +19,6 @@
 #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!!

@@ -446,12 +446,6 @@ void K_UpdateDirector(void)
 			}
 		}

-		// not sure if we should just stop here?
-		if (targetposition == MAXPLAYERS)
-		{
-			break;
-		}
-
 		target = directorinfo.sortedplayers[targetposition];

 		// stop here since we're already viewing this player
@@ -83,7 +83,6 @@ IMPL_HUD_OFFSET(stat);   // Stats

 // extra hud things
 consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_showstats_skinname = {"showstats_skinname", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};

 consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead

@@ -93,7 +92,6 @@ consvar_t cv_showinput = {"showinput", "Off", CV_SAVE, inputdisplay_cons_t, NULL
 static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}};
 consvar_t cv_minihead         = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_showminimapfinished = {"showminimapfinished", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};

 CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF];
 consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -209,7 +207,6 @@ void K_RegisterKartHudStuff(void)
 	CV_RegisterVar(&cv_kartspeedometer);

 	CV_RegisterVar(&cv_showstats);
-	CV_RegisterVar(&cv_showstats_skinname);
 	CV_RegisterVar(&cv_showinput);

 	CV_RegisterVar(&cv_posanim);
@@ -224,7 +221,6 @@ void K_RegisterKartHudStuff(void)

 	CV_RegisterVar(&cv_minihead);
 	CV_RegisterVar(&cv_showminimapnames);
-	CV_RegisterVar(&cv_showminimapfinished);
 	CV_RegisterVar(&cv_showminimapangle);

 	CV_RegisterVar(&cv_showlapemblem);
@@ -274,6 +270,7 @@ void K_RegisterKartHudStuff(void)

 // Smol speedo
 static patch_t *skp_smallsticker    = NULL;
+static patch_t *skp_smallsticker3   = NULL;

 static patch_t *skp_speedpatches[5] = {NULL};

@@ -311,6 +308,7 @@ static patch_t *kp_bumperstickerwideclr  =  NULL;
 static patch_t *kp_karmastickerclr       =  NULL;
 static patch_t *kp_timeoutstickerclr     =  NULL;
 static patch_t *skp_smallstickerclr      =  NULL;
+static patch_t *skp_smallstickerclr3     =  NULL;
 static patch_t *kp_itemmulstickerclr[2]  = {NULL};
 static patch_t *kp_itembgclr[4]          = {NULL};

@@ -476,6 +474,11 @@ static void K_LoadSaturnHUDGraphics(void)
 			skp_smallstickerclr = (patch_t *)W_CachePatchName("SC_SMSTC", PU_HUDGFX);
 		}

+		if (xtra_speedo_clr3)
+		{
+			skp_smallstickerclr3 = (patch_t *)W_CachePatchName("SC_SM3TC", PU_HUDGFX);
+		}
+
 		if (achi_speedo_clr)
 		{
 			skp_smallstickerachiclr    = (patch_t *)W_CachePatchName("SC_AMSTC", PU_HUDGFX);
@@ -530,6 +533,14 @@ static void K_LoadSaturnHUDGraphics(void)
 			kp_itemmulstickerclr[0] = (patch_t *)W_CachePatchName("K_ITMULC", PU_HUDGFX);
 		}
 	}
+
+	if (found_extra3_kart)
+	{
+		if (xtra_speedo3) // 80x11 patch scaled to size
+		{
+			skp_smallsticker3 = (patch_t *)W_CachePatchName("SP_SM3TC", PU_HUDGFX);
+		}
+	}
 }

 // -- Kart patches --
@@ -557,7 +568,7 @@ static patch_t *kp_racefinish[6];
 static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES];
 static patch_t *kp_winnernum[NUMPOSFRAMES];

-patch_t *kp_facenum[MAXPLAYERS+1] = {};
+patch_t *kp_facenum[MAXPLAYERS+1];
 static patch_t *kp_facehighlight[8];

 static patch_t *kp_rankbumper;
@@ -864,7 +875,7 @@ void K_LoadKartHUDGraphics(void)

 	kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX);

-	if (found_extra_kart || found_extra2_kart)
+	if (found_extra_kart || found_extra2_kart || found_extra3_kart)
 		K_LoadSaturnHUDGraphics();
 }

@@ -920,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)

 //}

-static INT32 ITEM_X, ITEM_Y;	// Item Window
-static INT32 TIME_X, TIME_Y;	// Time Sticker
-static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-static INT32 SPDM_X, SPDM_Y;	// Speedometer
-static INT32 POSI_X, POSI_Y;	// Position Number
-static INT32 FACE_X, FACE_Y;	// Top-four Faces
-static INT32 STCD_X, STCD_Y;	// Starting countdown
-static INT32 CHEK_Y;			// CHECK graphic
-static INT32 MINI_X, MINI_Y;	// Minimap
-static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+INT32 ITEM_X, ITEM_Y;	// Item Window
+INT32 TIME_X, TIME_Y;	// Time Sticker
+INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+INT32 SPDM_X, SPDM_Y;	// Speedometer
+INT32 POSI_X, POSI_Y;	// Position Number
+INT32 FACE_X, FACE_Y;	// Top-four Faces
+INT32 STCD_X, STCD_Y;	// Starting countdown
+INT32 CHEK_Y;			// CHECK graphic
+INT32 MINI_X, MINI_Y;	// Minimap
+INT32 WANT_X, WANT_Y;	// Battle WANTED poster

 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-static INT32 ITEM2_X, ITEM2_Y;
-static INT32 LAPS2_X, LAPS2_Y;
-static INT32 POSI2_X, POSI2_Y;
+INT32 ITEM2_X, ITEM2_Y;
+INT32 LAPS2_X, LAPS2_Y;
+INT32 POSI2_X, POSI2_Y;

 static void K_initKartHUD(void)
 {
@@ -1054,7 +1065,7 @@ static void K_initKartHUD(void)
 	}

 	if (timeinmap > 113 || forceshowhud)
-		hudtrans = (UINT8)cv_translucenthud.value;
+		hudtrans = cv_translucenthud.value;
 	else if (timeinmap > 105)
 		hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105);
 	else
@@ -1111,9 +1122,9 @@ void K_KartPlayerHUDUpdate(player_t *player)
 UINT8 K_GetHudColor(void)
 {
 	if (cv_colorizedhud.value && cv_colorizedhudcolor.value)
-		return (UINT8)cv_colorizedhudcolor.value;
+		return cv_colorizedhudcolor.value;

-	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : (UINT8)cv_playercolor.value);
+	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value);
 }

 boolean K_UseColorHud(void)
@@ -1134,6 +1145,7 @@ enum
 	SPEEDO_DIAL,
 	SPEEDO_PMETER,
 	SPEEDO_PMETERSMOL,
+	SPEEDO_EXTRA3,
 };

 static SINT8 K_GetSpeedometerStyle(void)
@@ -1148,6 +1160,8 @@ static SINT8 K_GetSpeedometerStyle(void)
 		return SPEEDO_PMETER;
 	else if (cv_newspeedometer.value == 6 && kartz_speedo_smol)
 		return SPEEDO_PMETERSMOL;
+	else if (cv_newspeedometer.value == 7 && xtra_speedo3)
+		return SPEEDO_EXTRA3;
 	else
 		return SPEEDO_VANILLA;
 }
@@ -1165,6 +1179,8 @@ static boolean K_UseColorSpeedo(int speedostyle)
 			return achi_speedo_clr;
 		case SPEEDO_DIAL:
 			return dial_speedo_clr;
+		case SPEEDO_EXTRA3:
+			return xtra_speedo_clr3;
 		default:
 			return false;
 	}
@@ -1176,6 +1192,7 @@ enum
 	GAUGE_SMALL,
 	GAUGE_BIGNUM,
 	GAUGE_NUMONLY,
+	GAUGE_EXTRA,
 };

 static SINT8 K_GetDriftgaugeStyle(void)
@@ -1188,6 +1205,8 @@ static SINT8 K_GetDriftgaugeStyle(void)
 			return GAUGE_SMALL;
 		else if (cv_driftgaugestyle.value == 3)
 			return GAUGE_BIGNUM;
+		else if (cv_driftgaugestyle.value == 5 && xtra_speedo3)
+			return GAUGE_EXTRA;
 	}

 	// Fallback
@@ -1339,12 +1358,10 @@ INT32 K_getMinimapTrans(void)
 		return -1;

 	if (timeinmap <= 113)
-	{
 		minimaptrans = ((((INT32)timeinmap) - 105)*minimaptrans)/(113-105);

-		if (!minimaptrans)
-			return -1;
-	}
+	if (!minimaptrans)
+		return -1;

 	return (10-minimaptrans)<<FF_TRANSSHIFT;
 }
@@ -1386,6 +1403,7 @@ static void K_drawKartStats(void)
 		{
 			case SPEEDO_EXTRA:
 			case SPEEDO_ACHII:
+			case SPEEDO_EXTRA3:
 				spdoffset = -10;
 				break;
 			case SPEEDO_DIAL:
@@ -1397,6 +1415,8 @@ static void K_drawKartStats(void)
 				break;
 		}
 	}
+	else
+		spdoffset = 0;

 	if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
 		spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
@@ -1416,16 +1436,13 @@ static void K_drawKartStats(void)
 		fakeskin = K_GetPlayerSkin(stplyr);

 		// Skin name
-		if (cv_showstats_skinname.value)
+		if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
 		{
-			if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
-			{
-				V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
-			}
-			else
-			{
-				V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
-			}
+			V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
+		}
+		else
+		{
+			V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
 		}

 		// Icon and stats
@@ -1509,7 +1526,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
@@ -2079,7 +2096,7 @@ static void K_DrawKartPositionNum(INT32 num)
 			fy = POSI_Y;
 			fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0);	// flip P3 to the bottom.
 			flipdraw = true;
-			if (num >= 10)
+			if (num && num >= 10)
 				fx += W;	// this seems dumb, but we need to do this in order for positions above 10 going off screen.
 		}
 		else // else, that means we're P2 or P4.
@@ -2161,9 +2178,8 @@ static boolean K_drawKartPositionFaces(void)
 	UINT8 *colormap;

 	ranklines = 0;
-
-	if (!LUA_HudEnabled(hud_minirankings))
-		return false; // Don't proceed but still return true for free play above if HUD is disabled.
+	memset(completed, 0, sizeof (completed));
+	memset(rankplayer, 0, sizeof (rankplayer));

 	for (i = 0; i < MAXPLAYERS; i++)
 	{
@@ -2178,7 +2194,8 @@ static boolean K_drawKartPositionFaces(void)
 	if (numplayersingame <= 1)
 		return true;

-	memset(completed, 0, sizeof (completed));
+	if (!LUA_HudEnabled(hud_minirankings))
+		return false;	// Don't proceed but still return true for free play above if HUD is disabled.

 	for (j = 0; j < numplayersingame; j++)
 	{
@@ -2235,7 +2252,6 @@ static boolean K_drawKartPositionFaces(void)

 		if (!playeringame[rankplayer[i]])
 			continue;
-
 		if (player->spectator || !player->mo)
 			continue;

@@ -2413,7 +2429,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I

 static boolean K_BigLap(void)
 {
-	return (cv_biglaps.value && (cv_numlaps.value > 9) && !stplyr->exiting && (K_UseColorHud() ? big_lap_color : big_lap));
+	return (cv_biglaps.value && (cv_numlaps.value > 9) && (K_UseColorHud() ? big_lap_color : big_lap) && (!stplyr->exiting));
 }

 static void K_drawKartLaps(void)
@@ -2622,7 +2638,7 @@ static void K_drawKartSpeedometer(void)
 		return;

 	// index 0 is the raw value, index 1 is the converted value
-	fixed_t convSpeed[2] = {0, 0};
+	fixed_t convSpeed[2] = {0,0};
 #ifdef ROTSPRITE
 	fixed_t dial_divisor = DIALSPDDIV;
 #endif
@@ -2691,28 +2707,34 @@ static void K_drawKartSpeedometer(void)

 		V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric);
 	}
-	else if (speedostyle == SPEEDO_EXTRA || speedostyle == SPEEDO_ACHII) // why bother if we dont?
+	else if (speedostyle == SPEEDO_EXTRA) // why bother if we dont?
 	{
-		patch_t *speedopat;
-		UINT8 *colormap = NULL;
-
-		if (K_UseColorSpeedo(speedostyle)) //Colourized hud
+		if (K_UseColorSpeedo(SPEEDO_EXTRA)) //Colourized hud
 		{
-			colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+			UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+			V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerclr, colormap);
+		}
+		else
+			V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallsticker);

-			speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_smallstickerclr : skp_smallstickerachiclr);
-			V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat, colormap);
-			speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_speedpatches[cv_kartspeedometer.value] : skp_speedpatchesachiclr[cv_kartspeedometer.value]);
+		V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
+		V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]);
+	}
+	else if (speedostyle == SPEEDO_ACHII) // why bother if we dont?
+	{
+		if (K_UseColorSpeedo(SPEEDO_ACHII)) //Colourized hud
+		{
+			UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+			V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachiclr, colormap);
+			V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
+			V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachiclr[cv_kartspeedometer.value], colormap);
 		}
 		else
 		{
-			speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_smallsticker : skp_smallstickerachi);
-			V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat);
-			speedopat = ((speedostyle == SPEEDO_EXTRA) ? skp_speedpatches[cv_kartspeedometer.value] : skp_speedpatchesachi[cv_kartspeedometer.value]);
+			V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerachi);
+			V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
+			V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatchesachi[cv_kartspeedometer.value]);
 		}
-
-		V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
-		V_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat, colormap);
 	}
 #ifdef ROTSPRITE
 	else if (speedostyle == SPEEDO_DIAL)  // why bother if we dont?
@@ -2725,36 +2747,46 @@ static void K_drawKartSpeedometer(void)
 							(K_UseColorSpeedo(SPEEDO_DIAL)));
 	}
 #endif
+	else if (speedostyle == SPEEDO_EXTRA3) // why bother if we dont?
+	{
+		if (K_UseColorSpeedo(SPEEDO_EXTRA3)) //Colourized hud
+		{
+			UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+			V_DrawStretchyFixedPatch((SPDM_X-1)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallstickerclr3, colormap, 0);
+		}
+		else
+			V_DrawStretchyFixedPatch((SPDM_X-1)<<FRACBITS, (SPDM_Y + 5)<<FRACBITS, XTRA3PSCALE, XTRA3VSCALE, V_HUDTRANS|splitflags, skp_smallsticker3, NULL, 0);
+
+		V_DrawRankNum(SPDM_X + 26, SPDM_Y + 4, V_HUDTRANS|splitflags, convSpeed[1], 3, NULL);
+		V_DrawScaledPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_speedpatches[cv_kartspeedometer.value]);
+	}
 	// Kart Z speedo bullshit...
 	// Draw the Speed counter.
 	else if ((speedostyle == SPEEDO_PMETER) || (speedostyle == SPEEDO_PMETERSMOL))
 	{
+		fixed_t fuspeed = 0;
 		INT32 spdpatch = 0;
-		static const INT32 spdinterval[22] = { 2,  5,  7, 10,
-											  12, 15, 17, 20,
-											  22, 25, 27, 30,
-											  32, 35, 37, 40,
-											  42, 45, 47, 50,
-											  52, 55};
+		static const INT32 speedIntervals[22] = {2, 5, 7, 10, 12, 15, 17,
+												20, 22, 25, 27, 30, 32,
+												35, 37, 40, 42, 45, 47,
+												50, 52, 55};

-		const fixed_t spd = FixedDiv(stplyr->speed, mapobjectscale) / FRACUNIT;
+		fuspeed = FixedDiv(stplyr->speed, mapobjectscale)/FRACUNIT;

-		if (spd > 54)
+		for (INT32 i = 0; i < 22; ++i)
 		{
-			spdpatch = (leveltime & 4) ? 24 : 23;
-		}
-		else
-		{
-			for (INT32 i = 0; i < 22; ++i)
+			if (fuspeed < speedIntervals[i])
 			{
-				if (spd < spdinterval[i])
-				{
-					spdpatch = i;
-					break;
-				}
+				spdpatch = i;
+				break;
 			}
 		}

+		if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && (leveltime & 4))
+			spdpatch = 24;
+		else if (((fuspeed < 57 && fuspeed > 54) || (fuspeed < 60 && fuspeed > 56) || (fuspeed > 59)) && !(leveltime & 4))
+			spdpatch = 23;
+
 		V_DrawScaledPatch(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, (speedostyle == SPEEDO_PMETER) ? kp_kartzspeedo[spdpatch] : kp_kartzspeedo_smol[spdpatch]);
 	}
 }
@@ -2782,7 +2814,7 @@ static void K_drawKartBumpersOrKarma(void)
 	{
 		const UINT8 speedostyle = K_GetSpeedometerStyle();

-		if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII))
+		if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII) || (speedostyle == SPEEDO_EXTRA3))
 			fy += 5;
 		else
 			fy += 7;
@@ -2874,12 +2906,10 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
 	x = (fixed_t)(viewangle - R_PointToAngle(targx, targy));

 	distfact = FINECOSINE((x>>ANGLETOFINESHIFT) & FINEMASK);
-    if (!distfact)
-		distfact = 1;
+    if (!distfact) distfact = 1;

 	if (encoremode)
 		x = -x;
-
 	if (x < (fixed_t)ANGLE_270 || x > (fixed_t)ANGLE_90)
 		return false;

@@ -2961,7 +2991,7 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
 		if (stplyrnum > 0)
 			y = y + yres;
 	}
-	else if (splitscreen >= 2) // 3P or 4P
+	if (splitscreen >= 2) // 3P or 4P
 	{
 		x = x>>1;
 		y = y>>1;
@@ -3021,11 +3051,9 @@ static void K_drawNameTags(void)
 		if (players[i].kartstuff[k_hyudorotimer]) // player is invisible
 			continue;
 		if (maxdistance)
-		{
 			distance = R_PointToDist(players[i].mo->x, players[i].mo->y);
-			if (distance > maxdistance)
-				continue;
-		}
+		if (distance > maxdistance)
+			continue;
 		if (!P_CheckSightFast(stplyr->mo, players[i].mo))
 			continue;

@@ -3234,12 +3262,13 @@ static void K_drawDriftGauge(void)
 	if (!splitscreen && !camera->chase)
 		return;

-	// i will skip the drift early return and you cant stop me!
-	if (!forceshowhud)
-	{
-		if (!stplyr->kartstuff[k_drift])
-			return;
-	}
+	if (forceshowhud)
+		goto skipcrap; // i will skip the drift early return and you cant stop me!
+
+	if (!stplyr->kartstuff[k_drift])
+		return;
+
+skipcrap:

 	if (P_MobjWasRemoved(stplyr->mo))
 		return;
@@ -3264,11 +3293,12 @@ static void K_drawDriftGauge(void)
 	{
 		case GAUGE_DEFAULT:
 		case GAUGE_SMALL:
+		case GAUGE_EXTRA:
 		case GAUGE_BIGNUM:
 			{
 				patch_t *driftpatch = NULL;

-				if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM)
+				if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM || gaugestyle == GAUGE_EXTRA)
 				{
 					barx = basex - vid.dup*23;
 					BAR_WIDTH = vid.dup*47;
@@ -3281,15 +3311,30 @@ static void K_drawDriftGauge(void)

 				bary = basey - vid.dup*2;

-				if (K_UseColorHud()) // Colourized hud
+				if (gaugestyle == GAUGE_EXTRA) // i hate hud code i hate hud code i hate hud code i hate hud code i hate hud code.....
 				{
-					colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
-					driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
+					if (K_UseColorSpeedo(SPEEDO_EXTRA3)) // We reuse the extra speedometer patch hence this check
+					{
+						colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+						driftpatch = skp_smallstickerclr3;
+					}
+					else
+						driftpatch = skp_smallsticker3;
+
+					V_DrawStretchyFixedPatch((basex - vid.dup*30)<<FRACBITS, ((basey<<FRACBITS) - FixedMul(vid.dup<<FRACBITS, 21*FRACUNIT/10)), XTRA3PSCALE, XTRA3VSCALE, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap, 0);
 				}
 				else
-					driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmall : driftgauge);
+				{
+					if (K_UseColorHud()) // Colourized hud
+					{
+						colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+						driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
+					}
+					else
+						driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmall : driftgauge);

-				V_DrawMappedPatch(gaugestyle == GAUGE_SMALL ? basex + vid.dup*11 : basex, basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap);
+					V_DrawMappedPatch(gaugestyle == GAUGE_SMALL ? basex + vid.dup*11 : basex, basey, V_NOSCALESTART|V_OFFSET|drifttrans, driftpatch, colormap);
+				}

 				if (driftcharge >= driftval*4) // rainbow sparks
 				{
@@ -3587,7 +3632,7 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
 		V_DrawCenteredSmallStringAtFixed(amxpos + (4*FRACUNIT), amypos - (3*FRACUNIT), V_ALLOWLOWERCASE|flags|V_SkinColorToHighlightcolor(mo->color), player_names[player - players]);
 	}

-	const boolean minihead = K_useSmallMinimapHead(player);
+	const boolean minihead = K_useSmallMinimapHead(mo->player);

 	// thx wanted reticle for having weird offsets very cool
 	wntdamxpos = minihead ? amxpos + (1<<FRACBITS) : amxpos - (4<<FRACBITS);
@@ -3729,9 +3774,6 @@ static void K_drawKartMinimap(void)
 			if (!players[i].mo || players[i].spectator)
 				continue;

-			if (!cv_showminimapfinished.value && players[i].exiting)
-				continue;
-
 			if (P_IsDisplayPlayer(&players[i]))
 			{
 				// Draw display players on top of everything else
@@ -3776,7 +3818,7 @@ static void K_drawKartMinimap(void)

 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap = NULL;
+			UINT8 *colormap;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3787,27 +3829,10 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;

-			if (mobj->color)
-			{
-				if (mobj->colorized)
-				{
-					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-				}
-				else
-				{
-					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
-
-					// special case if startcolor is not the default (160 / Green)
-					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
-					{
-						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
-					}
-					else
-					{
-						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
-					}
-				}
-			}
+			if (mobj->colorized)
+				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+			else
+				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);

 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);
@@ -3972,7 +3997,6 @@ static void K_drawBattleFullscreen(void)
 	{
 		if (stplyrnum == 0)
 			V_DrawFadeScreen(0xFF00, 16);
-
 		if (stplyr->exiting < 6*TICRATE && !stplyr->spectator)
 		{
 			if (stplyr->kartstuff[k_position] == 1)
@@ -4037,7 +4061,7 @@ static void K_drawBattleFullscreen(void)
 		{
 			if (i == displayplayers[0])
 				continue;
-			if (playeringame[i])
+			if (playeringame[i] && !stplyr->spectator)
 				return;
 		}

@@ -4288,7 +4312,7 @@ static void K_drawInput(void)
 		}
 		else
 		{
-			const boolean analogjoystickmove  = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle;
+			const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle;
 			const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle;
 			const UINT8 ssplayer = stplyrnum+1;

@@ -4305,10 +4329,9 @@ static void K_drawInput(void)
 				{
 					hudforward += KART_FULLTURN;
 				}
-
 				if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0))
 				{
-					hudforward -= KART_FULLTURN;
+					hudforward-= KART_FULLTURN;
 				}
 			}

@@ -4394,7 +4417,6 @@ static void K_drawChallengerScreen(void)
 		19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact
 		21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold
 	};
-
 	const UINT8 offset = min(52-1, (3*TICRATE)-mapreset);

 	V_DrawFadeScreen(0xFF00, 16); // Fade out
@@ -4446,9 +4468,7 @@ 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);
-		const size_t laplength = strlen(lapnum);
-
-		for (size_t i = 0; i < laplength; i++)
+		for (int i = 0; i < (int)strlen(lapnum); i++)
 		{
 			int digit = lapnum[i] - '0';
 			int frame = min(2, progress/2 - 8 - (i*2));
@@ -4496,7 +4516,6 @@ static void K_drawDistributionDebugger(void)
 		kp_orbinaut[4],
 		kp_jawz[1]
 	};
-
 	INT32 useodds = 0;
 	INT32 pingame = 0, bestbumper = 0;
 	INT32 i;
@@ -4513,10 +4532,8 @@ static void K_drawDistributionDebugger(void)
 		if (!playeringame[i] || players[i].spectator)
 			continue;
 		pingame++;
-
 		if (players[i].exiting)
 			dontforcespb = true;
-
 		if (players[i].kartstuff[k_bumper] > bestbumper)
 			bestbumper = players[i].kartstuff[k_bumper];
 	}
@@ -4670,7 +4687,6 @@ void K_drawKartHUD(void)
 	{
 		if (LUA_HudEnabled(hud_battlefullscreen))
 			K_drawBattleFullscreen();
-
 		return;
 	}

@@ -35,7 +35,6 @@ extern consvar_t cv_darkitembox;
 extern consvar_t cv_biglaps;
 extern consvar_t cv_highresportrait;
 extern consvar_t cv_showstats;
-extern consvar_t cv_showstats_skinname;
 extern consvar_t cv_fancyroulette;
 extern consvar_t cv_showlaptimes;
 extern consvar_t cv_battlespeedo;
@@ -47,8 +47,6 @@ 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};
@@ -484,8 +482,7 @@ UINT8 colortranslations[MAXTRANSLATIONS][16] = {
 //
 UINT8 K_RainbowColor(void)
 {
-	const tic_t time = cv_reducevfx.value ? (leveltime >> 3) : leveltime;
-	return (UINT8)(1 + (time % (MAXSKINCOLORS-1)));
+	return (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1)));
 }

 // Define for getting accurate color brightness readings according to how the human eye sees them.
@@ -660,22 +657,13 @@ INT32 K_GetSkinNum(player_t *player)

 //
 // returns the mobj skinnumber
-// accounts for localskins ?
+// accounts for localskins
 //
 INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
 {
 	return skin - K_GetSkinArray(local);
 }

-//
-// returns the mobj skinnumber
-// accounts for localskins
-//
-INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
-{
-	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
-}
-
 //
 // returns the players skinnumber
 // accounts for localskins
@@ -776,8 +764,6 @@ void K_RegisterClientKartStuff(void)

 	CV_RegisterVar(&cv_playerblendeffects);

-	CV_RegisterVar(&cv_reducevfx);
-
 	CV_RegisterVar(&cv_saltyhop);
 	CV_RegisterVar(&cv_saltyhopsfx);
 	CV_RegisterVar(&cv_saltysquish);
@@ -1489,6 +1475,7 @@ void K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2, boolean bounce, boolean solid)
 		fixed_t nx = FixedDiv(distx, dist);
 		fixed_t ny = FixedDiv(disty, dist);

+		dist = dist ? dist : 1;
 		distx = FixedMul(mobj1->radius+mobj2->radius, nx);
 		disty = FixedMul(mobj1->radius+mobj2->radius, ny);

@@ -1600,78 +1587,57 @@ static UINT8 K_CheckOffroadCollide(mobj_t *mo)
 	sector_t *s2;		// FOF sector shortcut
 	ffloor_t *rover;	// FOF

-	fixed_t flr, cel; // floor & ceiling for height checks to make sure we're touching the offroad sector.
-	INT32 special;
+	fixed_t flr;
+	fixed_t cel;	// floor & ceiling for height checks to make sure we're touching the offroad sector.

+	I_Assert(mo != NULL);
 	I_Assert(!P_MobjWasRemoved(mo));

 	for (node = mo->touching_sectorlist; node; node = node->m_sectorlist_next)
 	{
 		if (!node->m_sector)
-			break; // shouldn't happen.
+			break;	// shouldn't happen.

 		s = node->m_sector;
-
 		// 1: Check for the main sector, make sure we're on the floor of that sector and see if we can apply offroad.
 		// Make arbitrary Z checks because we want to check for 1 sector in particular, we don't want to affect the player if the offroad sector is way below them and they're lineriding a normal sector above.

-		special = GETSECSPECIAL(s->special, 1);
-		for (i = 2; i < 5; i++) // check for sector special
-		{
-			if (special != i)
-				continue;
+		flr = P_MobjFloorZ(mo, s, s, mo->x, mo->y, NULL, false, true);
+		cel = P_MobjCeilingZ(mo, s, s, mo->x, mo->y, NULL, true, true);	// get Z coords of both floors and ceilings for this sector (this accounts for slopes properly.)
+		// NOTE: we don't use P_GetZAt with our x/y directly because the mobj won't have the same height because of its hitbox on the slope. Complex garbage but tldr it doesn't work.

-			if (s->flags & SF_FLIPSPECIAL_FLOOR)
-			{
-				flr = P_MobjFloorZ(mo, s, s, mo->x, mo->y, NULL, false, true);
-				if (mo->z == flr) // floor check
-					return i-1; // return offroad type
-			}
+		if ( ((s->flags & SF_FLIPSPECIAL_FLOOR) && mo->z == flr)	// floor check
+			|| ((mo->eflags & MFE_VERTICALFLIP && (s->flags & SF_FLIPSPECIAL_CEILING) && (mo->z + mo->height) == cel)) )	// ceiling check.

-			if (mo->eflags & MFE_VERTICALFLIP && (s->flags & SF_FLIPSPECIAL_CEILING))
-			{
-				cel = P_MobjCeilingZ(mo, s, s, mo->x, mo->y, NULL, true, true);
-				// NOTE: we don't use P_GetZAt with our x/y directly because the mobj won't have the same height because of its hitbox on the slope. Complex garbage but tldr it doesn't work.
-				if ((mo->z + mo->height) == cel) // ceiling check
-					return i-1; // return offroad type
-			}
-		}
+			for (i = 2; i < 5; i++)	// check for sector special
+
+				if (GETSECSPECIAL(s->special, 1) == i)
+					return i-1;	// return offroad type

 		// 2: If we're here, we haven't found anything. So let's try looking for FOFs in the sectors using the same logic.
 		for (rover = s->ffloors; rover; rover = rover->next)
 		{
-			if (!(rover->flags & FF_EXISTS)) // This FOF doesn't exist anymore.
+			if (!(rover->flags & FF_EXISTS))	// This FOF doesn't exist anymore.
 				continue;

-			s2 = &sectors[rover->secnum]; // makes things easier for us
+			s2 = &sectors[rover->secnum];	// makes things easier for us

-			special = GETSECSPECIAL(s2->special, 1);
-			for (i = 2; i < 5; i++) // check for sector special
-			{
-				if (special != i)
-					continue;
+			flr = P_GetFOFBottomZ(mo, s, rover, mo->x, mo->y, NULL);
+			cel = P_GetFOFTopZ(mo, s, rover, mo->x, mo->y, NULL);	// Z coords for fof top/bottom.

-				// we will do essentially the same checks as above instead of bothering with top/bottom height of the FOF.
-				// Reminder that an FOF's floor is its bottom, silly!
+			// we will do essentially the same checks as above instead of bothering with top/bottom height of the FOF.
+			// Reminder that an FOF's floor is its bottom, silly!
+			if (   ((s2->flags & SF_FLIPSPECIAL_FLOOR) && mo->z == cel)	// "floor" check
+				|| ((s2->flags & SF_FLIPSPECIAL_CEILING) && (mo->z + mo->height) == flr) )	// "ceiling" check.

-				if (s2->flags & SF_FLIPSPECIAL_FLOOR)
-				{
-					cel = P_GetFOFTopZ(mo, s, rover, mo->x, mo->y, NULL); // Z coords for fof top/bottom.
-					if (mo->z == cel) // "floor" check
-						return i-1; // return offroad type
-				}
+				for (i = 2; i < 5; i++)	// check for sector special
+
+					if (GETSECSPECIAL(s2->special, 1) == i)
+						return i-1;	// return offroad type

-				if (s2->flags & SF_FLIPSPECIAL_CEILING)
-				{
-					flr = P_GetFOFBottomZ(mo, s, rover, mo->x, mo->y, NULL);
-					if ((mo->z + mo->height) == flr) // "ceiling" check
-						return i-1; // return offroad type
-				}
-			}
 		}
 	}
-
-	return 0; // couldn't find any offroad
+	return 0;	// couldn't find any offroad
 }

 /**	\brief	Updates the Player's offroad value once per frame
@@ -1742,6 +1708,7 @@ static void K_SpawnDashDustRelease(player_t *player)
 	INT32 i;

 	I_Assert(player != NULL);
+	I_Assert(player->mo != NULL);
 	I_Assert(!P_MobjWasRemoved(player->mo));

 	if (!player->speed && !player->kartstuff[k_startboost])
@@ -1779,6 +1746,7 @@ static void K_SpawnBrakeDriftSparks(player_t *player) // Be sure to update the m
 	mobj_t *sparks;

 	I_Assert(player != NULL);
+	I_Assert(player->mo != NULL);
 	I_Assert(!P_MobjWasRemoved(player->mo));

 	// Position & etc are handled in its thinker, and its spawned invisible.
@@ -1974,9 +1942,11 @@ static void K_PlayGenericCombatSound(mobj_t *source, mobj_t *other, sfxenum_t sf
 	if (!skin)
 		return;

+	boolean alwaysHear = false;
+
 	if (cv_kartvoices.value && !P_MobjWasRemoved(other) && other->player != NULL)
 	{
-		boolean alwaysHear = P_IsDisplayPlayer(other->player);
+		alwaysHear = P_IsDisplayPlayer(other->player);
 		S_StartSound(alwaysHear ? NULL : source, skin->soundsid[S_sfx[sfx_id].skinsound]);
 	}

@@ -2176,13 +2146,7 @@ static void K_GetKartBoostPower(player_t *player)
 		&& player->speed > 0
 		&& !player->spectator)
 	{
-		mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true);
-
-		// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
-		// is to hide them if you are in saltyhop jump
-		if (dust && player->mo->salty.jump)
-			dust->flags2 |= MF2_DONTDRAW;
-
+		K_SpawnWipeoutTrail(player->mo, true);
 		if (leveltime % 6 == 0)
 			S_StartSound(player->mo, sfx_cdfm70);
 	}
@@ -2336,13 +2300,10 @@ fixed_t K_3dKartMovement(player_t *player, boolean onground, fixed_t forwardmove
 	finalspeed *= forwardmove/25;
 	finalspeed /= 2;

-	if (forwardmove < 0)
-	{
-		if (finalspeed > mapobjectscale*2)
-			return finalspeed/2;
-
+	if (forwardmove < 0 && finalspeed > mapobjectscale*2)
+		return finalspeed/2;
+	else if (forwardmove < 0)
 		return -mapobjectscale/2;
-	}

 	if (finalspeed < 0)
 		finalspeed = 0;
@@ -2392,7 +2353,6 @@ void K_SpawnBattlePoints(player_t *source, player_t *victim, UINT8 amount)
 			break;
 		case 3:
 			st = S_BATTLEPOINT3A;
-			break;
 		default:
 			return; // NO STATE!
 	}
@@ -3143,18 +3103,17 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
 	return NULL;
 }

-static UINT8 K_DriftSparkColor(player_t *player, INT32 charge)
+static UINT16 K_DriftSparkColor(player_t *player, INT32 charge)
 {
-	UINT8 color = SKINCOLOR_NONE;
-	const INT32 sparkval = K_GetKartDriftSparkValue(player);
+	UINT16 color = SKINCOLOR_NONE;

-	if (charge >= sparkval*4)
+	if (charge >= K_GetKartDriftSparkValue(player)*4)
 	{
 		color = K_RainbowColor();
 	}
-	else if (charge >= sparkval*2)
+	else if (charge >= K_GetKartDriftSparkValue(player)*2)
 	{
-		if (charge <= (sparkval*2)+(24*3))
+		if (charge <= (K_GetKartDriftSparkValue(player)*2)+(24*3))
 			color = SKINCOLOR_RASPBERRY; // transition
 		else
 			color = SKINCOLOR_KETCHUP;
@@ -3178,6 +3137,7 @@ static void K_SpawnDriftSparks(player_t *player)
 	INT32 i;

 	I_Assert(player != NULL);
+	I_Assert(player->mo != NULL);
 	I_Assert(!P_MobjWasRemoved(player->mo));

 	if (leveltime % 2 == 1)
@@ -3441,7 +3401,7 @@ static void K_QuiteSaltyHop(player_t *player)
 			pmo->spritexscale -= (FRACUNIT/8);
 		}

-		pmo->spriteyoffset += FixedMul(psalt->zoffset, cv_saltyheight.value);
+		pmo->spriteyoffset = FixedMul(psalt->zoffset, cv_saltyheight.value);

 		if (cv_saltyhopsfx.value)
 		{
@@ -3549,6 +3509,7 @@ void K_SpawnBoostTrail(player_t *player)
 	INT32 i;

 	I_Assert(player != NULL);
+	I_Assert(player->mo != NULL);
 	I_Assert(!P_MobjWasRemoved(player->mo));

 	if (!P_IsObjectOnGround(player->mo)
@@ -3630,10 +3591,9 @@ void K_SpawnSparkleTrail(mobj_t *mo)
 	mobj_t *sparkle;
 	INT32 i;

+	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);
@@ -3651,18 +3611,19 @@ void K_SpawnSparkleTrail(mobj_t *mo)

 		sparkle->color = mo->color;

-		if (shouldblend)
+		if (mo->player && K_PlayerEffectsShouldBlend(mo->player))
 			sparkle->blendmode = AST_ADD;
 	}

 	P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
 }

-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 {
 	mobj_t *dust;
 	angle_t aoff;

+	I_Assert(mo != NULL);
 	I_Assert(!P_MobjWasRemoved(mo));

 	if (mo->player)
@@ -3694,10 +3655,10 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
 		dust->momx = mo->momx/2;
 		dust->momy = mo->momy/2;
 		dust->momz = mo->momz/2;
-		dust->flags2 |= MF2_SHADOW;
 	}

-	return dust;
+	if (translucent)
+		dust->flags2 |= MF2_SHADOW;
 }

 //	K_DriftDustHandling
@@ -3711,7 +3672,7 @@ void K_DriftDustHandling(mobj_t *spawner)
 {
 	angle_t anglediff;

-	if (leveltime % 2 != 0 || !P_IsObjectOnGround(spawner))
+	if (!P_IsObjectOnGround(spawner) || leveltime % 2 != 0)
 		return;

 	if (spawner->player)
@@ -4094,7 +4055,7 @@ static void K_DoThunderShield(player_t *player)
 	mo->scale = player->mo->scale*3 + (player->mo->scale/2);

 	// spawn horizontal bolts;
-	for (i = 0; i < 7; i++)
+	for (i=0; i<7; i++)
 	{
 		mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_THOK);
 		mo->angle = P_RandomRange(0, 359)*ANG1;
@@ -4105,7 +4066,7 @@ static void K_DoThunderShield(player_t *player)

 	// spawn the radius thing:
 	an = ANGLE_22h;
-	for (i = 0; i < 15; i++)
+	for (i=0; i<15; i++)
 	{
 		sx = player->mo->x + FixedMul((player->mo->scale*THUNDERRADIUS), FINECOSINE((an*i)>>ANGLETOFINESHIFT));
 		sy = player->mo->y + FixedMul((player->mo->scale*THUNDERRADIUS), FINESINE((an*i)>>ANGLETOFINESHIFT));
@@ -4197,12 +4158,12 @@ static void K_DoHyudoroSteal(player_t *player)

 void K_DoSneaker(player_t *player, INT32 type)
 {
+	const fixed_t intendedboost = K_GetSneakerBoostSpeed();
+
 	if (!player->kartstuff[k_floorboost] || player->kartstuff[k_floorboost] == 3)
 	{
 		S_StartSound(player->mo, sfx_cdfm01);
 		K_SpawnDashDustRelease(player);
-
-		const fixed_t intendedboost = K_GetSneakerBoostSpeed();
 		if (intendedboost > player->kartstuff[k_speedboost])
 			player->kartstuff[k_destboostcam] = FixedMul(FRACUNIT, FixedDiv((intendedboost - player->kartstuff[k_speedboost]), intendedboost));
 	}
@@ -4672,7 +4633,8 @@ void K_RepairOrbitChain(mobj_t *orbit)
 				prev->movedir = num;
 		}

-		player->kartstuff[k_itemamount] = num;
+		if (player->kartstuff[k_itemamount] != num)
+			player->kartstuff[k_itemamount] = num;
 	}
 }

@@ -6197,13 +6159,6 @@ void K_KartUpdatePosition(player_t *player)
 						}
 					}

-					// the player should NOT be checked against themselves! lol
-					// otherwise prevcheck will effectively be halved
-					// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
-					// oh well
-					//if (player == &players[i])
-						//continue;
-
 					const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
 					const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);

@@ -6218,8 +6173,7 @@ void K_KartUpdatePosition(player_t *player)
 							players[i].kartstuff[k_prevcheck] += imo;
 							ipcd++;
 						}
-
-						if (isnextcheckpointi)
+						if (isnextcheckpointi )
 						{
 							players[i].kartstuff[k_nextcheck] += imo;
 							incd++;
@@ -6811,7 +6765,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 		{
 			if (splitscreen)
 			{
-				if (!cv_reducevfx.value && leveltime & 1)
+				if (leveltime & 1)
 					player->mo->flags2 |= MF2_DONTDRAW;
 				else
 					player->mo->flags2 &= ~MF2_DONTDRAW;
@@ -6837,7 +6791,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 (!cv_reducevfx.value && leveltime & 1)
+					if (leveltime & 1)
 						player->mo->flags2 |= MF2_DONTDRAW;
 					else
 						player->mo->flags2 &= ~MF2_DONTDRAW;
@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
 void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
 void K_SpawnBoostTrail(player_t *player);
 void K_SpawnSparkleTrail(mobj_t *mo);
-mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
+void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
 void K_DriftDustHandling(mobj_t *spawner);
 void K_PuntMine(mobj_t *mine, mobj_t *punter);
 void K_DoSneaker(player_t *player, INT32 type);
@@ -99,7 +99,8 @@ void K_EraseStats(void)
 	// The only field we want to remember
 	boolean vanilla = kartstats.vanilla;

-	Z_Free(kartstats.copy);
+	if (kartstats.copy)
+		Z_Free(kartstats.copy);

 	memset(&kartstats, 0, sizeof(kartstats_t));

@@ -1293,7 +1293,6 @@ 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))
@@ -358,8 +358,7 @@ static int lib_cvRegisterVar(lua_State *L)
 #define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))

 	lua_pushnil(L);
-	while (lua_next(L, 1))
-	{
+	while (lua_next(L, 1)) {
 		// stack: cvar table, cvar userdata, key/index, value
 		//            1             2            3        4
 		i = 0;
@@ -369,40 +368,26 @@ static int lib_cvRegisterVar(lua_State *L)
 		else if (lua_isstring(L, 3))
 			k = lua_tostring(L, 3);

-		if (i == 1 || (k && fasticmp(k, "name")))
-		{
+		if (i == 1 || (k && fasticmp(k, "name"))) {
 			if (!lua_isstring(L, 4))
 				TYPEERROR("name", LUA_TSTRING)
-
 			cvar->name = Z_StrDup(lua_tostring(L, 4));
-		}
-		else if (i == 2 || (k && fasticmp(k, "defaultvalue")))
-		{
+		} else if (i == 2 || (k && fasticmp(k, "defaultvalue"))) {
 			if (!lua_isstring(L, 4))
 				TYPEERROR("defaultvalue", LUA_TSTRING)
-
 			cvar->defaultvalue = Z_StrDup(lua_tostring(L, 4));
-		}
-		else if (i == 3 || (k && fasticmp(k, "flags")))
-		{
+		} else if (i == 3 || (k && fasticmp(k, "flags"))) {
 			if (!lua_isnumber(L, 4))
 				TYPEERROR("flags", LUA_TNUMBER)
-
 			cvar->flags = (INT32)lua_tointeger(L, 4);
-		}
-		else if (i == 4 || (k && fasticmp(k, "PossibleValue")))
-		{
-			if (lua_islightuserdata(L, 4))
-			{
+		} else if (i == 4 || (k && fasticmp(k, "PossibleValue"))) {
+			if (lua_islightuserdata(L, 4)) {
 				CV_PossibleValue_t *pv = lua_touserdata(L, 4);
-
 				if (pv == CV_OnOff || pv == CV_YesNo || pv == CV_Unsigned || pv == CV_Natural)
 					cvar->PossibleValue = pv;
 				else
 					FIELDERROR("PossibleValue", "CV_PossibleValue_t expected, got unrecognised pointer")
-			}
-			else if (lua_istable(L, 4))
-			{
+			} else if (lua_istable(L, 4)) {
 				// Accepts tables in the form of {MIN=0, MAX=9999} or {Red=0, Green=1, Blue=2}
 				// and converts them to CV_PossibleValue_t {{0,"MIN"},{9999,"MAX"}} or {{0,"Red"},{1,"Green"},{2,"Blue"}}
 				//
@@ -413,9 +398,7 @@ static int lib_cvRegisterVar(lua_State *L)
 				CV_PossibleValue_t *cvpv;

 				lua_pushnil(L);
-
-				while (lua_next(L, 4))
-				{
+				while (lua_next(L, 4)) {
 					count++;
 					lua_pop(L, 1);
 				}
@@ -429,9 +412,7 @@ static int lib_cvRegisterVar(lua_State *L)

 				i = 0;
 				lua_pushnil(L);
-
-				while (lua_next(L, 4))
-				{
+				while (lua_next(L, 4)) {
 					// stack: [...] PossibleValue table, index, value
 					//                       4             5      6
 					if (lua_type(L, 5) != LUA_TSTRING
@@ -442,19 +423,14 @@ static int lib_cvRegisterVar(lua_State *L)
 					i++;
 					lua_pop(L, 1);
 				}
-
 				cvpv[i].value = 0;
 				cvpv[i].strvalue = NULL;
 				cvar->PossibleValue = cvpv;
-			}
-			else
+			} else
 				FIELDERROR("PossibleValue", va("%s or CV_PossibleValue_t expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1)))
-		}
-		else if (i == 5 || (k && fasticmp(k, "func")))
-		{
+		} else if (i == 5 || (k && fasticmp(k, "func"))) {
 			if (!lua_isfunction(L, 4))
 				TYPEERROR("func", LUA_TFUNCTION)
-
 			lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange");
 			I_Assert(lua_istable(L, 5));
 			lua_pushlightuserdata(L, cvar);
@@ -462,13 +438,9 @@ static int lib_cvRegisterVar(lua_State *L)
 			lua_rawset(L, 5);
 			lua_pop(L, 1);
 			cvar->func = Lua_OnChange;
-
-			if (i == 5 && !(cvar->flags & CV_CALL))
-			{
-				category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
-			}
 		}
-		else if ((cvar->flags & CV_CALL && i == 6)
+		else if (((i == 5 && !(cvar->flags & CV_CALL))
+				|| (cvar->flags & CV_CALL && i == 6))
 				|| (k && fasticmp(k, "category")))
 		{
 			category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
@@ -479,7 +451,6 @@ static int lib_cvRegisterVar(lua_State *L)
 		{
 			menu_name = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
 		}
-
 		lua_pop(L, 1);
 	}
 #undef FIELDERROR
Author	SHA1	Message	Date
Alug	8cf2395d42	Merge branch 'Saturn-Next' into Saturn	2025-12-06 15:45:51 +01:00
Alug	3abe74de86	release 9.2	2025-12-06 15:33:41 +01:00
Alug	5a61ebf325	Merge branch 'Saturn-Next' into Saturn	2025-12-06 15:33:08 +01:00