can pass char to this now

no need to reconvert this stuff from const char to std::string and back to const char really lol

CMakeLists.txt

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

LUASTUFF.md

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

README.md

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

assets/CMakeLists.txt

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

cmake/Modules/FindGME.cmake

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

cmake/Modules/FindOPENMPT.cmake

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

cmake/Modules/Findlibbacktrace.cmake

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

cmake/Modules/LibFindMacros.cmake

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

src/.gitignore

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

src/CMakeLists.txt

@@ -2,6 +2,8 @@
 
 # Core sources
 set(SRB2_CORE_SOURCES
+	core/memory.cpp
+	core/thread_pool.cpp
 	am_map.c
 	b_bot.c
 	command.c
@@ -18,17 +20,21 @@ set(SRB2_CORE_SOURCES
 	f_wipe.c
 	filesrch.c
 	g_game.c
+	g_demo.c
 	g_input.c
 	hu_stuff.c
 	i_tcp.c
 	info.c
+	k_hud.c
 	lzf.c
 	m_aatree.c
 	m_anigif.c
 	m_argv.c
 	m_bbox.c
 	m_cheat.c
+	m_curl.c
 	m_cond.c
+	m_emotes.cpp
 	m_fixed.c
 	m_menu.c
 	m_textinput.c
@@ -40,19 +46,25 @@ set(SRB2_CORE_SOURCES
 	mserv.c
 	http-mserv.c
 	qs22j.c
+	r_skins.c
 	s_sound.c
 	screen.c
 	sounds.c
 	st_stuff.c
-	#string.c
+	string.c
 	tables.c
 	v_video.c
 	w_wad.c
 	y_inter.c
-	z_zone.c
+	z_zone.cpp
 )
 
 set(SRB2_CORE_HEADERS
+	core/memory.h
+	core/thread_pool.h
+	m_curl.h
+	m_emotes.h
+	k_hud.h
 	am_map.h
 	b_bot.h
 	byteptr.h
@@ -78,6 +90,7 @@ set(SRB2_CORE_HEADERS
 	fastcmp.h
 	filesrch.h
 	g_game.h
+	g_demo.h
 	g_input.h
 	g_state.h
 	hu_stuff.h
@@ -109,6 +122,7 @@ set(SRB2_CORE_HEADERS
 	md5.h
 	mserv.h
 	qs22j.h
+	r_skins.h
 	s_sound.h
 	screen.h
 	sounds.h
@@ -123,18 +137,18 @@ set(SRB2_CORE_HEADERS
 )
 
 set(SRB2_CORE_RENDER_SOURCES
-	r_bsp.c
+	r_bsp.cpp
 	r_data.c
-	r_draw.c
-	r_fps.c
-	r_main.c
-	r_patch.c
-	r_patchrotation.c
-	r_plane.c
-	r_segs.c
+	r_draw.cpp
+	r_fps.cpp
+	r_main.cpp
+	r_patch.cpp
+	r_patchrotation.cpp
+	r_plane.cpp
+	r_segs.cpp
 	r_sky.c
 	r_splats.c
-	r_things.c
+	r_things.cpp
 	r_portal.c
 
 	r_bsp.h
@@ -162,7 +176,7 @@ set(SRB2_CORE_GAME_SOURCES
 	p_inter.c
 	p_lights.c
 	p_map.c
-	p_maputl.c
+	p_maputl.cpp
 	p_mobj.c
 	p_polyobj.c
 	p_saveg.c
@@ -193,10 +207,6 @@ set(SRB2_CORE_GAME_SOURCES
 	k_stats.h
 )
 
-if(NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
-	set(SRB2_CORE_SOURCES ${SRB2_CORE_SOURCES} string.c)
-endif()
-
 prepend_sources(SRB2_CORE_SOURCES)
 prepend_sources(SRB2_CORE_HEADERS)
 prepend_sources(SRB2_CORE_RENDER_SOURCES)
@@ -226,10 +236,23 @@ set(SRB2_CONFIG_HWRENDER ON CACHE BOOL
 	"Enable hardware rendering through OpenGL.")
 set(SRB2_CONFIG_STATIC_OPENGL OFF CACHE BOOL
 	"Use statically linked OpenGL. NOT RECOMMENDED.")
-set(SRB2_CONFIG_USE_FBO_OGL ON CACHE BOOL
-	"Enable OpenGL FBO Downsampling support.")
 set(SRB2_CONFIG_DEDICATED OFF CACHE BOOL
 	"Build a dedicated server.")
+set(SRB2_CONFIG_LIBBACKTRACE ON CACHE BOOL
+	"Enable using libbacktrace for crashlogs.")
+set(SRB2_CONFIG_LTO ON CACHE BOOL
+	"Enable link time optimizations, improves performance at the cost of longer link times.")
+set(SRB2_CONFIG_ASAN OFF CACHE BOOL
+	"Compile with AddressSanitizer (libasan).")
+set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
+	"Compile with UndefinedBehaviorSanitizer (libubsan).")
+
+set(SRB2_CONFIG_SATURNPAK ON CACHE BOOL
+	"Enable Saturn specific special packet. Required for using the newer resynch system")
+set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
+	"Enable Saturn specific allowjoin toggle.")
+set(SRB2_CONFIG_SCREENFBO ON CACHE BOOL
+	"Enable hardware renderer (OpenGL) FBO downsampling support")
 
 if(${SRB2_CONFIG_DEDICATED})
 	set(SRB2_CONFIG_HAVE_GME NO)
@@ -252,6 +275,7 @@ if(${SRB2_CONFIG_HAVE_BLUA})
 		lua_hooklib.c
 		lua_hudlib.c
 		lua_hudlib_drawlist.c
+		lua_profile.cpp
 		lua_infolib.c
 		lua_maplib.c
 		lua_mathlib.c
@@ -267,6 +291,7 @@ if(${SRB2_CONFIG_HAVE_BLUA})
 		lua_hook.h
 		lua_hud.h
 		lua_hudlib_drawlist.h
+		lua_profile.h
 		lua_libs.h
 		lua_script.h
 		lua_udatalib.h
@@ -469,6 +494,26 @@ 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
@@ -478,7 +523,7 @@ if(${SRB2_CONFIG_HWRENDER})
 		${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.c
+		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
@@ -493,7 +538,6 @@ if(${SRB2_CONFIG_HWRENDER})
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_data.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_defs.h
-		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_dll.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_gl.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_glob.h
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.h
@@ -512,7 +556,6 @@ if(${SRB2_CONFIG_HWRENDER})
 	set(SRB2_R_OPENGL_HEADERS
 		${CMAKE_CURRENT_SOURCE_DIR}/hardware/r_opengl/r_opengl.h
 	)
-
 endif()
 
 if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
@@ -525,25 +568,40 @@ if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
 	endif()
 endif()
 
-if(${SRB2_CONFIG_HWRENDER})
-	if(${SRB2_CONFIG_USE_FBO_OGL})
-		set(SRB2_USE_FBO_OGL ON)
-		add_definitions(-DUSE_FBO_OGL)
-	endif()
+if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_SCREENFBO})
+	add_definitions(-DUSE_FBO_OGL)
+endif()
+
+if(${SRB2_CONFIG_SATURNPAK})
+	add_definitions(-DDOSATURNPAK)
+endif()
+
+if(${SRB2_CONFIG_SATURNJOIN})
+	add_definitions(-DDOSATURNJOIN)
 endif()
 
 # Targets
 
 # Compatibility flag with later versions of GCC
 # We should really fix our code to not need this
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -mno-ms-bitfields)
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|x64|amd64|AMD64|em64t|EM64T)")
+		add_compile_options(-mno-ms-bitfields)
+	endif()
+	add_compile_options(-Wno-trigraphs)
 endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} -Wno-absolute-value)
+# TODO: fix prng and P_CreateBlockmap overflow at some point
+add_compile_options(-fwrapv)
+
+if (${CMAKE_BUILD_TYPE} MATCHES Debug)
+	add_compile_options(-O0)
+else()
+	add_compile_options(-O3)
 endif()
 
+add_compile_options(-g)
+
 add_definitions(-DCMAKECONFIG)
 
 #add_library(SRB2Core STATIC

src/Makefile

@@ -93,7 +93,8 @@
 # NOLDWARNING=1 - ?
 # NOSDLMAIN=1 - ?
 # SDLMAIN=1 - ?
-# USELTO=1 - Enable building with LTO.
+# NOLTO=1 - Disable link time optimizations
+# USEJEMALLOC=1 Enable building with jemalloc Allocator to replace GLibc malloc, might improve performance
 #
 # Library configuration flags:
 # Everything here is an override.
@@ -260,7 +261,7 @@ debug_opts=-D_DEBUG
 else # build a normal optimized version
 debug_opts=-DNDEBUG
 opts+=-O3
-ifdef USELTO
+ifndef NOLTO
 # compile with LTO
 opts+=-flto=auto
 libs+=-flto=auto
@@ -269,16 +270,20 @@ endif
 
 ifdef USEASAN
 # compile with asan
-opts+=-fsanitize=address
+opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
 libs+=-fsanitize=address
 endif
 
 ifdef USEUBSAN
-# compile with asan
-opts+=-fsanitize=undefined
+# compile with ubsan
+opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
 libs+=-fsanitize=undefined
 endif
 
+ifdef USEJEMALLOC
+libs+=-ljemalloc
+endif
+
 ifneq (,$(filter $(CC) $(CXX),clang clang++))
  libs+=-fuse-ld=lld
 endif
@@ -295,6 +300,7 @@ opts+=$(debug_opts)
 
 opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))
 
+CWFLAGS+=-std=gnu17
 CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers
 
 opts+=$(WFLAGS) $(CFLAGS)

src/Makefile.d/detect.mk

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

src/Makefile.d/features.mk

@@ -8,6 +8,7 @@ passthru_opts+=\
 	HAVE_MINIUPNPC\
 	HAVE_DISCORDRPC DEVELOP\
 	NOHOLEPUNCH\
+	HAVE_IPV6\
 
 # build with debugging information
 ifdef DEBUGMODE

src/Makefile.d/versions.mk

@@ -20,7 +20,11 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
 CXXFLAGS+= -Wno-aggregate-return
 
 # -W -Wno-unused
-WFLAGS:=-Wall -Wno-trigraphs
+WFLAGS:=-Wall -Wnull-dereference
+#WFLAGS+=-Wno-trigraphs
+ifdef GCC152
+WFLAGS+=-Wzero-as-null-pointer-constant
+endif
 ifndef GCC295
 #WFLAGS+=-Wno-packed
 endif
@@ -28,7 +32,7 @@ ifndef RELAXWARNINGS
  WFLAGS+=-W
 #WFLAGS+=-Wno-sign-compare
 ifndef GCC295
- WFLAGS+=-Wno-div-by-zero
+# WFLAGS+=-Wno-div-by-zero
 endif
 #WFLAGS+=-Wsystem-headers
 WFLAGS+=-Wfloat-equal
@@ -59,7 +63,7 @@ endif
 endif
  WFLAGS+=-Wsign-compare
 ifdef GCC91
- WFLAGS+=-Wno-error=address-of-packed-member
+# WFLAGS+=-Wno-error=address-of-packed-member
 endif
 ifdef GCC45
  WFLAGS+=-Wlogical-op
@@ -102,14 +106,14 @@ endif
 endif
 WFLAGS+=-Wformat-y2k
 ifdef GCC71
-WFLAGS+=-Wno-error=format-overflow=2
+#WFLAGS+=-Wno-error=format-overflow=2
 endif
 WFLAGS+=-Wformat-security
 ifndef GCC29
 #WFLAGS+=-Winit-self
 endif
 ifdef GCC46
-WFLAGS+=-Wno-suggest-attribute=noreturn
+#WFLAGS+=-Wno-suggest-attribute=noreturn
 endif
 
 ifdef NOLDWARNING
@@ -127,21 +131,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++))
@@ -180,6 +184,6 @@ endif
 # Lua
 ifdef GCC43
 ifndef GCC44
-WFLAGS+=-Wno-logical-op
+#WFLAGS+=-Wno-logical-op
 endif
 endif

src/Sourcefile

@@ -1,3 +1,4 @@
+string.c
 am_map.c
 b_bot.c
 command.c
@@ -42,7 +43,6 @@ s_sound.c
 screen.c
 sounds.c
 st_stuff.c
-string.c
 tables.c
 v_video.c
 w_wad.c
@@ -99,3 +99,4 @@ lua_skinlib.c
 lua_thinkerlib.c
 lua_udatalib.c
 lua_glib.c
+lua_profile.cpp

src/android/i_system.c

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

src/b_bot.c

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

src/blua/lapi.c

@@ -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_new(L, "") : luaS_newlstr(L, s, len));
+  setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len));
   api_incr_top(L);
   lua_unlock(L);
 }

src/blua/lauxlib.c

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

src/blua/lauxlib.h

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

src/blua/lcode.c

@@ -790,18 +790,19 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
     case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
     case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
     case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
-    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
-    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
-    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
-    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
-    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
-    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
-    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
-    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
-    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
-    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
-    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
-    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
+      break;
+    }
+    case OPR_EQ: case OPR_LT: case OPR_LE: {
+      codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
+      break;
+    }
+    case OPR_NE: case OPR_GT: case OPR_GE: {
+      codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
+      break;
+    }
     default: lua_assert(0);
   }
 }

src/blua/lcode.h

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

src/blua/ldebug.c

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

src/blua/ldo.c

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

src/blua/liolib.c

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

src/blua/lparser.c

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

src/blua/lstring.c

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

src/blua/lstrlib.c

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

src/blua/ltable.c

@@ -81,6 +81,7 @@ 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;
@@ -90,6 +91,12 @@ 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
 
 
 

src/blua/luaconf.h

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

src/blua/lvm.c

@@ -28,7 +28,7 @@
 
 
 
-/* limit for table tag-method chains (to avoid loops) */
+/* limit for table tag-method chains (to avoid infinite loops) */
 #define MAXTAGLOOP	100
 
 
@@ -366,6 +366,7 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
 
 
 #define arith_op(op,tm) { \
+        StkId ra = RA(i); \
         TValue *rb = RKB(i); \
         TValue *rc = RKC(i); \
         if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -392,7 +393,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
   /* main loop of interpreter */
   for (;;) {
     const Instruction i = *pc++;
-    StkId ra;
     if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
       traceexec(L, pc);
@@ -402,26 +402,28 @@ void luaV_execute (lua_State *L, int nexeccalls) {
       }
       base = L->base;
     }
-    /* warning!! several calls may realloc the stack and invalidate `ra' */
-    ra = RA(i);
     lua_assert(base == L->base && L->base == L->ci->base);
     lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
     lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
     switch (GET_OPCODE(i)) {
       case OP_MOVE: {
+        StkId ra = RA(i);
         setobjs2s(L, ra, RB(i));
         continue;
       }
       case OP_LOADK: {
+        StkId ra = RA(i);
         setobj2s(L, ra, KBx(i));
         continue;
       }
       case OP_LOADBOOL: {
+        StkId ra = RA(i);
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
         continue;
       }
       case OP_LOADNIL: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
@@ -429,11 +431,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETUPVAL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
         continue;
       }
       case OP_GETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         TValue *rb = KBx(i);
         sethvalue(L, &g, cl->env);
@@ -442,10 +446,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_GETTABLE: {
-        Protect(luaV_gettable(L, RB(i), RKC(i), ra));
+        StkId ra = RA(i);
+        StkId rb = RB(i);
+        TValue *rc = RKC(i);
+        Protect(luaV_gettable(L, rb, rc, ra));
         continue;
       }
       case OP_SETGLOBAL: {
+        StkId ra = RA(i);
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
@@ -453,16 +461,21 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETUPVAL: {
+        StkId ra = RA(i);
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
         continue;
       }
       case OP_SETTABLE: {
-        Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
+        StkId ra = RA(i);
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        Protect(luaV_settable(L, ra, rb, rc));
         continue;
       }
       case OP_NEWTABLE: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int c = GETARG_C(i);
         sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -470,6 +483,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SELF: {
+        StkId ra = RA(i);
         StkId rb = RB(i);
         setobjs2s(L, ra+1, rb);
         Protect(luaV_gettable(L, rb, RKC(i), ra));
@@ -488,6 +502,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_DIV: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -503,6 +518,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_MOD: {
+        StkId ra = RA(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -522,26 +538,27 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_BAND: {
-	arith_op(luai_numand, TM_AND);
-	continue;
+        arith_op(luai_numand, TM_AND);
+        continue;
       }
       case OP_BOR: {
-	arith_op(luai_numor, TM_OR);
-	continue;
+        arith_op(luai_numor, TM_OR);
+        continue;
       }
       case OP_BXOR: {
-	arith_op(luai_numxor, TM_XOR);
-	continue;
+        arith_op(luai_numxor, TM_XOR);
+        continue;
       }
       case OP_BSHL: {
-	arith_op(luai_numshl, TM_SHL);
-	continue;
+        arith_op(luai_numshl, TM_SHL);
+        continue;
       }
       case OP_BSHR: {
-	arith_op(luai_numshr, TM_SHR);
-	continue;
+        arith_op(luai_numshr, TM_SHR);
+        continue;
       }
       case OP_BNOT: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -553,6 +570,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_UNM: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -564,11 +582,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_NOT: {
+        StkId ra = RA(i);
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
         continue;
       }
       case OP_LEN: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         switch (ttype(rb)) {
           case LUA_TTABLE: {
@@ -626,12 +646,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TEST: {
+        StkId ra = RA(i);
         if (l_isfalse(ra) != GETARG_C(i))
           dojump(L, pc, GETARG_sBx(*pc));
         pc++;
         continue;
       }
       case OP_TESTSET: {
+        StkId ra = RA(i);
         TValue *rb = RB(i);
         if (l_isfalse(rb) != GETARG_C(i)) {
           setobjs2s(L, ra, rb);
@@ -641,6 +663,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         int nresults = GETARG_C(i) - 1;
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
@@ -662,6 +685,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_TAILCALL: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         L->savedpc = pc;
@@ -694,6 +718,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_RETURN: {
+        StkId ra = RA(i);
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
@@ -709,6 +734,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         }
       }
       case OP_FORLOOP: {
+        StkId ra = RA(i);
         lua_Number step = nvalue(ra+2);
         lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
         lua_Number limit = nvalue(ra+1);
@@ -721,6 +747,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_FORPREP: {
+        StkId ra = RA(i);
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
@@ -737,6 +764,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_TFORLOOP: {
+        StkId ra = RA(i);
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+2, ra+2);
         setobjs2s(L, cb+1, ra+1);
@@ -753,6 +781,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_SETLIST: {
+        StkId ra = RA(i);
         int n = GETARG_B(i);
         int c = GETARG_C(i);
         int last;
@@ -775,10 +804,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_CLOSE: {
+        StkId ra = RA(i);
         luaF_close(L, ra);
         continue;
       }
       case OP_CLOSURE: {
+        StkId ra = RA(i);
         Proto *p;
         Closure *ncl;
         int nup, j;
@@ -799,6 +830,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         continue;
       }
       case OP_VARARG: {
+        StkId ra = RA(i);
         int b = GETARG_B(i) - 1;
         int j;
         CallInfo *ci = L->ci;

src/command.c

@@ -237,10 +237,13 @@ void COM_ImmedExecute(const char *ptext)
 	char line[1024] = "";
 	INT32 quotes;
 
-	while (i < strlen(ptext))
+	const size_t txtlength = strlen(ptext);
+
+	while (i < txtlength)
 	{
 		quotes = 0;
-		for (j = 0; i < strlen(ptext); i++,j++)
+
+		for (j = 0; i < txtlength; i++,j++)
 		{
 			if (ptext[i] == '\"' && !quotes && i > 0 && ptext[i-1] != ' ') // Malformed command
 				return;
@@ -652,7 +655,7 @@ static void COM_Alias_f(void)
 		CONS_Printf(M_GetText("All aliases that start with \x87'%s'\x80 are:\n"), begin);
 
 		int count = 0;
-		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head != NULL; head = head->next)
 		{
 			if (strncmp(begin, head->name, szBegin) == 0)
 			{
@@ -673,7 +676,7 @@ static void COM_Alias_f(void)
 		/* Display alias subtext, show all aliases. */
 		CONS_Printf(M_GetText("alias <name> <command>: create a shortcut command that executes other command(s)\n"));
 
-		for (cmdalias_t *head = com_alias; head->next != NULL; head = head->next)
+		for (cmdalias_t *head = com_alias; head != NULL; head = head->next)
 		{
 			CONS_Printf(alias_format, head->name, head->value);
 		}
@@ -1162,6 +1165,39 @@ void VS_Print(vsbuf_t *buf, const char *data)
 //
 // =========================================================================
 
+#define NAME      cvar_map_t
+#define KEY_TY    const char *
+#define VAL_TY    consvar_t *
+#define HASH_FN   FNV1a_HashLowercaseString
+#define CMPR_FN   vt_cmpr_casestring
+#include "verstable.h"
+
+#define NAME      netvar_map_t
+#define KEY_TY    UINT16
+#define VAL_TY    consvar_t *
+#define HASH_FN   vt_hash_integer
+#define CMPR_FN   vt_cmpr_integer
+#include "verstable.h"
+
+static cvar_map_t cvar_map;
+static netvar_map_t netvar_map;
+
+CONSTRUCTOR static void CV_InitMap(void)
+{
+	// ensure the map is initialized
+	cvar_map_t_init(&cvar_map);
+	cvar_map_t_reserve(&cvar_map, 512);
+
+	netvar_map_t_init(&netvar_map);
+	netvar_map_t_reserve(&netvar_map, 256);
+}
+
+DESTRUCTOR static void CV_DestroyMap(void)
+{
+	cvar_map_t_cleanup(&cvar_map);
+	netvar_map_t_cleanup(&netvar_map);
+}
+
 static const char *cv_null_string = "";
 
 /** Searches if a variable has been registered.
@@ -1172,11 +1208,17 @@ static const char *cv_null_string = "";
   */
 consvar_t *CV_FindVar(const char *name)
 {
-	consvar_t *cvar;
+	cvar_map_t_itr it = cvar_map_t_get(&cvar_map, name);
+	if (!cvar_map_t_is_end(it))
+		return it.data->val;
 
+	// fallback linear search
+	/*
+	consvar_t *cvar;
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
-		if (fasticmp(name,cvar->name))
+		if (fasticmp(name, cvar->name))
 			return cvar;
+	*/
 
 	return NULL;
 }
@@ -1191,7 +1233,7 @@ consvar_t *CV_FindVar(const char *name)
 static inline UINT16 CV_ComputeNetid(const char *s)
 {
 	UINT16 ret = 0, i = 0;
-	static UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
+	static const UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
 
 	while (*s)
 	{
@@ -1210,11 +1252,17 @@ static inline UINT16 CV_ComputeNetid(const char *s)
   */
 static consvar_t *CV_FindNetVar(UINT16 netid)
 {
+	netvar_map_t_itr it = netvar_map_t_get(&netvar_map, netid);
+	if (!netvar_map_t_is_end(it))
+		return it.data->val;
+
+	/*
 	consvar_t *cvar;
 
 	for (cvar = consvar_vars; cvar; cvar = cvar->next)
 		if (cvar->netid == netid)
 			return cvar;
+	*/
 
 	if (netid == 44542) // ouch this hack
 		return &cv_karteliminatelast;
@@ -1280,6 +1328,11 @@ void CV_RegisterVar(consvar_t *variable)
 
 	// the SetValue will set this bit
 	variable->flags &= ~CV_MODIFIED;
+
+	cvar_map_t_insert(&cvar_map, variable->name, variable);
+
+	if (variable->flags & CV_NETVAR)
+		netvar_map_t_insert(&netvar_map, variable->netid, variable);
 }
 
 /** Finds the string value of a console variable.
@@ -1585,9 +1638,21 @@ 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--)
@@ -1790,7 +1855,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
 					if (newvalue == oldvalue)
 						break; // don't loop forever if there's none of a certain gametype
 
-					if (newvalue >= 0 && !mapheaderinfo[newvalue])
+					if (newvalue >= 0 && newvalue < NUMMAPS && !mapheaderinfo[newvalue])
 						continue; // Don't allocate the header.  That just makes memory usage skyrocket.
 
 				} while (!M_CanShowLevelInList(newvalue, gt));

src/command.h

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

src/config.h.in

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

src/console.c

@@ -46,23 +46,23 @@
 #ifdef HAVE_THREADS
 I_mutex con_mutex;
 
-// g_in_exiting_signal_handler is an evil hack
+// I_In_Exiting_Signal_Handler is an evil hack
 // to avoid infinite SIGABRT recursion in the signal handler
 // due to poisoned locks or mach-o kernel not supporting locks in signals
 // or something like that. idk
-#  define Lock_state()    if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
-#  define Unlock_state()  if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
-#else/*HAVE_THREADS*/
+#  define Lock_state()    if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); }
+#  define Unlock_state()  if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); }
+#else /*HAVE_THREADS*/
 #  define Lock_state()
 #  define Unlock_state()
-#endif/*HAVE_THREADS*/
+#endif /*HAVE_THREADS*/
 
 static boolean con_started = false; // console has been initialised
        boolean con_startup = false; // true at game startup, screen need refreshing
 static boolean con_forcepic = true; // at startup toggle console translucency when first off
        boolean con_recalc = false;  // set true when screen size has changed
 
-static tic_t con_tick; // console ticker for anim or blinking prompt cursor
+static tic_t con_tick; // console ticker for blinking prompt cursor
                         // con_scrollup should use time (currenttime - lasttime)..
 
 static boolean consoletoggle; // true when console key pushed, ticker will handle
@@ -103,6 +103,7 @@ static void CON_InputInit(void);
 static void CON_RecalcSize(void);
 static void CON_ChangeHeight(void);
 
+static void CONS_height_Change(void);
 static void CONS_hudlines_Change(void);
 static void CONS_backcolor_Change(void);
 
@@ -131,7 +132,7 @@ static CV_PossibleValue_t speed_cons_t[] = {{0, "MIN"}, {64, "MAX"}, {0, NULL}};
 static consvar_t cons_speed = {"con_speed", "8", CV_SAVE, speed_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 // percentage of screen height to use for console
-static consvar_t cons_height = {"con_height", "50", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL};
+static consvar_t cons_height = {"con_height", "50", CV_CALL|CV_SAVE, CV_Unsigned, CONS_height_Change, 0, NULL, NULL, 0, 0, NULL};
 
 static CV_PossibleValue_t backpic_cons_t[] = {{0, "translucent"}, {1, "picture"}, {0, NULL}};
 // whether to use console background picture, or translucent mode
@@ -169,8 +170,22 @@ static CV_PossibleValue_t menuhighlight_cons_t[] =
 };
 consvar_t cons_menuhighlight = {"menuhighlight", "Gametype Default", CV_SAVE, menuhighlight_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+consvar_t cons_consoleprintinmenu = {"consoleprintinmenu", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 static void CON_Print(char *msg);
 
+// Change the console height on demand
+//
+static void CONS_height_Change(void)
+{
+	Lock_state();
+
+	if (con_destlines > 0 && !con_startup) // If the console is open (as in, not using "bind")...
+		CON_ChangeHeight(); // ...update its height now, not only when it's closed and re-opened
+
+	Unlock_state();
+}
+
 //
 //
 static void CONS_hudlines_Change(void)
@@ -206,14 +221,6 @@ 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)
@@ -426,6 +433,7 @@ void CON_Init(void)
 		CV_RegisterVar(&cons_backpic);
 		CV_RegisterVar(&cons_backcolor);
 		CV_RegisterVar(&cons_menuhighlight);
+		CV_RegisterVar(&cons_consoleprintinmenu);
 		COM_AddCommand("bind", CONS_Bind_f);
 	}
 	else
@@ -586,12 +594,18 @@ static void CON_ChangeHeight(void)
 
 // Handles Console moves in/out of screen (per frame)
 //
-static void CON_MoveConsole(void)
+void CON_MoveConsole(void)
 {
 	static fixed_t fracmovement = 0;
 
 	Lock_state();
 
+	if (con_curlines == con_destlines)
+	{
+		Unlock_state();
+		return;
+	}
+
 	// instant
 	if (!cons_speed.value)
 	{
@@ -624,72 +638,191 @@ static 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())
+	if (I_UseNativeKeyboard() || ch >= (INT32)CON_GetShiftSize())
 		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'))
 	{
-		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];
-		}
+		return !!shiftdown != capslock ? CON_Shiftform()[ch] : ch;
 	}
-	else	// if we're holding shift we should still shift non letter symbols
+
+	// if we're holding shift we should still shift non letter symbols
+	if (shiftdown)
 	{
-		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 CON_Shiftform()[ch];
+	}
+
+	// AZERTY
+	if (cv_keyboardlayout.value == 3)
+	{
+		if (altdown & 0x2)
+			return french_altgrxform[ch];
+
+		return CON_FallBackFrSpecialLetter(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
 //
@@ -883,7 +1016,7 @@ boolean CON_Responder(event_t *ev)
 		return true;
 
 	// ctrl modifier -- changes behavior, adds shortcuts
-	if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
+	if (ctrldown && (cv_keyboardlayout.value != 3 || !altdown))
 	{
 		// show all cvars/commands that match what we have inputted
 		if (key == KEY_TAB)
@@ -1213,19 +1346,10 @@ void CON_LogMessage(const char *msg)
 // Console print! Wahooo! Lots o fun!
 //
 
-void CONS_Printf(const char *fmt, ...)
+static inline void CONS_PrintMsg(char *txt)
 {
-	va_list argptr;
-	static char *txt = NULL;
 	boolean startup;
 
-	if (txt == NULL)
-		txt = malloc(8192);
-
-	va_start(argptr, fmt);
-	vsnprintf(txt, 8192, fmt, argptr);
-	va_end(argptr);
-
 	// echo console prints to log file
 	DEBFILE(txt);
 
@@ -1251,6 +1375,21 @@ void CONS_Printf(const char *fmt, ...)
 	}
 }
 
+void CONS_Printf(const char *fmt, ...)
+{
+	va_list argptr;
+	static char *txt = NULL;
+
+	if (txt == NULL)
+		txt = malloc(8192);
+
+	va_start(argptr, fmt);
+	vsnprintf(txt, 8192, fmt, argptr);
+	va_end(argptr);
+
+	CONS_PrintMsg(txt);
+}
+
 void CONS_Alert(alerttype_t level, const char *fmt, ...)
 {
 	va_list argptr;
@@ -1279,9 +1418,7 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
 			break;
 	}
 
-	// I am lazy and I feel like just letting CONS_Printf take care of things.
-	// Is that okay?
-	CONS_Printf("%s", txt);
+	CONS_PrintMsg(txt);
 }
 
 void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1299,11 +1436,9 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 	vsnprintf(txt, 8192, fmt, argptr);
 	va_end(argptr);
 
-	// Again I am lazy, oh well
-	CONS_Printf("%s", txt);
+	CONS_PrintMsg(txt);
 }
 
-
 // Print an error message, and wait for ENTER key to continue.
 // To make sure the user has seen the message
 //
@@ -1315,6 +1450,8 @@ void CONS_Error(const char *msg)
 	// dirty quick hack, but for the good cause
 	while (I_GetKey() != KEY_ENTER)
 	{
+		I_HandleInterrupt();
+
 		// Sleep so we don't take too much of cpu usage
 		I_Sleep(1.f/TICRATE*1000);
 
@@ -1513,53 +1650,54 @@ static void CON_DrawConsole(void)
 	}
 
 	// draw console text lines from top to bottom
-	if (con_curlines < minheight)
-		return;
-
-	i = con_cy - con_scrollup;
-
-	// skip the last empty line due to the cursor being at the start of a new line
-	i--;
-
-	i -= (con_curlines - minheight) / charheight;
-
-	if (rendermode == render_none) return;
-
-	for (y = (con_curlines-minheight) % charheight; y <= con_curlines-minheight; y += charheight, i++)
+	if (con_curlines >= minheight)
 	{
-		INT32 x;
-		size_t c;
+		i = con_cy - con_scrollup;
 
-		p = (UINT8 *)&con_buffer[((i > 0 ? i : 0)%con_totallines)*con_width];
+		// skip the last empty line due to the cursor being at the start of a new line
+		i--;
 
-		for (c = 0, x = charwidth; c < con_width; c++, x += charwidth, p++)
+		i -= (con_curlines - minheight) / charheight;
+
+		if (rendermode == render_none)
+			return;
+
+		for (y = (con_curlines-minheight) % charheight; y <= con_curlines-minheight; y += charheight, i++)
 		{
-			while (*p & 0x80)
+			INT32 x;
+			size_t c;
+
+			p = (UINT8 *)&con_buffer[((i > 0 ? i : 0)%con_totallines)*con_width];
+
+			for (c = 0, x = charwidth; c < con_width; c++, x += charwidth, p++)
 			{
-				charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
-				p++;
-				c++;
+				while (*p & 0x80)
+				{
+					charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
+					p++;
+					c++;
+				}
+
+				if (c >= con_width)
+					break;
+
+				int emotelen;
+				emote_t *emote;
+
+				if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
+				{
+					M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
+					p += emotelen-1;
+					c += emotelen-1;
+					continue;
+				}
+				V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
 			}
-
-			if (c >= con_width)
-				break;
-
-			int emotelen;
-			emote_t *emote;
-
-			if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
-			{
-				M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
-				p += emotelen-1;
-				c += emotelen-1;
-				continue;
-			}
-			V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
 		}
 	}
 
 	// draw prompt if enough place (not while game startup)
-	if ((con_curlines == con_destlines) && (con_curlines >= minheight) && !con_startup)
+	if ((con_curlines >= (minheight-charheight)) && !con_startup)
 		CON_DrawInput();
 }
 
@@ -1584,13 +1722,12 @@ void CON_Drawer(void)
 	}
 
 	// console movement
-	if (con_curlines != con_destlines)
-		CON_MoveConsole();
+	CON_MoveConsole();
 
 	if (con_curlines > 0)
 		CON_DrawConsole();
 	else if (gamestate == GS_LEVEL || gamestate == GS_INTERMISSION || gamestate == GS_CUTSCENE || gamestate == GS_CREDITS
-		|| gamestate == GS_VOTING || gamestate == GS_EVALUATION || gamestate == GS_WAITINGPLAYERS)
+		|| gamestate == GS_VOTING || gamestate == GS_EVALUATION || gamestate == GS_WAITINGPLAYERS || (cons_consoleprintinmenu.value && gamestate == GS_TITLESCREEN))
 		CON_DrawHudlines();
 
 	Unlock_state();

src/console.h

@@ -13,6 +13,10 @@
 #ifndef __CONSOLE__
 #define __CONSOLE__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "d_event.h"
 #include "command.h"
 #include "i_threads.h"
@@ -36,6 +40,7 @@ extern INT32 con_destlines;
 extern UINT32 con_scalefactor; // console text scale factor
 
 extern consvar_t cons_backcolor, cons_menuhighlight;
+extern consvar_t cons_consoleprintinmenu;
 
 extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *orangemap,\
  *skymap, *goldmap, *lavendermap, *teamap, *steelmap, *pinkmap, *brownmap, *peachmap;
@@ -44,13 +49,13 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
 extern UINT8 *consolebgmap;
 
 INT32 CON_ShiftChar(INT32 ch);
-INT32 CON_ShitAndAltGrChar(INT32 ch);
 
 void CON_SetupBackColormap(void);
 void CON_ClearHUD(void); // clear heads up messages
 
 void CON_Ticker(void);
 void CON_Drawer(void);
+void CON_MoveConsole(void);
 void CONS_Error(const char *msg); // print out error msg, and wait a key
 
 // force console to move out
@@ -61,4 +66,8 @@ boolean CON_Ready(void);
 
 void CON_LogMessage(const char *msg);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

src/d_clisrv.h

@@ -516,7 +516,6 @@ typedef struct
 
 extern serverelem_t serverlist[MAXSERVERLIST];
 extern UINT32 serverlistcount;
-extern UINT32 serverlistultimatecount;
 extern INT32 mapchangepending;
 
 // Points inside doomcom
@@ -601,6 +600,8 @@ 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);
@@ -627,7 +628,6 @@ void CL_ClearPlayer(INT32 playernum);
 void CL_RemovePlayer(INT32 playernum, INT32 reason);
 void CL_QueryServerList(msg_server_t *list);
 void CL_UpdateServerList(void);
-void CL_TimeoutServerList(void);
 
 void CL_AbortConnection(void);
 
@@ -650,21 +650,25 @@ extern UINT8 playernode[MAXPLAYERS];
 
 extern boolean player_muted[MAXPLAYERS];
 
+extern UINT32 localplayerping;
+
 INT32 D_NumPlayers(void);
 
 void D_ResetTiccmds(void);
 
 tic_t GetLag(INT32 node);
 
-extern UINT8 hu_resynching;
+extern boolean hu_resynching;
 #ifdef SATURNPAK
-extern UINT8 hu_redownloadinggamestate;
+extern boolean hu_redownloadinggamestate;
 #endif
 extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
 
+#define SAVEGAMESIZE (768*1024)
+
 typedef struct rewind_s
 {
-	UINT8 savebuffer[(768*1024)];
+	UINT8 savebuffer[SAVEGAMESIZE];
 	tic_t leveltime;
 	size_t demopos;
 

src/d_main.c

@@ -79,6 +79,32 @@
 #include "core/memory.h"
 
 #include "lua_script.h"
+#include "lua_profile.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"
@@ -105,14 +131,15 @@ static size_t startuppwadcount = 0;
 // autoloading
 static char *autoloadwadfiles[MAX_WADFILES];
 static char *autoloadwadfilespost[MAX_WADFILES];
-static size_t autoloadcount = 0;
-static size_t postloadcount = 0;
+static size_t autoloadwadcount = 0;
+static size_t postloadwadcount = 0;
 //
 
 boolean devparm = false; // started game with -devparm
 
 boolean singletics = false; // timedemo
 boolean lastdraw = false;
+boolean intermissionbginit = false;
 
 #ifdef MOTIONBLUR
 INT32 postimgparam[MAXSPLITSCREENPLAYERS];
@@ -128,7 +155,7 @@ boolean music_disabled = false;
 INT32 debugload = 0;
 #endif
 
-char savegamename[256];
+char savegamename[256] = {};
 
 char srb2home[256] = ".";
 char srb2path[256] = ".";
@@ -249,21 +276,17 @@ static void D_Renderview(void)
 
 	R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL));
 
-	if (rendermode == render_soft)
+	if (rendermode == render_soft && cv_homremoval.value)
 	{
-		// if this is display player 1
-		if (cv_homremoval.value)
+		if (cv_homremoval.value == 1)
 		{
-			if (cv_homremoval.value == 1)
-			{
-				// Clear the software screen buffer to remove HOM
-				memset(vid.screens[0], 31, vid.width * vid.height);
-			}
-			else if (cv_homremoval.value == 2)
-			{
-				//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
-				memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
-			}
+			// Clear the software screen buffer to remove HOM
+			memset(vid.screens[0], 31, vid.width * vid.height);
+		}
+		else if (cv_homremoval.value == 2)
+		{
+			//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
+			memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
 		}
 	}
 
@@ -297,7 +320,6 @@ static void D_Renderview(void)
 					break;
 				default: // Initialize for P1
 					viewwindowy = viewwindowx = 0;
-					objectsdrawn = 0;
 					break;
 			}
 
@@ -308,19 +330,17 @@ static void D_Renderview(void)
 			}
 			else if (rendermode == render_soft)
 #endif
+			{
 				R_RenderPlayerView(&players[displayplayers[i]]);
-		}
-
-		if (rendermode == render_soft)
-		{
-			if (i == 0)
-				R_ApplyViewMorph();
 
+				if (i == 0)
+					R_ApplyViewMorph();
 #ifdef MOTIONBLUR
-			V_DoPostProcessor(i, postimgparam[i]);
+				V_DoPostProcessor(i, postimgparam[i]);
 #else
-			V_DoPostProcessor(i, 0);
+				V_DoPostProcessor(i, 0);
 #endif
+			}
 		}
 	}
 
@@ -344,6 +364,33 @@ 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;
@@ -509,16 +556,8 @@ static boolean D_Display(void)
 			PS_START_TIMING(ps_rendercalltime);
 			D_Renderview();
 			PS_STOP_TIMING(ps_rendercalltime);
-		}
 
-		if (lastdraw)
-		{
-			if (rendermode == render_soft)
-			{
-				VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
-			}
-
-			lastdraw = false;
+			D_MakeIntermissionBG();
 		}
 
 		PS_START_TIMING(ps_uitime);
@@ -620,6 +659,11 @@ static boolean D_Display(void)
 
 	    CON_Drawer(); // Ha, i LIED!
 
+		if (cv_lua_profile.value > 0)
+		{
+			LUA_RenderTimers();
+		}
+
 		PS_START_TIMING(ps_swaptime);
 		I_FinishUpdate(); // page flip or blit buffer
 		PS_STOP_TIMING(ps_swaptime);
@@ -639,7 +683,7 @@ void D_SRB2Loop(void)
 	tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
 	double deltatics = 0.0;
 	double deltasecs = 0.0;
-	UINT64 precision;
+	UINT64 precision = 0;
 
 	boolean interp = false;
 	boolean doDisplay = false;
@@ -684,8 +728,12 @@ void D_SRB2Loop(void)
 		precise_t elapsed;
 		precise_t enterprecise, finishprecise;
 
+		boolean ranwipe = false;
+
 		enterprecise = I_GetPreciseTime();
 
+		I_HandleInterrupt();
+
 		memset(&g_dc, 0, sizeof(g_dc));
 		Z_Frame_Reset();
 
@@ -693,8 +741,6 @@ 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)
@@ -758,11 +804,6 @@ void D_SRB2Loop(void)
 
 				doDisplay = true;
 			}
-
-			if (!dedicated)
-			{
-				G_DeviceLEDTick();
-			}
 		}
 
 		if (interp)
@@ -792,9 +833,9 @@ void D_SRB2Loop(void)
 			}
 			else if (!dedicated)
 			{
-				// always update console and hud
-				// otherwise it may take minutes to open it
-				CON_Drawer();
+				// always update console movement
+				// otherwise it will takes literal ages to open
+				CON_MoveConsole();
 			}
 		}
 
@@ -804,6 +845,13 @@ void D_SRB2Loop(void)
 		if (takescreenshot)
 			M_DoScreenShot();
 
+#ifndef DEDICATED
+		if (!dedicated && renderisnewtic)
+		{
+			G_DeviceLEDTick();
+		}
+#endif
+
 		// consoleplayer -> displayplayers (hear sounds from viewpoint)
 		S_UpdateSounds(); // move positional sounds
 
@@ -882,10 +930,11 @@ void D_ClearState(void)
 
 	// okay, stop now
 	// (otherwise the game still thinks we're playing!)
+#ifdef HAVE_CURL
 	CURLAbortFile();
+#endif
 	SV_StopServer();
 	SV_ResetServer();
-	serverlistultimatecount = 0;
 
 	for (i = 0; i < MAXPLAYERS; i++)
 		CL_ClearPlayer(i);
@@ -947,6 +996,9 @@ void D_ClearState(void)
 //
 void D_StartTitle(void)
 {
+	if (dedicated)
+		I_Error("D_StartTitle is called on dedicated server");
+
 	D_ClearState();
 	multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao
 	F_StartTitleScreen();
@@ -1008,25 +1060,38 @@ static INT32 D_DetectFileType(const char* filename)
 }
 
 // autoload that shit
-static void D_AutoloadFile(const char *file, char **filearray, size_t index)
+static void D_AutoloadFile(const char *file, char **filearray, size_t *index)
 {
 	char *newfile;
 	INT32 fileType = D_DetectFileType(file);
 
+	if (*index >= MAX_WADFILES)
+	{
+		CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
+		return;
+	}
+
 	if (!fileType)
 	{
 		CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
 		return;
 	}
 
+	if (fileType == 1)
+	{
+		CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
+		return;
+	}
+
 	if (fileType <= 6)
 	{
 		newfile = malloc(strlen(file) + 1);
 		if (!newfile)
-			I_Error("No more free memory to AutoloadFile %s",file);
+			I_Error("D_AutoloadFile: No more free memory to autoload file %s", file);
 
 		strcpy(newfile, file);
-		filearray[index] = newfile;
+		filearray[*index] = newfile;
+		(*index)++;
 	}
 	else
 	{
@@ -1069,7 +1134,7 @@ static void D_FindAddonsToAutoload(void)
 	// If the file is found, run our shit
 	if (!autoloadconfigfile) // nope outta here
 	{
-		autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
+		autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
 		return;
 	}
 
@@ -1095,27 +1160,34 @@ static void D_FindAddonsToAutoload(void)
 		if (newline)
 			*newline = '\0';
 
+		// ok so theres still issues with players adding stuff to autoload by accident
+		// sometimes this stuff contains maps
+		// you can probably imagine how that goes in a netgame....
+		if (W_CheckAutoLoadContainsMap(wadsToAutoload))
+		{
+			CONS_Alert(CONS_WARNING, "Autoload: file %s contains map data, this WILL cause crashes and desynchs! skipping...\n", wadsToAutoload);
+			continue;
+		}
+
 		if (!postload && W_CheckPostLoadList(wadsToAutoload))
 		{
-			CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
+			CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload);
 			postload = true;
 		}
 
 		// LOAD IT
 		if (!postload)
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
-			autoloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount);
 		}
 		else
 		{
-			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
-			postloadcount++;
+			D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount);
 		}
 	}
 
-	autoloadwadfiles[autoloadcount] = NULL;
-	autoloadwadfilespost[postloadcount] = NULL;
+	autoloadwadfiles[autoloadwadcount] = NULL;
+	autoloadwadfilespost[postloadwadcount] = NULL;
 
 	// we dont want memory leaks around here do we?
 	fclose(autoloadconfigfile);
@@ -1124,7 +1196,7 @@ static void D_FindAddonsToAutoload(void)
 static void D_AddAutoloadFiles(void)
 {
 	// nothing to autoload
-	if (autoloadcount == 0)
+	if (autoloadwadcount == 0)
 		return;
 
 	CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1132,15 +1204,15 @@ static void D_AddAutoloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
 		CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfiles, autoloadcount);
+	D_CleanFile(autoloadwadfiles, autoloadwadcount);
 
-	autoloadcount = 0;
+	autoloadwadcount = 0;
 }
 
 void D_AddPostloadFiles(void)
 {
 	// nothing to postload
-	if (postloadcount == 0 || !netgame)
+	if (postloadwadcount == 0 || !netgame)
 		return;
 
 	CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1148,9 +1220,9 @@ void D_AddPostloadFiles(void)
 	if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
 		CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
 
-	D_CleanFile(autoloadwadfilespost, postloadcount);
+	D_CleanFile(autoloadwadfilespost, postloadwadcount);
 
-	postloadcount = 0;
+	postloadwadcount = 0;
 }
 
 // ==========================================================================
@@ -1159,7 +1231,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))
 	{
@@ -1187,17 +1259,13 @@ static void IdentifyVersion(void)
 #endif
 
 	char tempsrb2path[256] = ".";
-	getcwd(tempsrb2path, 256);
+	if (getcwd(tempsrb2path, 256) == NULL)
+		strcpy(tempsrb2path, ".");
 
 	// get the current directory (possible problem on NT with "." as current dir)
 	if (!srb2waddir)
 	{
-		if (tempsrb2path[0])
-			srb2waddir = tempsrb2path;
-		else
-		{
-			srb2waddir = ".";
-		}
+		srb2waddir = tempsrb2path;
 	}
 
 #if (1) // reduce the amount of findfile by only using full cwd in this func
@@ -1291,20 +1359,24 @@ static void IdentifyVersion(void)
 //
 // search for maps
 //
-static void D_CheckMaps(boolean checkreplaced)
+static void D_CheckMapReplacements(boolean pwad)
 {
 	INT32 i;
 	char *name;
 	UINT16 wadnum;
 	lumpinfo_t *lumpinfo;
+	size_t numfiles;
 
-	for (wadnum = 0; wadnum < mainwads; wadnum++)
+	wadnum = pwad ? (mainwads+1) : 0;
+	numfiles = pwad ? numwadfiles : mainwads;
+
+	for (; wadnum < numfiles; wadnum++)
 	{
 		lumpinfo = wadfiles[wadnum]->lumpinfo;
 		for (i = 0; i < wadfiles[wadnum]->numlumps; i++, lumpinfo++)
 		{
 			name = lumpinfo->name;
-			P_CheckMapReplacements(name, checkreplaced);
+			P_CheckMapReplacements(name, pwad);
 		}
 	}
 }
@@ -1340,8 +1412,6 @@ 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
@@ -1371,7 +1441,6 @@ 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; }
@@ -1530,20 +1599,6 @@ 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
@@ -1618,12 +1673,6 @@ void D_SRB2Main(void)
 	strcpy(srb2, "SRB2Kart");
 	D_MakeTitleString(srb2);
 
-#if defined (__OS2__) && !defined (HAVE_SDL)
-	// set PM window title
-	snprintf(pmData->title, sizeof (pmData->title), "SRB2Kart" VERSIONSTRING ": %s", title);
-	pmData->title[sizeof (pmData->title) - 1] = '\0';
-#endif
-
 	if (devparm)
 		CONS_Printf(M_GetText("Development mode ON.\n"));
 
@@ -1747,10 +1796,6 @@ 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");
 
@@ -1794,17 +1839,19 @@ void D_SRB2Main(void)
 	// conversion sometimes needs the palette
 	V_ReloadPalette();
 
-	D_CheckMaps(false);
+	D_CheckMapReplacements(false);
 
-	W_InitMultipleFiles(startuppwads, startuppwadcount, true);
-
-	// Only search for pwad maps if we actually have a pwad added
 	if (startuppwadcount > 0)
 	{
-		D_CheckMaps(true);
+		CONS_Printf("W_InitMultipleFiles(): Adding extra PWADs.\n");
+		W_InitMultipleFiles(startuppwads, startuppwadcount, true);
+
+		// Only search for pwad maps if we actually have a pwad added
+		D_CheckMapReplacements(true);
+
+		D_CleanFile(startuppwads, startuppwadcount);
 	}
 
-	D_CleanFile(startuppwads, startuppwadcount);
 	startuppwadcount = 0;
 
 	cht_Init();
@@ -1870,7 +1917,8 @@ void D_SRB2Main(void)
 	if (M_CheckParm("-warp") && M_IsNextParm())
 	{
 		const char *word = M_GetNextParm();
-		pstartmap = G_FindMapByNameOrCode(word, 0);
+		pstartmap = G_FindMapByNameOrCode(word, NULL);
+
 		if (! pstartmap)
 			I_Error("Cannot find a map remotely named '%s'\n", word);
 		else
@@ -1890,7 +1938,7 @@ void D_SRB2Main(void)
 	CONS_Printf("R_Init(): Init SRB2 refresh daemon.\n");
 	R_Init();
 
-#if SOUND==SOUND_DUMMY
+#if SOUND == SOUND_DUMMY
 	sound_disabled = true;
 	music_disabled = true;
 #else
@@ -2003,9 +2051,13 @@ void D_SRB2Main(void)
 	if (M_CheckProtoParam("replay"))
 	{
 		const char *replayurl = M_GetProtoParam();
-		char *replayname = strrchr(replayurl, '/');
 
-		if (!replayname || !replayurl)
+		if (!replayurl)
+			I_Error("REPLAY: Invalid URL.");
+
+		gconst char *replayname = strrchr(replayurl, '/');
+
+		if (!replayname)
 			I_Error("REPLAY: Invalid URL.");
 
 #define REPLAYDIR "/DownloadedReplays/"
@@ -2119,8 +2171,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
 	}

src/d_main.h

@@ -38,8 +38,6 @@ 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

src/d_net.c

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

src/d_net.h

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

src/d_netcmd.h

@@ -21,10 +21,7 @@ extern "C" {
 
 #include "command.h"
 
-void SendWeaponPref(void);
-void SendWeaponPref2(void);
-void SendWeaponPref3(void);
-void SendWeaponPref4(void);
+void SendWeaponPref(UINT8 splitplayer);
 
 // console vars
 extern consvar_t cv_playername;
@@ -54,10 +51,6 @@ extern consvar_t cv_mousevisible;
 //WTF
 extern consvar_t cv_mouseturn;
 extern consvar_t cv_usejoystick[4]; //MAXSPLITSCREENPLAYERS
-#ifdef LJOYSTICK
-extern consvar_t cv_joyport;
-extern consvar_t cv_joyport2;
-#endif
 extern consvar_t cv_joyscale[4]; //MAXSPLITSCREENPLAYERS
 
 // normally in p_mobj but the .h is not read
@@ -96,11 +89,6 @@ 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;
@@ -158,8 +146,10 @@ 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;
+extern consvar_t cv_spinoutroll;
 
 extern consvar_t cv_showlapemblem;
 
@@ -199,6 +189,8 @@ extern consvar_t cv_ps_thinkframe_page;
 extern consvar_t cv_ps_samplesize;
 extern consvar_t cv_ps_descriptor;
 
+extern consvar_t cv_lua_profile;
+
 extern consvar_t cv_director, cv_kartdebugdirector, cv_showdirectorhud;
 
 extern consvar_t cv_showtrackaddon;
@@ -295,7 +287,7 @@ typedef union {
 // add game commands, needs cleanup
 void D_RegisterServerCommands(void);
 void D_RegisterClientCommands(void);
-void D_SendPlayerConfig(void);
+void D_SendPlayerConfig(UINT8 splitplayer);
 void Command_ExitGame_f(void);
 void Command_Retry_f(void);
 void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore

src/d_netfil.c

@@ -116,6 +116,8 @@ static I_mutex downloadmutex;
 #endif
 char downloaddir[512] = "DOWNLOAD";
 
+INT32 addontypes[NUMADDONTYPES] = {0};
+
 file_download_t filedownload = {};
 
 #ifdef HAVE_CURL
@@ -131,8 +133,12 @@ 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.
@@ -161,7 +167,9 @@ UINT8 *PutFileNeeded(UINT16 firstfile)
 			continue;
 		}
 
-		nameonly(strcpy(wadfilename, wadfiles[i]->filename));
+		strncpy(wadfilename, wadfiles[i]->filename, MAX_WADPATH);
+		wadfilename[MAX_WADPATH-1] = '\0';
+		nameonly(wadfilename);
 
 		// Look below at the WRITE macros to understand what these numbers mean.
 		const size_t len = strlen(wadfilename) + 1;
@@ -223,8 +231,11 @@ 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
-		READSTRINGN(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name
+		READSTRINGL(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);
 	}
 }
 
@@ -248,9 +259,10 @@ void CL_PrepareDownloadSaveGame(const char *tmpsave)
   */
 boolean CL_CheckDownloadable(void)
 {
-	UINT8 i,dlstatus = 0;
+	UINT8 i, dlstatus = 0;
 
 	for (i = 0; i < fileneedednum; i++)
+	{
 		if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
 		{
 			if (fileneeded[i].willsend == 1)
@@ -261,6 +273,7 @@ boolean CL_CheckDownloadable(void)
 			else //if (fileneeded[i].willsend == 2)
 				dlstatus = 2;
 		}
+	}
 
 	// Downloading locally disabled
 	if (!dlstatus && M_CheckParm("-nodownload"))
@@ -271,15 +284,17 @@ boolean CL_CheckDownloadable(void)
 
 	// not downloadable, put reason in console
 	CONS_Alert(CONS_NOTICE, M_GetText("You need additional files to connect to this server:\n"));
+
 	for (i = 0; i < fileneedednum; i++)
+	{
 		if (fileneeded[i].status != FS_FOUND && fileneeded[i].status != FS_OPEN)
 		{
 			CONS_Printf(" * \"%s\" (%dK)", fileneeded[i].filename, fileneeded[i].totalsize >> 10);
 
-				if (fileneeded[i].status == FS_MD5SUMBAD)
-					CONS_Printf(M_GetText(" wrong version, md5: "));
-				else
-					CONS_Printf(M_GetText(" not found, md5: "));
+			if (fileneeded[i].status == FS_MD5SUMBAD)
+				CONS_Printf(M_GetText(" wrong version, md5: "));
+			else
+				CONS_Printf(M_GetText(" not found, md5: "));
 
 			{
 				INT32 j;
@@ -290,6 +305,7 @@ boolean CL_CheckDownloadable(void)
 			}
 			CONS_Printf("\n");
 		}
+	}
 
 	switch (dlstatus)
 	{
@@ -303,6 +319,7 @@ boolean CL_CheckDownloadable(void)
 			CONS_Printf(M_GetText("All files downloadable, but you have chosen to disable downloading locally.\n"));
 			break;
 	}
+
 	return false;
 }
 
@@ -540,7 +557,7 @@ INT32 CL_CheckFiles(void)
 		if (fileneeded[i].status != FS_OPEN)
 			filestoload++;
 
-		if (fileneeded[i].status != FS_NOTCHECKED) //since we're running this over multiple tics now, its possible for us to come across files checked in previous tics
+		if (fileneeded[i].status != FS_NOTCHECKED) // since we're running this over multiple tics now, its possible for us to come across files checked in previous tics
 			continue;
 
 		CONS_Debug(DBG_NETPLAY, "searching for '%s' ", fileneeded[i].filename);
@@ -548,14 +565,18 @@ INT32 CL_CheckFiles(void)
 		// Check in already loaded files
 		for (j = mainwads+1; j < numwadfiles; j++)
 		{
-			nameonly(strcpy(wadfilename, wadfiles[j]->filename));
-
-			if (fasticmp(wadfilename, fileneeded[i].filename) &&
-				!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
+			if (!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
 			{
-				CONS_Debug(DBG_NETPLAY, "already loaded\n");
-				fileneeded[i].status = FS_OPEN;
-				return 4;
+				strncpy(wadfilename, wadfiles[j]->filename, MAX_WADPATH);
+				wadfilename[MAX_WADPATH-1] = '\0';
+				nameonly(wadfilename);
+
+				if (fasticmp(wadfilename, fileneeded[i].filename))
+				{
+					CONS_Debug(DBG_NETPLAY, "already loaded\n");
+					fileneeded[i].status = FS_OPEN;
+					return 4;
+				}
 			}
 		}
 
@@ -573,6 +594,48 @@ 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)
 {
@@ -594,7 +657,7 @@ boolean CL_LoadServerFiles(void)
 		else
 		{
 			const char *s;
-			switch(fileneeded[i].status)
+			switch (fileneeded[i].status)
 			{
 			case FS_NOTFOUND:
 				s = "FS_NOTFOUND";
@@ -637,7 +700,7 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
 
 	char wadfilename[MAX_WADPATH];
 
-	if (cv_noticedownload.value)
+	if (cv_noticedownload.value && I_GetNodeAddress)
 		CONS_Printf("Sending file \"%s\" (id %d) to node %d (%s)\n", filename, fileid, node, I_GetNodeAddress(node));
 
 	// Find the last file in the list and set a pointer to its "next" field
@@ -662,7 +725,9 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
 	// Look for the requested file through all loaded files
 	for (wadnum = 0; wadfiles[wadnum]; wadnum++)
 	{
-		strlcpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH);
+		// im a certified strlcpy hater
+		strncpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH);
+		wadfilename[MAX_WADPATH-1] = '\0';
 		nameonly(wadfilename);
 
 		if (fasticmp(wadfilename, p->id.filename))
@@ -958,7 +1023,7 @@ void Got_Filetxpak(void)
 		|| fastcmp(filename, "music.kart")
 		|| fastcmp(filename, "patch.kart")
 		))
-		I_Error("Tried to download \"%s\"", filename);
+		I_Error("Tried to download base-game file: \"%s\"", filename);
 
 	if (filenum >= fileneedednum)
 	{
@@ -1015,23 +1080,23 @@ void Got_Filetxpak(void)
 	{
 		const char *s;
 
-		switch(file->status)
+		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);
@@ -1079,12 +1144,14 @@ void CloseNetFile(void)
 
 	// Receiving a file?
 	for (i = 0; i < MAX_WADFILES; i++)
+	{
 		if (fileneeded[i].status == FS_DOWNLOADING && fileneeded[i].file)
 		{
 			fclose(fileneeded[i].file);
 			// File is not complete delete it
 			remove(fileneeded[i].filename);
 		}
+	}
 
 	// Remove PT_FILEFRAGMENT from acknowledge list
 	Net_AbortPacketType(PT_FILEFRAGMENT);
@@ -1098,17 +1165,16 @@ void nameonly(char *s)
 	void *ns;
 
 	for (j = strlen(s); j != (size_t)-1; j--)
+	{
 		if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
 		{
 			ns = &(s[j+1]);
 			len = strlen(ns);
-#if 0
-				memcpy(s, ns, len+1);
-#else
-				memmove(s, ns, len+1);
-#endif
+			memmove(s, ns, len+1);
+
 			return;
 		}
+	}
 }
 
 // Returns the length in characters of the last element of a path.
@@ -1142,7 +1208,7 @@ filestatus_t checkfilemd5(char *filename, const UINT8 *wantedmd5sum)
 	fhandle = fopen(filename, "rb");
 	if (fhandle)
 	{
-		md5_stream(fhandle,md5sum);
+		md5_stream(fhandle, md5sum);
 		fclose(fhandle);
 		if (!memcmp(wantedmd5sum, md5sum, 16))
 			return FS_FOUND;
@@ -1162,8 +1228,12 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
 	filestatus_t homecheck; // store result of last file search
 	boolean badmd5 = false; // store whether md5 was bad from either of the first two searches (if nothing was found in the third)
 
-	// skip for startup, our mainwads wont be in there
-	if (loaded_config)
+	// see IdentifyVersion
+	// Iwads skip findfile due to passing fullpath to W_OpenWadFile
+#if 0
+	// skip for Iwads, as they wont be in there
+	if (!startupiwadcount)
+#endif
 	{
 		if (cv_addons_option.value == 3 && *cv_addons_folder.string != '\0')
 		{
@@ -1300,6 +1370,7 @@ void CURLPrepareFile(const char* url, int dfilenum)
 	if (!multi_handle)
 	{
 		cc = curl_global_init(CURL_GLOBAL_ALL);
+
 		if (cc < 0)
 		{
 			I_OutputMsg("libcurl: curl_global_init() returned %d\n", cc);
@@ -1308,6 +1379,7 @@ void CURLPrepareFile(const char* url, int dfilenum)
 		{
 			multi_handle = curl_multi_init();
 		}
+
 		if (!multi_handle)
 		{
 			I_OutputMsg("libcurl: curl_multi_init() failed\n");
@@ -1436,7 +1508,7 @@ void CURLAbortFile(void)
 #endif
 }
 
-void CURLGetFile(void)
+static void CURLGetFile(void)
 {
 #ifdef HAVE_THREADS
 	I_lock_mutex(&downloadmutex);
@@ -1478,7 +1550,8 @@ void CURLGetFile(void)
 				e = m->easy_handle;
 				easyres = m->data.result;
 
-				char *filename = Z_StrDup(curl_realname);
+				char *filename = malloc(strlen(curl_realname)+1);
+				strcpy(filename, curl_realname);
 				nameonly(filename);
 
 				if (easyres != CURLE_OK)
@@ -1516,7 +1589,7 @@ void CURLGetFile(void)
 					}
 				}
 
-				Z_Free(filename);
+				free(filename);
 				curl_curfile->file = NULL;
 				filedownload.remaining--;
 				mc = curl_multi_remove_handle(multi_handle, e);

src/d_netfil.h

@@ -40,6 +40,15 @@ 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?
@@ -51,11 +60,13 @@ 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
 {
@@ -91,6 +102,7 @@ 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);
@@ -119,7 +131,6 @@ size_t nameonlylength(const char *s);
 #ifdef HAVE_CURL
 void CURLPrepareFile(const char* url, int dfilenum);
 void CURLAbortFile(void);
-void CURLGetFile(void);
 HTTP_login * CURLGetLogin (const char *url, HTTP_login ***return_prev_next);
 size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream);
 #endif

src/d_player.h

@@ -566,6 +566,8 @@ typedef struct player_s
 	fixed_t fovadd; // adjust FOV for hw rendering
 
 	SINT8 driftlevel; // just for controller rumble for now
+
+	UINT8 stairjank;
 } player_t;
 
 #endif

src/d_ticcmd.h

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

src/dedicated/CMakeLists.txt

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

src/dedicated/i_system.c

@@ -167,6 +167,8 @@ static char returnWadPath[256];
 #include "../i_video.h"
 #include "../i_sound.h"
 #include "../i_system.h"
+#include "../i_time.h"
+#include "../i_net.h"
 #include "../screen.h" //vid.WndParent
 #include "../d_net.h"
 #include "../g_game.h"
@@ -178,10 +180,6 @@ static char returnWadPath[256];
 
 #include "../m_argv.h"
 
-#ifdef MAC_ALERT
-#include "macosx/mac_alert.h"
-#endif
-
 #include "../d_main.h"
 
 #if !defined(NOMUMBLE) && defined(HAVE_MUMBLE)
@@ -196,8 +194,6 @@ UINT8 keyboard_started = false;
 
 #ifdef HAVE_TERMIOS
 // TERMIOS console code from Quake3: thank you!
-boolean stdin_active = true;
-
 typedef struct
 {
 	size_t cursor;
@@ -699,11 +695,7 @@ void I_JoyScale4(void)
 
 
 */
-void I_ShutdownJoystick(void)
-{
-}
-
-void I_GetJoystickEvents(UINT8 index)
+void I_ShutdownJoystick(UINT8 index)
 {
 	(void)index;
 }
@@ -743,6 +735,22 @@ 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;
@@ -992,7 +1000,7 @@ void I_SleepDuration(precise_t duration)
 #endif
 }
 
-boolean g_in_exiting_signal_handler = false;
+static volatile sig_atomic_t g_in_exiting_signal_handler = false;
 
 static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
 {
@@ -1015,8 +1023,13 @@ 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 kill
-			sigmsg = ("SIGTERM - SRB2Kart-Saturn was terminated by a kill signal.");
+		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.");
 			break;
 #endif
 #ifdef SIGBREAK
@@ -1056,6 +1069,11 @@ static void I_ReportSignal(int num, int coredumped)
 	I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
 }
 
+boolean I_In_Exiting_Signal_Handler(void)
+{
+	return g_in_exiting_signal_handler;
+}
+
 #ifndef NEWSIGNALHANDLER
 FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 {
@@ -1075,11 +1093,17 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
 }
 #endif
 
-FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
+static volatile sig_atomic_t interrupted = 0;
+
+boolean I_Interrupted(void)
 {
-	signal(num, SIG_DFL); //default signal action
-	raise(num);
-	I_Quit();
+	return interrupted;
+}
+
+static void quit_handler(int num)
+{
+	(void)num;
+	interrupted = 1;
 }
 
 #ifdef HAVE_LIBBACKTRACE
@@ -1338,18 +1362,28 @@ 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);
@@ -1409,8 +1443,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
@@ -1426,16 +1460,18 @@ 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);
 }
 
@@ -1481,7 +1517,6 @@ FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
 
 			I_OutputMsg("SRB2Kart %s Recursive Error", buffer);
 
-			W_Shutdown();
 			exit(-1); // recursive errors detected
 		}
 	}
@@ -1499,8 +1534,6 @@ 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
@@ -1516,8 +1549,6 @@ 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
@@ -1623,9 +1654,10 @@ void I_ShutdownSystem(void)
 {
 	INT32 c;
 
-#ifndef NEWSIGNALHANDLER
-	I_ShutdownConsole();
+#ifdef NEWSIGNALHANDLER
+	if (M_CheckParm("-nofork"))
 #endif
+		I_ShutdownConsole();
 
 	for (c = MAX_QUIT_FUNCS-1; c >= 0; c--)
 		if (quit_funcs[c])

src/dehacked.h

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

src/doomdata.h

@@ -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.
@@ -81,10 +81,12 @@ typedef struct
 	INT16 flags;
 	INT16 special;
 	INT16 tag;
-	// sidenum[1] will be 0xffff if one sided
+	// sidenum[1] will be NO_INDEX if one sided
 	UINT16 sidenum[2];
 } ATTRPACK maplinedef_t;
 
+#define NO_INDEX 0xffff
+
 //
 // LineDef attributes.
 //

src/doomdef.h

@@ -40,22 +40,45 @@
 #define ASMCALL
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "doomtype.h"
 
+#ifdef __cplusplus               /* Only when compiled as C++ */
+    #include <algorithm>        /* std::min, std::max, std::sort, … */
+#endif
+
+#ifdef __cplusplus
+// Force libc++ to expose std::min/std::max even when <cmath> is included first (Apple clang quirk)
+#ifndef _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
+#define _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
+#endif
+#ifndef _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#endif
+
+// Optional: only try <version> if it actually exists (newer Xcode)
+#if __has_include(<version>)
+#include <version>
+#endif
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <cstring>
+#include <climits>
+
+extern "C" {
+#else
+#include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <string.h>
 
-#define _USE_MATH_DEFINES // fixes M_PI errors in r_plane.c for Visual Studio
-#ifdef __cplusplus
-#include <cmath>
-#else
-#include <math.h>
+#include <limits.h>
 #endif
 
 #include <sys/types.h>
@@ -107,8 +130,8 @@ extern char  logfilename[1024];
 #else
 #define VERSION    1 // Game version
 #define SUBVERSION 6 // more precise version number
-#define VERSIONSTRING "Saturn v9.1"
-#define VERSIONSTRINGW L"Saturn v9.1"
+#define VERSIONSTRING "Saturn v9.3"
+#define VERSIONSTRINGW L"Saturn v9.3"
 
 #define SATURN_TESTING // comment out for saturn release builds!
 
@@ -493,22 +516,6 @@ extern boolean capslock;
 // i_system.c, replace getchar() once the keyboard has been appropriated
 INT32 I_GetKey(void);
 
-/* http://www.cse.yorku.ca/~oz/hash.html */
-static inline
-UINT32 quickncasehash (const char *p, size_t n)
-{
-	size_t i = 0;
-	UINT32 x = 5381;
-
-	while (i < n && p[i])
-	{
-		x = (x * 33) ^ tolower(p[i]);
-		i++;
-	}
-
-	return x;
-}
-
 #ifndef __cplusplus
 #ifndef min // Double-Check with WATTCP-32's cdefs.h
 #define min(x, y) (((x) < (y)) ? (x) : (y))
@@ -566,6 +573,13 @@ UINT32 quickncasehash (const char *p, size_t n)
 // NOTE: you WILL have nasal troubles if the variable is not initialized
 #define CLEANUP(f) __attribute__((__cleanup__(f)))
 
+// the GNU constructor and destructor attributes
+// The constructor attribute causes the function to be called automatically before execution enters main ().
+// Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called.
+// Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.
+#define CONSTRUCTOR __attribute__((constructor, used))
+#define DESTRUCTOR __attribute__((destructor, used))
+
 // An assert-type mechanism.
 #ifdef PARANOIA
 #define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__))
@@ -588,6 +602,13 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
 // None of these that are disabled in the normal build are guaranteed to work perfectly
 // Compile them at your own risk!
 
+// undefine to enable fixes and features that are not vanilla compatible
+#define COMPAT_VANILLA
+// if we build with 32 player (or more!) support we dont need to care vanilla compat
+#if MAXPLAYERS > 16
+#undef COMPAT_VANILLA
+#endif
+
 //-- SATURN __
 /// Detect if a client is on Saturn in the clientconfig.
 /// To seperately allow them to join or block joining from vanilla clients.
@@ -652,6 +673,13 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
 #undef UPDATE_ALERT
 #endif
 
+// overwrite some of those
+// when not compiling in vanilla compat mode
+#ifndef COMPAT_VANILLA
+	#define SATURNJOIN
+	#define SATURNPAK
+#endif
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/doomstat.h

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

src/doomtype.h

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

src/f_finale.c

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

src/f_wipe.c

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

src/fastcmp.h

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

src/filesrch.c

@@ -49,7 +49,7 @@ size_t menupathindex[menudepth] = {};
 size_t menudepthleft = menudepth;
 
 char menusearchbuf[MAXSTRINGLENGTH+1];
-textinput_t menusearch;
+textinput_t menusearch = {};
 
 char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
 size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
@@ -111,10 +111,12 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
 	char *searchname;
 	int depthleft = maxsearchdepth;
 	char searchpath[MAXFILEPATH];
-	size_t *searchpathindex;
+	size_t *searchpathindex = NULL;
 
 	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;
@@ -271,10 +273,13 @@ static boolean filemenucmp(char *haystack, char *needle)
 {
 	static char localhaystack[128];
 	strlcpy(localhaystack, haystack, 128);
+
 	if (!cv_addons_search_case.value)
 		strupr(localhaystack);
+
 	if (cv_addons_search_type.value)
-		return (strstr(localhaystack, needle) != 0);
+		return (strstr(localhaystack, needle) != NULL);
+
 	return (!strncmp(localhaystack, needle, menusearch.length));
 }
 
@@ -314,8 +319,7 @@ void closefilemenu(boolean validsize)
 		coredirmenu = NULL;
 	}
 
-	if (refreshdirname)
-		Z_Free(refreshdirname);
+	Z_Free(refreshdirname);
 	refreshdirname = NULL;
 }
 
@@ -343,8 +347,7 @@ void searchfilemenu(char *tempname)
 
 	if (!menusearch.length)
 	{
-		if (dirmenu)
-			Z_Free(dirmenu);
+		Z_Free(dirmenu);
 		dirmenu = coredirmenu;
 		sizedirmenu = sizecoredirmenu;
 
@@ -386,8 +389,8 @@ void searchfilemenu(char *tempname)
 				I_Error("searchfilemenu(): could not create \"No results...\".");
 		sizedirmenu = 1;
 		dir_on[menudepthleft] = 0;
-		if (tempname)
-			Z_Free(tempname);
+		Z_Free(tempname);
+
 		return;
 	}
 
@@ -502,8 +505,8 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
 	{
 		closedir(dirhandle);
 		closefilemenu(false);
-		if (tempname)
-			Z_Free(tempname);
+		Z_Free(tempname);
+
 		return false;
 	}
 

src/g_demo.h

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

src/g_game.c

@@ -61,17 +61,11 @@
 
 gameaction_t gameaction = 0;
 gamestate_t gamestate = GS_NULL;
-UINT8 ultimatemode = false;
 
 boolean botingame = false;
 UINT8 botskin = 0;
 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";
@@ -90,7 +84,6 @@ 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;
@@ -100,7 +93,6 @@ 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;
@@ -112,7 +104,6 @@ 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)
@@ -132,7 +123,7 @@ UINT8 skincolor_bluering = SKINCOLOR_STEEL;
 tic_t countdowntimer = 0;
 boolean countdowntimeup = false;
 
-cutscene_t *cutscenes[128];
+cutscene_t *cutscenes[128] = {};
 
 INT16 nextmapoverride = 0;
 boolean skipstats = false;
@@ -144,7 +135,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] = {};
@@ -190,9 +181,6 @@ 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
@@ -210,10 +198,7 @@ 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;
@@ -228,7 +213,7 @@ tic_t racecountdown = 0, exitcountdown = 0; // for racing
 fixed_t gravity = 0;
 fixed_t mapobjectscale = FRACUNIT;
 
-struct maplighting maplighting;
+struct maplighting maplighting = {};
 
 INT16 autobalance = 0; //for CTF team balance
 INT16 teamscramble = 0; //for CTF team scramble
@@ -312,6 +297,8 @@ consvar_t cv_pauseifunfocused = {"pauseifunfocused", "Yes", CV_SAVE, CV_YesNo, N
 static CV_PossibleValue_t songcredits_cons_t[] = {{0, "Off"}, {1, "Default"}, {2, "Box"}, {0, NULL}};
 consvar_t cv_songcredits = {"songcredits", "Default", CV_SAVE, songcredits_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+consvar_t cv_pausesongcredits = {"pausesongcredits", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 // Show "FREE PLAY" when you're alone. :(
 consvar_t cv_showfreeplay = { "showfreeplay", "Yes", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -452,6 +439,14 @@ consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS] = {
 	{"litesteer4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
 };
 
+//static CV_PossibleValue_t autoaccelcons_t[] = {{0, "Off"}, {1, "Manual"}, {2, "Automatic"}, {0, NULL}};
+consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS] = {
+	{"kartautoaccel",  "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel3", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
+	{"kartautoaccel4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
+};
+
 static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}};
 consvar_t cv_driftsparkpulse = {"driftsparkpulse", "1.4", CV_FLOAT | CV_SAVE, driftsparkpulse_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -513,11 +508,8 @@ void G_ClearRecords(void)
 	INT16 i;
 	for (i = 0; i < NUMMAPS; ++i)
 	{
-		if (mainrecords[i])
-		{
-			Z_Free(mainrecords[i]);
-			mainrecords[i] = NULL;
-		}
+		Z_Free(mainrecords[i]);
+		mainrecords[i] = NULL;
 	}
 }
 
@@ -662,7 +654,7 @@ INT16 G_ClipAimingPitch(INT32 *aiming)
 	else if (*aiming < -limitangle)
 		*aiming = -limitangle;
 
-	return (INT16)((*aiming)>>16);
+	return (INT16)((*aiming) >> TICCMD_REDUCE);
 }
 
 INT16 G_SoftwareClipAimingPitch(INT32 *aiming)
@@ -675,7 +667,7 @@ INT16 G_SoftwareClipAimingPitch(INT32 *aiming)
 	else if (*aiming < -limitangle)
 		*aiming = -limitangle;
 
-	return (INT16)((*aiming)>>16);
+	return (INT16)((*aiming) >> TICCMD_REDUCE);
 }
 
 INT32 JoyAxis(axis_input_e axissel, UINT8 player)
@@ -761,7 +753,7 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
 	if (retaxis > (+JOYAXISRANGE))
 		retaxis = +JOYAXISRANGE;
 
-	if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
+	if (!DigitalGamepadStyle(pnum) && axissel < AXISDEAD)
 	{
 		const INT32 jdeadzone = ((JOYAXISRANGE-1) * deadzone) >> FRACBITS;
 
@@ -798,6 +790,10 @@ static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
 static fixed_t sidemove[2] = {2<<FRACBITS>>16, 4<<FRACBITS>>16};
 static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
 
+//
+// G_HandleLocalDriftturn
+// Hack for Lua menus that check directional inputs with driftturn
+//
 static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
 {
 	INT32 axis = 0;
@@ -805,8 +801,8 @@ static void G_HandleLocalDriftturn(ticcmd_t *cmd, UINT8 ssplayer)
 
 	const UINT8 forplayer = (ssplayer-1);
 
-	const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !Joystick[forplayer].bGamepadStyle;
-	const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle;
+	const boolean analogjoystickmove  = cv_usejoystick[forplayer].value && !DigitalGamepadStyle(forplayer);
+	const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && DigitalGamepadStyle(forplayer);
 
 	turnright = InputDown(gc_turnright, ssplayer);
 	turnleft = InputDown(gc_turnleft, ssplayer);
@@ -860,9 +856,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 UINT8 forplayer = (ssplayer-1);
+	const boolean usejoystick = cv_usejoystick[forplayer].value;
 
 	// check for inputs and return button commands
 	// for stuff like joining with item button, saltyhop, honking, etc.
@@ -897,15 +893,11 @@ static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
 
 #undef CHECKINPUT
 
-	moveinput = (InputDown(gc_turnleft, ssplayer) || InputDown(gc_turnright, ssplayer)
-	|| InputDown(gc_aimforward, ssplayer) || InputDown(gc_aimbackward, ssplayer) ||
-	(usejoystick && JoyAxis(AXISAIM, ssplayer) != 0) || (usejoystick && JoyAxis(AXISTURN, ssplayer) != 0));
-
 	axis = JoyAxis(AXISLOOKBACK, ssplayer);
-	camspin[ssplayer-1] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
+	camspin[forplayer] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
 
 	// Reset to our spec player if we watch someone else.
-	if ((moveinput || cmd->buttons)
+	if ((cmd->driftturn || cmd->buttons)
 		&& displayplayers[0] != consoleplayer && ssplayer == 1)
 	{
 		if (cv_director.value)
@@ -917,6 +909,63 @@ static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
 	}
 }
 
+//
+// G_HandleAutoAcceleration
+//
+static void G_HandleAutoAcceleration(ticcmd_t *cmd, player_t *player, UINT8 forplayer)
+{
+	if (!cv_autoaccel[forplayer].value)
+		return;
+
+	if (gamestate != GS_LEVEL)
+		return;
+
+	// dont accel before and during countdown
+	if (leveltime <= starttime)
+		return;
+
+	// dont do this in menus or when console is onscreen
+	if (menuactive || CON_Ready())
+		return;
+
+	// gotta have a player that aint respawning
+	if (!player->mo || player->kartstuff[k_respawn])
+		return;
+
+	// dont need for "finished" players
+	if (player->exiting || (player->pflags & PF_TIMEOVER))
+		return;
+
+	// dont do during spinout
+	if (player->kartstuff[k_spinouttimer])
+		return;
+
+	// spectators and freecam dont need special handling, see G_BuildTiccmd
+
+	if (cmd->buttons & BT_BRAKE)
+	{
+		if (cmd->buttons & BT_DRIFT ||
+			player->kartstuff[k_sneakertimer] ||
+			player->kartstuff[k_squishedtimer])
+		{
+			cmd->forwardmove = (SINT8)forwardmove[0];
+			cmd->buttons |= BT_ACCELERATE;
+		}
+		else
+		{
+			// allows us to drive backwards if we need to
+			if (cmd->forwardmove > 0)
+				cmd->forwardmove = 0;
+			cmd->buttons &= ~BT_ACCELERATE;
+		}
+	}
+	else
+	{
+		cmd->forwardmove = (SINT8)forwardmove[1];
+		cmd->buttons |= BT_ACCELERATE;
+	}
+}
+
 //
 // G_BuildTiccmd
 // Builds a ticcmd from all of the available inputs
@@ -942,10 +991,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	player_t *player = P_GetLocalPlayerForNum(forplayer);
 
 	camera_t *thiscam = &camera[forplayer];
-	const boolean freecam = camera[forplayer].freecam;
-
-	const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !Joystick[forplayer].bGamepadStyle;
-	const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle;
+	const boolean freecam = thiscam->freecam;
 
 	lang = localangle[forplayer];
 	laim = localaiming[forplayer];
@@ -959,7 +1005,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	// Kart, don't build a ticcmd if someone is resynching or the server is stopped too so we don't fly off course in bad conditions
 	if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching)
 	{
-		cmd->angleturn = (INT16)(lang >> 16);
+		cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
 		cmd->aiming = G_ClipAimingPitch(&laim);
 		return;
 	}
@@ -967,7 +1013,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	// dumbass thing so we can use a few buttons but dont accidentally drive away
 	if (player->spectator || freecam)
 	{
-		cmd->angleturn = (INT16)(lang >> 16);
+		cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
 		G_BuildLocalTiccmd(cmd, ssplayer, freecam);
 
 		// let lua override everything
@@ -977,6 +1023,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		return;
 	}
 
+	const boolean analogjoystickmove  = cv_usejoystick[forplayer].value && !DigitalGamepadStyle(forplayer);
+	const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && DigitalGamepadStyle(forplayer);
+
 	usejoystick = (analogjoystickmove || gamepadjoystickmove);
 	turnright = InputDown(gc_turnright, ssplayer);
 	turnleft = InputDown(gc_turnleft, ssplayer);
@@ -1064,7 +1113,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		if (InputDown(gc_accelerate, ssplayer) || (gamepadjoystickmove && axis > 0) || player->kartstuff[k_sneakertimer])
 		{
 			cmd->buttons |= BT_ACCELERATE;
-			forward = forwardmove[1];	// 50
+			forward = forwardmove[1]; // 50
 		}
 		else if (analogjoystickmove && axis > 0)
 		{
@@ -1127,7 +1176,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	cmd->aiming = G_ClipAimingPitch(&laim);
 
-	mousex = mousey = mlooky = 0;
+	mousex = mousey = 0;
 
 	if (forward > MAXPLMOVE)
 		forward = MAXPLMOVE;
@@ -1145,6 +1194,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		cmd->sidemove = (SINT8)(cmd->sidemove + side);
 	}
 
+	G_HandleAutoAcceleration(cmd, player, forplayer);
+
 	//{ SRB2kart - Drift support
 	// Not grouped with the rest of turn stuff because it needs to know what buttons you're pressing for rubber-burn turn
 	// limit turning to angleturn[1] to stop mouselook letting you look too fast
@@ -1166,10 +1217,10 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		|| (leveltime > starttime && (cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE)) // Rubber-burn turn
 		|| (player->kartstuff[k_respawn]) // Respawning
 		|| (player->spectator || objectplacing))) // Not a physical player
-		lang += (cmd->angleturn<<16);
+		lang += (cmd->angleturn << TICCMD_REDUCE);
 
-	cmd->angleturn = (INT16)(lang >> 16);
-	cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
+	cmd->angleturn = (INT16)(lang >> TICCMD_REDUCE);
+	cmd->latency = modeattacking ? 0 : (leveltime & TICCMD_LATENCYMASK); // Send leveltime when this tic was generated to the server for control lag calculations
 
 	if (!hu_stopped)
 	{
@@ -1238,8 +1289,6 @@ 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
 
@@ -1261,6 +1310,7 @@ static void G_DoLoadLevel(boolean resetplayer)
 	{
 		// fail so reset game stuff
 		Command_ExitGame_f();
+		P_FreeCorruptMapWarnings();
 		return;
 	}
 
@@ -1294,6 +1344,8 @@ static void G_DoLoadLevel(boolean resetplayer)
 
 	// clear hud messages remains (usually from game startup)
 	CON_ClearHUD();
+	// print any map errors now due to clearhud above :chaosleep:
+	P_PrintCorruptMapWarnings();
 
 	server_lagless = !cv_gentlemens.value;
 
@@ -1750,14 +1802,15 @@ void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive)
 // Increment a viewpoint by offset from the current player. A negative value
 // decrements.
 //
-void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive)
+void G_AdjustViewEx(UINT8 viewnum, INT32 offset, boolean onlyactive, boolean resetfreecam)
 {
 	INT32 *displayplayerp, oldview;
 	displayplayerp = &displayplayers[viewnum-1];
 	oldview = (*displayplayerp);
 
 	// turn off the freecam
-	camera[viewnum-1].freecam = false;
+	if (resetfreecam)
+		camera[viewnum-1].freecam = false;
 
 	G_ResetView(viewnum, ( (*displayplayerp) + offset ), onlyactive);
 
@@ -1771,7 +1824,7 @@ void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive)
 // Ensures all viewpoints are valid
 // Also demotes splitscreen down to one player.
 //
-void G_ResetViews(void)
+void G_ResetViews(boolean resetfreecam)
 {
 	UINT8 splits;
 	UINT8 viewd;
@@ -1795,7 +1848,7 @@ void G_ResetViews(void)
 	*/
 	for (viewd = 1; viewd <= splits; ++viewd)
 	{
-		G_AdjustView(viewd, 0, false);
+		G_AdjustViewEx(viewd, 0, false, resetfreecam);
 	}
 }
 
@@ -1876,7 +1929,7 @@ void G_Ticker(boolean run)
 			G_CopyTiccmd(cmd, &netcmds[buf][i], 1);
 
 			// Use the leveltime sent in the player's ticcmd to determine control lag
-			cmd->latency = modeattacking ? 0 : min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1); //@TODO add a cvar to allow setting this max
+			cmd->latency = modeattacking ? 0 : min(((leveltime & TICCMD_LATENCYMASK) - cmd->latency) & TICCMD_LATENCYMASK, MAXPREDICTTICS-1); //@TODO add a cvar to allow setting this max
 		}
 	}
 
@@ -1884,7 +1937,6 @@ void G_Ticker(boolean run)
 	switch (gamestate)
 	{
 		case GS_LEVEL:
-
 			for (; ra_timeskip < starttime - TICRATE*4; ra_timeskip++)	// this looks weird but this is done to not break compability with older demos for now.
 			{
 				if (demo.title)
@@ -3293,18 +3345,6 @@ 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);
@@ -3343,7 +3383,7 @@ static void G_DoContinued(void)
 	token = 0;
 
 	// Reset # of lives
-	pl->lives = (ultimatemode) ? 1 : 3;
+	pl->lives = 3;
 
 	D_MapChange(gamemap, gametype, false, false, 0, false, false);
 
@@ -3433,7 +3473,7 @@ void G_LoadGameData(void)
 	INT32 i, j;
 	UINT8 modded = false;
 	UINT8 rtemp;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	//For records
 	tic_t rectime;
@@ -3566,7 +3606,7 @@ void G_SaveGameData(boolean force)
 	size_t length;
 	INT32 i, j;
 	UINT8 btemp;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 	(void)force;
 	char backupfile[MAX_WADPATH+4];
 
@@ -3737,7 +3777,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	size_t length;
 	char vcheck[VERSIONSIZE];
 	char savename[255];
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
 	memset(&savedata, 0, sizeof(savedata));
@@ -3823,7 +3863,7 @@ void G_SaveGame(UINT32 savegameslot)
 	boolean saved;
 	char savename[256] = "";
 	const char *backup;
-	savebuffer_t save = {0};
+	savebuffer_t save = {};
 
 	sprintf(savename, savegamename, savegameslot);
 	backup = va("%s",savename);
@@ -3837,7 +3877,7 @@ void G_SaveGame(UINT32 savegameslot)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
+		save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame
 		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -3987,7 +4027,6 @@ 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;
 	}
 
@@ -4052,6 +4091,7 @@ char *G_BuildMapTitle(INT32 mapnum)
 		const char *actnum = NULL;
 
 		len += strlen(mapheaderinfo[mapnum-1]->lvlttl);
+
 		if (strlen(mapheaderinfo[mapnum-1]->zonttl) > 0)
 		{
 			zonetext = M_GetText(mapheaderinfo[mapnum-1]->zonttl);
@@ -4062,6 +4102,7 @@ char *G_BuildMapTitle(INT32 mapnum)
 			zonetext = M_GetText("Zone");
 			len += strlen(zonetext) + 1;	// ' ' + zonetext
 		}
+
 		if (strlen(mapheaderinfo[mapnum-1]->actnum) > 0)
 		{
 			actnum = M_GetText(mapheaderinfo[mapnum-1]->actnum);
@@ -4075,8 +4116,10 @@ char *G_BuildMapTitle(INT32 mapnum)
 
 		sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl);
 
-		if (zonetext) sprintf(title + strlen(title), " %s", zonetext);
-		if (actnum) sprintf(title + strlen(title), " %s", actnum);
+		if (zonetext)
+			sprintf(title + strlen(title), " %s", zonetext);
+		if (actnum)
+			sprintf(title + strlen(title), " %s", actnum);
 	}
 
 	return title;
@@ -4088,12 +4131,13 @@ static void measurekeywords(mapsearchfreq_t *fr,
 {
 	char *qp;
 	char *sp;
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
 				PU_STATIC, NULL);
 	for (qp = strtok(va("%s", q), " ");
 			qp && fr->total < 255;
-			qp = strtok(0, " "))
+			qp = strtok(NULL, " "))
 	{
 		if (( sp = strcasestr(s, qp) ))
 		{
@@ -4102,10 +4146,12 @@ static void measurekeywords(mapsearchfreq_t *fr,
 				(*dimp)[(*cuntp)].pos = sp - s;
 				(*dimp)[(*cuntp)].siz = strlen(qp);
 			}
+
 			(*cuntp)++;
 			fr->total++;
 		}
 	}
+
 	if (wanttable)
 		(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
 				PU_STATIC, NULL);
@@ -4174,7 +4220,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 			{
 				newmapnum = mapnum;
 				newmapname = realmapname;
-				realmapname = 0;
+				realmapname = NULL;
 				Z_Free(apromapname);
 				if (!wanttable)
 					break;
@@ -4195,7 +4241,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
 				{
 					apromapnum = mapnum;
 					apromapname = realmapname;
-					realmapname = 0;
+					realmapname = NULL;
 				}
 			}
 			else/* ...match individual keywords */

src/g_game.h

@@ -39,18 +39,14 @@ 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];
 
 // used in game menu
 extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatbacktint, cv_chatspamprotection, cv_chatcentertext/*, cv_compactscoreboard*/;
-extern consvar_t cv_songcredits;
+extern consvar_t cv_songcredits, cv_pausesongcredits;
 extern consvar_t cv_showfreeplay;
 extern consvar_t cv_growmusic, cv_supermusic;
 extern consvar_t cv_pauseifunfocused;
@@ -74,6 +70,8 @@ extern consvar_t cv_ydeadzone[MAXSPLITSCREENPLAYERS];
 
 extern consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS];
 
+extern consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS];
+
 extern consvar_t cv_ghost_besttime, cv_ghost_bestlap, cv_ghost_last, cv_ghost_guest, cv_ghost_staff;
 
 // Hud offsets
@@ -120,14 +118,16 @@ extern consvar_t cv_driftsparkpulse;
 extern consvar_t cv_gravstretch;
 extern consvar_t cv_sloperoll;
 extern consvar_t cv_sliptideroll;
+extern consvar_t cv_stairjank;
+extern consvar_t cv_stairjanksfx;
 extern consvar_t cv_slamsound;
 extern consvar_t cv_sloperolldist;
 extern consvar_t cv_sparkroll;
-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;
 
@@ -249,7 +249,6 @@ 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
 
@@ -262,9 +261,10 @@ boolean G_CanView(INT32 playernum, UINT8 viewnum, boolean onlyactive);
 INT32 G_FindView(INT32 startview, UINT8 viewnum, boolean onlyactive, boolean reverse);
 INT32 G_CountPlayersPotentiallyViewable(boolean active);
 
-void G_ResetViews(void);
+void G_ResetViews(boolean resetfreecam);
 void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive);
-void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive);
+void G_AdjustViewEx(UINT8 viewnum, INT32 offset, boolean onlyactive, boolean resetfreecam);
+#define G_AdjustView(v,o,oa) G_AdjustViewEx(v,o,oa, true)
 
 void G_AddPlayer(INT32 playernum);
 

src/g_input.c

@@ -34,7 +34,7 @@ static CV_PossibleValue_t onecontrolperkey_cons_t[] = {{1, "One"}, {2, "Several"
 static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "Off"}, {0, NULL}};
 
 // mouse values are used once
-consvar_t cv_mousesens = {"mousesens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
@@ -81,6 +81,10 @@ 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)
@@ -125,17 +129,17 @@ static void led_off_handle4(void)
 	G_ResetPlayerGamepadIndicatorColor(3);
 }
 
-INT32 mousex, mousey;
-INT32 mlooky; // like mousey but with a custom sensitivity for mlook
+INT32 mousex = 0, mousey = 0;
 
 // joystick values are repeated
-INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET];
+INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET] = {};
+INT32 joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET] = {};
 
 // current state of the keys: true if pushed
-UINT8 gamekeydown[NUMINPUTS];
+UINT8 gamekeydown[NUMINPUTS] = {};
 
 // two key codes (or virtual key) per game control
-INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2];
+INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2] = {};
 
 typedef struct
 {
@@ -192,9 +196,8 @@ void G_MapEventsToControls(event_t *ev)
 		case ev_mouse: // buttons are virtual keys
 			if (menuactive || CON_Ready() || chat_on)
 				break;
-			mousex = (INT32)(ev->data2*((cv_mousesens.value*cv_mousesens.value)/110.0f + 0.1f));
-			mousey = (INT32)(ev->data3*((cv_mousesens.value*cv_mousesens.value)/110.0f + 0.1f));
-			mlooky = (INT32)(ev->data3*((cv_mouseysens.value*cv_mousesens.value)/110.0f + 0.1f));
+			mousex = (INT32)(ev->data2*((cv_mousexsens.value*cv_mousexsens.value)/110.0f + 0.1f));
+			mousey = (INT32)(ev->data3*((cv_mouseysens.value*cv_mouseysens.value)/110.0f + 0.1f));
 			break;
 
 		case ev_joystick: // buttons are virtual keys
@@ -215,7 +218,7 @@ void G_MapEventsToControls(event_t *ev)
 
 		case ev_joystick3:
 			i = ev->data1;
-			if (i >= JOYAXISSET)
+			if (i >= JOYAXISSET || menuactive)
 				break;
 			if (ev->data2 != INT32_MAX) joyxmove[2][i] = ev->data2;
 			if (ev->data3 != INT32_MAX) joyymove[2][i] = ev->data3;
@@ -223,7 +226,7 @@ void G_MapEventsToControls(event_t *ev)
 
 		case ev_joystick4:
 			i = ev->data1;
-			if (i >= JOYAXISSET)
+			if (i >= JOYAXISSET || menuactive)
 				break;
 			if (ev->data2 != INT32_MAX) joyxmove[3][i] = ev->data2;
 			if (ev->data3 != INT32_MAX) joyymove[3][i] = ev->data3;
@@ -931,12 +934,17 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
 
 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 
-	if (cv_gamepadled[playernum].value == 0
+	if (cv_gamepadled[playernum].value == 0 || (window_notinfocus && cv_gamepadledifunfocused.value == 0)
 	 || color >= MAXTRANSLATIONS)
 	{
 		return;
 	}
 
+	if (!I_GamepadHasLED(playernum))
+	{
+		return;
+	}
+
 	// so we can override this
 	skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
 	byte_color = V_GetColor(colortranslations[skincolor][8]).s;
@@ -946,6 +954,8 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
 
 static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
+
 	if (cv_gamepadled[playernum].value == 0)
 	{
 		I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
@@ -970,12 +980,22 @@ 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);
 
 		if (curcolor[i] == newcolor) // dont update if same colour
+		{
 			continue;
+		}
 
 		G_SetPlayerGamepadIndicatorColor(i, newcolor);
 		curcolor[i] = newcolor;
@@ -990,6 +1010,7 @@ void G_ResetDeviceLED(void)
 
 static void G_ResetPlayerDeviceRumble(INT32 playernum)
 {
+	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 	I_GamepadRumble(playernum, 0, 0, 0);
 }
 
@@ -1007,7 +1028,7 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
 {
 	I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
 
-	if (cv_rumble[playernum].value == 0)
+	if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0))
 	{
 		return;
 	}
@@ -1050,6 +1071,12 @@ void G_DeviceRumbleTick(void)
 			continue;
 		}
 
+		// does not support rumble! :c
+		if (!I_GamepadHasRumble(i))
+		{
+			continue;
+		}
+
 		if (camera[i].freecam)
 		{
 			continue;
@@ -1112,6 +1139,12 @@ void G_DeviceRumbleTick(void)
 			if (leveltime & 1) // this is actually funny lel
 				high = RUMBLE_MODERATE;
 		}
+		/*else if ((player->stairjank > 8) // this is kinda cool but prob gets annoying after a while
+			&& player->speed != 0
+			&& P_IsObjectOnGround(player->mo))
+		{
+			low = high = RUMBLE_WEAK;
+		}*/
 
 		if (player->kartstuff[k_brakedrift])
 		{

src/g_input.h

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

src/g_state.h

@@ -52,7 +52,6 @@ typedef enum
 } gameaction_t;
 
 extern gamestate_t gamestate;
-extern UINT8 ultimatemode; // was sk_insane
 extern gameaction_t gameaction;
 
 extern boolean botingame;

src/hardware/hw_batching.c

@@ -214,7 +214,7 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
 	const PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
 
 	const GLMipmap_t *texture1 = poly1->hash & 0x80000000 ? NULL : poly1->texture;
-	const GLMipmap_t *texture2 = poly1->hash & 0x80000000 ? NULL : poly2->texture;
+	const GLMipmap_t *texture2 = poly2->hash & 0x80000000 ? NULL : poly2->texture;
 
 	// skywalls and horizon lines must retain their order for horizon lines to work
 	if (!texture1 && !texture2)
@@ -391,7 +391,7 @@ void HWR_RenderBatches(void)
 				nextSurfaceInfo = nextEntry->surf;
 
 				if (nextPolyFlags & PF_NoTexture)
-					nextTexture = 0;
+					nextTexture = NULL;
 
 				if (useshader && currentShader != nextShader)
 				{

src/hardware/hw_bsp.c

@@ -373,7 +373,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 count, poly_t *poly)
 		if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL)
 			gl_maphashorizonlines = true;
 
-		if (line->sidenum[1] != 0xffff)
+		if (line->sidenum[1] != NO_INDEX)
 		{
 			if (sides[line->sidenum[0]].sector == sides[line->sidenum[1]].sector)
 			{

src/hardware/hw_cache.c

@@ -15,8 +15,6 @@
 
 #ifdef HWRENDER
 
-#include <unordered_set>
-
 #include "hw_main.h"
 #include "hw_glob.h"
 #include "hw_gl.h"
@@ -100,7 +98,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
 			position = 0;
 		}
 
-		position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
+		position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
 
 		if (position + count >= pblockheight)
 			count = pblockheight - position;
@@ -164,7 +162,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	RGBA_t *palette;
@@ -214,7 +212,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
 	fixed_t xfrac, xfracstep;
 	fixed_t yfracstep, scale_y;
 	const column_t *patchcol;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data);
+	UINT8 *block = (UINT8 *)(mipmap->data);
 	INT32 bpp;
 	INT32 blockmodulo;
 	INT32 width, height;
@@ -290,7 +288,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
 	INT32 blocksize = (glMipmap->width * glMipmap->height);
 
 	bpp = format2bpp(glMipmap->format);
-	block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
+	block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
 
 	switch (bpp)
 	{
@@ -327,7 +325,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	texture = textures[texnum];
 
 	gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
-	gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
+	gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
 
 	// hack the Legacy skies..
 	if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -346,7 +344,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 		colormap += COLORMAP_REMAPOFFSET;
 #endif
 
-	gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	gltex->mipmap.colormap->source = colormap;
 	memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -379,7 +377,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
+		pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
 		realpatch = (softwarepatch_t *)pdata;
 
 		HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -415,7 +413,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
 		glMipmap->flags = 0;
 
 		// setup the texture info
-		glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
+		glMipmap->format = (GLTextureFormat_t)(patchformat);
 
 		glPatch->max_s = (float)patch->width / (float)glMipmap->width;
 		glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -448,7 +446,7 @@ typedef struct
 } GLMapTextureSet_t; // idk i suck at naming things
 
 static size_t gl_numtextures = 0; // Texture count
-static GLMapTextureSet_t *gl_textures; // For all textures
+static GLMapTextureSet_t *gl_textures = NULL; // For all textures
 
 static void HWR_FreeTextureData(patch_t *patch)
 {
@@ -457,7 +455,7 @@ static void HWR_FreeTextureData(patch_t *patch)
 	if (!patch || !patch->hardware)
 		return;
 
-	glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		GL_DeleteTexture(glPatch->mipmap);
@@ -473,7 +471,7 @@ void HWR_FreeTexture(patch_t *patch)
 
 	if (patch->hardware)
 	{
-		GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+		GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 		HWR_FreeTextureColormaps(patch);
 
@@ -499,7 +497,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
 	if (!patch)
 		return;
 
-	pat = static_cast<GLPatch_t *>(patch->hardware);
+	pat = (GLPatch_t *)(patch->hardware);
 	if (!pat)
 		return;
 
@@ -572,7 +570,8 @@ void HWR_ClearAllTextures(void)
 /*static void HWR_FreeColormapCache(void)
 {
 	HWR_FreePatchCache(false);
-}*/
+}
+*/
 
 void HWR_InitMapTextures(void)
 {
@@ -614,24 +613,21 @@ 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
-	// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
-	std::unordered_set<UINT32> flatpresent;
-	lumpnum_t lump;
+	flatcheck flatpresent;
 	size_t i, j;
 	INT32 k;
 
-	auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
-	{
-		// flat already loaded?
-		if (flatpresent.count(lump) == 0)
-		{
-			HWR_GetFlat(lump, noencoremap);
-			flatpresent.insert(lump);
-		}
-	};
+	flatcheck_init(&flatpresent);
+	flatcheck_reserve(&flatpresent, numlevelflats);
 
 	// special case for encore
 #ifdef GLENCORE
@@ -649,16 +645,24 @@ static void HWR_PrecacheLevelFlats(void)
 				const INT32 pic = ceiling ? sec->ceilingpic : sec->floorpic;
 
 				const levelflat_t *levelflat = &levelflats[pic];
-				lump = levelflat->lumpnum;
 
-				load_flat(lump, R_NoEncore(sec, ceiling));
+				if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
+				{
+					HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
+					flatcheck_insert(&flatpresent, levelflat->lumpnum);
+				}
 
 				if (levelflat->speed) // is it an animated flat ?
 				{
 					// start from 0, occasionally basenumlump != flat->lumpnum
 					for (k = 0; k < levelflat->numpics; k++)
 					{
-						load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
+						lumpnum_t lump = levelflat->baselumpnum + k;
+						if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+						{
+							HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
+							flatcheck_insert(&flatpresent, lump);
+						}
 					}
 				}
 			}
@@ -672,20 +676,30 @@ static void HWR_PrecacheLevelFlats(void)
 		for (i = 0; i < numlevelflats; i++)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
-			lump = levelflat->lumpnum;
 
-			load_flat(lump, false);
+			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
+			{
+				HWR_GetFlat(levelflat->lumpnum, false);
+				flatcheck_insert(&flatpresent, levelflat->lumpnum);
+			}
 
 			if (levelflat->speed) // is it an animated flat ?
 			{
 				// start from 0, occasionally basenumlump != flat->lumpnum
 				for (k = 0; k < levelflat->numpics; k++)
 				{
-					load_flat(levelflat->baselumpnum + k, false);
+					lumpnum_t lump = levelflat->baselumpnum + k;
+					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
+					{
+						HWR_GetFlat(lump, false);
+						flatcheck_insert(&flatpresent, lump);
+					}
 				}
 			}
 		}
 	}
+
+	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -695,7 +709,7 @@ static void HWR_PrecacheLevelTextures(void)
 	size_t i, j, f;
 	INT32 h;
 
-	texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
+	texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
 	if (texturepresent == NULL)
 		I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
 
@@ -715,7 +729,7 @@ static void HWR_PrecacheLevelTextures(void)
 		for (j = 0; j < 2; j++)
 		{
 			// check if single-sided linedef
-			if (line->sidenum[j] == 0xffff)
+			if (line->sidenum[j] == NO_INDEX)
 				continue;
 
 			const side_t *side = &sides[line->sidenum[j]];
@@ -870,7 +884,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
 	HWR_FreeMapTextures();
 
 	gl_numtextures = pnumtextures;
-	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
+	gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
 
 	if (gl_textures == NULL)
 		I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -967,7 +981,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 	W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
 
 #ifdef GLENCORE
-	flat = static_cast<UINT8 *>(glMipmap->data);
+	flat = (UINT8 *)(glMipmap->data);
 	for (steppy = 0; steppy < size; steppy++)
 	{
 		if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -978,7 +992,6 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 
 		flat[steppy] = glMipmap->colormap->source[flat[steppy]];
 	}
-#endif
 
 	if (haschromakey)
 	{
@@ -990,6 +1003,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
 			glMipmap->flags &= ~TF_CHROMAKEYED;
 		}
 	}
+#endif
 }
 
 // Download a Doom 'flat' to the hardware cache and make it ready for use
@@ -1011,7 +1025,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 		if (!noencoremap && encoremap)
 			colormap += COLORMAP_REMAPOFFSET;
 #endif
-		glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+		glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 		glMipmap->colormap->source = colormap;
 		memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 	}
@@ -1035,7 +1049,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
 // --------------------+
 static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 
 	if (!glMipmap->downloaded)
 	{
@@ -1056,7 +1070,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 // ----------------------+
 static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
 {
-	GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
 	HWR_MakePatch(patch, glPatch, glMipmap, true);
 
 	// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1092,7 +1106,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 
 	if (!patch->hardware)
 		Patch_CreateGL(patch);
-	glPatch = static_cast<GLPatch_t *>(patch->hardware);
+	glPatch = (GLPatch_t *)(patch->hardware);
 
 	// Blatant hack for encore colormapping aside...
 	if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1116,7 +1130,9 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
 				HWR_UpdatePatchMipmap(patch, glMipmap);
 			}
 			else
+			{
 				HWR_LoadPatchMipmap(patch, glMipmap);
+			}
 
 			return;
 		}
@@ -1128,12 +1144,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 = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
+	newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
 	if (newMipmap == NULL)
 		I_Error("%s: Out of memory", "HWR_GetMappedPatch");
 	glMipmap->nextcolormap = newMipmap;
 
-	newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
+	newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
 	newMipmap->colormap->source = colormap;
 	memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
 
@@ -1156,7 +1172,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(static_cast<patch_t *>(ptr));
+		Patch_AllocateHardwarePatch((patch_t *)(ptr));
 	}
 
 	return (patch_t *)(lumpcache[lumpnum]);
@@ -1173,7 +1189,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
 {
 	INT32 i,j;
 	fixed_t posx, posy, stepx, stepy;
-	UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
+	UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
 	UINT8 *flat;
 	UINT8 *dest, *src, texel;
 	RGBA_t col;
@@ -1329,7 +1345,7 @@ void HWR_SetPalette(RGBA_t *palette)
 static void HWR_SetPaletteLookup(RGBA_t *palette)
 {
 	int r, g, b;
-	UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
+	UINT8 *lut = (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)
@@ -1374,7 +1390,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 = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
+		RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
 		// we got the RGB palette now, but we need it in RGBA format.
 		for (i = 0; i < 256; i++)
 		{
@@ -1409,7 +1425,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
 {
 	UINT32 i, id;
 	RGBA_t *palette = HWR_GetTexturePalette();
-	RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
+	RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
 
 	// To make the palette index -> RGBA mapping easier for the shader,
 	// the hardware lighttable is composed of RGBA colors instead of palette indices.

src/hardware/hw_clip.c

@@ -319,23 +319,24 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
 	double clipfov;
 	double floatangle;
 	angle_t a1;
-
-	float tilt = fabsf(((float)(int)tiltangle) / (float)ANG1);
-
-	if (tilt > 90.0f)
-		tilt = 90.0f;
+	float tilt;
 
 	// 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)xs_CRoundToInt(ANG1 * floatangle);
+	a1 = (angle_t)lrint(ANG1 * floatangle);
 	return a1;
 }
 

src/hardware/hw_data.h

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

src/hardware/hw_draw.c

@@ -32,20 +32,6 @@
 
 #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};
@@ -57,8 +43,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
 {
 	FOutVector v[4];
 	FBITFIELD flags;
-	float cx = FIXED_TO_FLOAT(x);
-	float cy = FIXED_TO_FLOAT(y);
+	float cx, cy;
 	UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
 	UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT);
 	GLPatch_t *hwrPatch;
@@ -72,6 +57,9 @@ 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;
 
@@ -150,7 +138,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, (column->topdelta == 0xff ? 31 : source[0]));
+					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
 				}
 			}
 
@@ -222,7 +210,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)
@@ -244,8 +232,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 {
 	FOutVector v[4];
 	FBITFIELD flags;
-	float cx = FIXED_TO_FLOAT(x);
-	float cy = FIXED_TO_FLOAT(y);
+	float cx, cy;
 	UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
 	GLPatch_t *hwrPatch;
 
@@ -258,6 +245,9 @@ 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;
 
@@ -302,7 +292,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, (column->topdelta == 0xff ? 31 : source[0]));
+					HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
 				}
 			}
 
@@ -385,7 +375,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
 	// clip it since it is used for bunny scroll in doom I
 	if (alphalevel)
 	{
-		FSurfaceInfo Surf;
+		FSurfaceInfo Surf = {};
 		Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
 
 		switch (alphalevel)
@@ -490,7 +480,7 @@ void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
 void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
 
 	v[0].x = v[3].x = -1.0f;
@@ -543,7 +533,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
 void HWR_DrawConsoleBack(UINT32 color, INT32 height)
 {
 	FOutVector  v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 
 	// setup some neat-o translucency effect
 	if (!height) //cool hack 0 height is full height
@@ -598,7 +588,7 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
 void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	float fx, fy, fw, fh, fwait = 0;
 	RGBA_t *palette;
 
@@ -702,7 +692,7 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
 void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
 {
 	FOutVector v[4];
-	FSurfaceInfo Surf;
+	FSurfaceInfo Surf = {};
 	float fx, fy, fw, fh;
 
 	if (w < 0 || h < 0)
@@ -820,7 +810,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)
@@ -964,6 +954,20 @@ 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
 // --------------------------------------------------------------------------

src/hardware/hw_gl.h

@@ -32,8 +32,12 @@ 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);
@@ -63,7 +67,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, boolean useshader);
+void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height);
 
 void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]);
 
@@ -72,6 +76,7 @@ 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);
 
@@ -80,6 +85,9 @@ UINT32 GL_CreateLightTable(RGBA_t *hw_lighttable);
 void GL_ClearLightTables(void);
 void GL_SetScreenPalette(RGBA_t *palette);
 
+void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
+                      FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/hardware/hw_glob.h

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

src/hardware/hw_main.h

@@ -102,7 +102,7 @@ void HWR_SetViewSize(void);
 void HWR_AddCommands(void);
 
 void HWR_RenderPlayerView(void);
-void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, int stencil_level, boolean allow_portals);
+void HWR_RenderPortalViewpoint(gl_portal_t *rootportal, int stencil_level);
 
 void HWR_ClearSkyDome(void);
 void HWR_BuildSkyDome(void);
@@ -151,14 +151,19 @@ 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, boolean useshader)
+FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height)
 {
-	GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height, useshader);
+	GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height);
 }
 
 // hw_main.c: Segs
@@ -208,7 +213,6 @@ extern consvar_t cv_glportals;
 
 extern consvar_t cv_glpaletterendering;
 extern consvar_t cv_glpalettedepth;
-extern consvar_t cv_glflashpal;
 
 FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
 {
@@ -220,11 +224,6 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
 	return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
 }
 
-FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
-{
-	return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
-}
-
 // Returns a pointer to the palette which should be used for caching textures.
 FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
 {

src/hardware/hw_md2.c

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

src/hardware/hw_md2.h

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

src/hardware/hw_md2load.c

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

src/hardware/hw_md3load.c

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

src/hardware/hw_model.c

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

src/hardware/hw_portal.c

@@ -80,8 +80,8 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
 	gl_portal_t *portal = HWR_Portal_Add(seg);
 
 	// Offset the portal view by the linedef centers
-	line_t* start	= &lines[line1];
-	line_t* dest	= &lines[line2];
+	line_t* start = &lines[line1];
+	line_t* dest  = &lines[line2];
 
 	angle_t dangle = R_PointToAngle2(0, 0, dest->dx, dest->dy) - R_PointToAngle2(start->dx, start->dy, 0, 0);
 
@@ -99,7 +99,7 @@ void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
 	dest_c.y = dest->v1->y/2 + dest->v2->y/2;
 
 	disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy);
-	angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
+	angtopoint  = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
 	angtopoint += dangle;
 
 	portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
@@ -170,7 +170,7 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
 	HWR_PortalFrame(portal);
 
 	// call HWR_RenderViewpoint
-	HWR_RenderPortalViewpoint(portal, stencil_level + 1, true);
+	HWR_RenderPortalViewpoint(portal, stencil_level + 1);
 
 	// return to current frame
 	if (rootportal)
@@ -220,9 +220,9 @@ boolean HWR_PortalCheckBBox(const fixed_t *bspcoord)
 	if (!portalclipline)
 		return true;
 
-	if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) ||
-		HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) ||
-		HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) ||
+	if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT],  bspcoord[BOXTOP])    ||
+		HWR_PortalCheckPointSide(bspcoord[BOXLEFT],  bspcoord[BOXBOTTOM]) ||
+		HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP])    ||
 		HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXBOTTOM]))
 	{
 		return true;

src/hardware/hw_shaders.c

@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
 // returns INT32_MAX if not found
 static INT32 strstr_int(const char *str1, const char *str2)
 {
-	char *location = strstr(str1, str2);
+	gconst char *location = strstr(str1, str2);
 	if (location)
 		return location - str1;
 	else
@@ -365,13 +365,17 @@ 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);
 	}
 
@@ -387,8 +391,10 @@ 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);

src/hardware/hw_shaders.h

@@ -76,35 +76,30 @@
 //
 
 // Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro.
+
+// dither shader based on
+// https://github.com/hughsk/glsl-dither/blob/master/8x8.glsl
+// https://github.com/libretro/glsl-shaders/blob/master/dithering/shaders/bayer_4x4.glsl
+// adapted and messed about to work with srb2 and scale per resolution
 #define GLSL_DOOM_COLORMAP_DITHER \
 	"float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\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 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 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" \
-	"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" \
+	"threshold = 11.0;\n" \
 	"#endif\n" \
-	"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, zFactor);\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"
 
 #define GLSL_DOOM_COLORMAP_NODITHER \
 	"return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \

src/hardware/r_opengl/r_opengl.c

@@ -98,10 +98,10 @@ static size_t textureBufferSize = 0;
 static LTListItem *LightTablesTail = NULL;
 static LTListItem *LightTablesHead = NULL;
 
-static RGBA_t screenPalette[256] = {0}; // the palette for the postprocessing step in palette rendering
+static RGBA_t screenPalette[256] = {}; // the palette for the postprocessing step in palette rendering
 static GLuint screenPaletteTex = 0; // 1D texture containing the screen palette
 static GLuint paletteLookupTex = 0; // 3D texture containing RGB -> palette index lookup table
-RGBA_t  myPaletteData[256] = {0}; // the palette for converting textures to RGBA
+RGBA_t myPaletteData[256] = {}; // the palette for converting textures to RGBA
 
 static GLint gltexformat = GL_RGB5_A1;
 GLint   screen_width     = 0;               // used by Draw2DLine()
@@ -127,9 +127,9 @@ GLuint gl_num_extensions;
 int majorGL = 0, minorGL = 0;
 
 //Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
-GLfloat modelMatrix[16] = {0};
-GLfloat projMatrix[16] = {0};
-static GLint   viewport[4];
+GLfloat modelMatrix[16] = {};
+GLfloat projMatrix[16] = {};
+static GLint viewport[4];
 
 #ifdef USE_FBO_OGL
 enum
@@ -171,7 +171,7 @@ boolean supportstencil = false;
 //			flush all of the stored textures, leaving them unavailable at times such as between levels
 //			These need to start at 0 and be set to their number, and be reset to 0 when deleted so that Intel GPUs
 //			can know when the textures aren't there, as textures are always considered resident in their virtual memory
-static GLuint screenTextures[NUMSCREENTEXTURES] = {0};
+static GLuint screenTextures[NUMSCREENTEXTURES] = {};
 
 #define byte2float(byte) (GLfloat)(byte / 255.0f)
 
@@ -404,6 +404,14 @@ static PFNglEnableClientState pglEnableClientState;
 typedef void (APIENTRY * PFNglDisableClientState) (GLenum cap);
 static PFNglDisableClientState pglDisableClientState;
 
+typedef void (APIENTRY * PFNglOrtho) (GLdouble left,
+									  GLdouble right,
+									  GLdouble bottom,
+									  GLdouble top,
+									  GLdouble nearVal,
+									  GLdouble farVal);
+static PFNglOrtho pglOrtho;
+
 /* Lighting */
 typedef void (APIENTRY * PFNglShadeModel) (GLenum mode);
 static PFNglShadeModel pglShadeModel;
@@ -745,7 +753,7 @@ typedef struct gl_shaderstate_s
 static gl_shaderstate_t gl_shaderstate;
 
 // Shader info
-static float shader_leveltime = 0;
+static float shader_leveltime = 0.0f;
 static float shader_light_x = 0.0f;
 static float shader_light_y = 0.0f;
 static float shader_light_z = 0.0f;
@@ -858,6 +866,8 @@ void SetupGLFunc4(void)
 	GetGLfunc(glUniform3fv);
 	GetGLfunc(glGetUniformLocation);
 
+	GetGLfunc(glOrtho);
+
 #ifdef GLDEBUGMESSAGE
 	GetGLfunc(glDebugMessageCallback);
 #endif
@@ -1058,6 +1068,13 @@ 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
@@ -1105,7 +1122,7 @@ static void GL_Perspective(GLfloat fovy, GLfloat aspect)
 
 	const GLfloat deltaZ = FAR_CLIPPING_PLANE - NEAR_CLIPPING_PLANE;
 
-	if ((fabsf((float)deltaZ) < 1.0E-36f) || fpclassify(aspect) == FP_ZERO)
+	if ((fabsf(deltaZ) < 1.0E-36f) || fpclassify(aspect) == FP_ZERO)
 	{
 		return;
 	}
@@ -1267,7 +1284,7 @@ void GL_SetStates(void)
 
 	pglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
-	pglEnable(GL_STENCIL_TEST);
+	pglDisable(GL_STENCIL_TEST);
 	pglEnable(GL_DEPTH_TEST);    // check the depth buffer
 	pglDepthMask(GL_TRUE);       // enable writing to depth buffer
 	pglClearDepth(1.0f);
@@ -1297,6 +1314,16 @@ 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
 // -----------------+
@@ -1373,19 +1400,19 @@ void GL_Flush(void)
 // -----------------+
 INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
 {
-	GLubyte         *where, *terminator;
+	gconst GLubyte *where, *terminator;
 
 	if (!extension || !start)
 		return 0;
 
-	where = (GLubyte *) strchr(extension, ' ');
+	where = (gconst GLubyte *)strchr(extension, ' ');
 
 	if (where || *extension == '\0')
 		return 0;
 
 	for (;;)
 	{
-		where = (GLubyte *) strstr((const char *) start, extension);
+		where = (gconst GLubyte *)strstr((const char *)start, extension);
 
 		if (!where)
 			break;
@@ -1556,6 +1583,7 @@ void GL_Draw2DLine(F2DCoord * v1, F2DCoord * v2, RGBA_t Color)
 		angle = atanf((v2->y-v1->y)/(v2->x-v1->x));
 	else
 		angle = (float)N_PI_DEMI;
+
 	dx = sinf(angle) / (float)screen_width;
 	dy = cosf(angle) / (float)screen_height;
 
@@ -1670,7 +1698,7 @@ static void GL_SetBlendMode(FBITFIELD flags)
 
 void GL_SetBlend(FBITFIELD PolyFlags)
 {
-	const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;;
+	const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;
 
 	if (Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Skydecal|PF_Invisible))
 	{
@@ -2209,16 +2237,10 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG
 			UNIFORM_1(shader->uniforms[gluniform_light_contrast], shader_light_contrast, pglUniform1f);
 			UNIFORM_1(shader->uniforms[gluniform_light_backlight], shader_light_backlight, pglUniform1f);
 		}
-		else
-		{
-			UNIFORM_3(shader->uniforms[gluniform_light_dir], 0, 0, 0, pglUniform3f);
-			UNIFORM_1(shader->uniforms[gluniform_light_contrast], 0, pglUniform1f);
-			UNIFORM_1(shader->uniforms[gluniform_light_backlight], 0, pglUniform1f);
-		}
 
 		UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f);
 
-		UNIFORM_2(shader->uniforms[gluniform_scr_resolution], vid.width, vid.height, pglUniform2f);
+		UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)vid.width, (GLfloat)vid.height, pglUniform2f);
 
 		#undef UNIFORM_1
 		#undef UNIFORM_2
@@ -2893,7 +2915,7 @@ void GL_CreateModelVBOs(model_t *model)
 	}
 }
 
-#define BUFFER_OFFSET(i) ((char*)(i))
+#define BUFFER_OFFSET(i) ((void*)(i))
 
 void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics, INT32 nextFrameIndex, FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface)
 {
@@ -3096,6 +3118,39 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
 	pglDisable(GL_NORMALIZE);
 }
 
+void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
+                      FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface)
+{
+	// save our matrix´s
+	pglMatrixMode(GL_PROJECTION);
+	pglPushMatrix();
+	pglMatrixMode(GL_MODELVIEW);
+	pglPushMatrix();
+
+	pglMatrixMode(GL_PROJECTION);
+	pglLoadIdentity();
+
+	// switch to ortho mode to make our lives easier
+	// thisll make sure our coords will be remapped to pixel coords
+	pglOrtho(0.0f, (float)vid.width, (float)vid.height, 0.0f, NZCLIP_PLANE, FAR_ZCLIP_DEFAULT);
+
+	pglMatrixMode(GL_MODELVIEW);
+	pglLoadIdentity();
+
+	pglEnable(GL_DEPTH_TEST);
+	pglDepthMask(GL_TRUE);
+	pglClear(GL_DEPTH_BUFFER_BIT);
+
+	GL_DrawModelEx(model, frameIndex, duration, tics, nextFrameIndex,
+	               pos, hscale, vscale, flipped, hflipped, Surface);
+
+	// restore the matrix´s
+	pglMatrixMode(GL_PROJECTION);
+	pglPopMatrix();
+	pglMatrixMode(GL_MODELVIEW);
+	pglPopMatrix();
+}
+
 // -----------------+
 // SetTransform     :
 // -----------------+
@@ -3206,14 +3261,6 @@ 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);
 
@@ -3265,6 +3312,18 @@ 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);
 
@@ -3287,6 +3346,10 @@ 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);
 }
@@ -3554,22 +3617,30 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 		 1.0f, -1.0f, 1.0f
 	};
 
-	xfix = 1/((float)screen_texsizew/(float)screen_width);
-	yfix = 1/((float)screen_texsizeh/(float)screen_height);
-
 	const GLfloat scrwf = (float)screen_width;
 	const GLfloat scrwh = (float)screen_height;
 
+	xfix = 1/((float)screen_texsizew/scrwf);
+	yfix = 1/((float)screen_texsizeh/scrwh);
+
+	GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
+
 	// Slight fuzziness
 	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
 	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
-	const float stride = 2.f/scrwh;
+	uint32_t r = rand();
 
-	for (i = 0; i < 1; i += stride)
+	const float ystep = 2.f/scrwh * (float)vid.udup/4.f;
+
+	for (i = 0; i < 1; i += ystep)
 	{
-		fix[2] = (float)(rand() % 128) / -22000.f * xfix;
+		// avoid calling rand thousands of times
+		r ^= r >> 13;
+		r ^= r >> 11;
+		r ^= r << 21;
+
+		fix[2] = (float)(r & 127) / -22000.f * xfix;
 		fix[0] = fix[2];
 		fix[6] = fix[0] + xfix;
 		fix[4] = fix[2] + xfix;
@@ -3587,8 +3658,8 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 	}
 
 	// Upward bar
-	//GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	//pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
+	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
+	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
 	color[0] = color[1] = color[2] = 190;
 	color[3] = 250;
@@ -3611,13 +3682,14 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 
 	fix[1] = fix[7] += (fix[3] - fix[7])*2;
 	screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
+
 	pglTexCoordPointer(2, GL_FLOAT, 0, fix);
 	pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 	// Downward bar
-	//GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
-	//pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
+	GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
+	pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
 
 	fix[0] = 0.0f;
 	fix[6] = xfix;
@@ -3636,6 +3708,7 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 
 	fix[1] = fix[7] += (fix[3] - fix[7])*2;
 	screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
+
 	pglTexCoordPointer(2, GL_FLOAT, 0, fix);
 	pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
@@ -3671,11 +3744,11 @@ void GL_MakeScreenTexture(int tex)
 	tex_downloaded = screenTextures[tex];
 }
 
-void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean useshader)
+void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
 {
 	float xfix, yfix;
 	float origaspect, newaspect;
-	float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen
+	float xoff = 1.0f, yoff = 1.0f; // xoffset and yoffset for the polygon to have black bars around the screen
 
 	static float off[12] =
 	{
@@ -3698,19 +3771,19 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
 	if (origaspect < newaspect)
 	{
 		xoff = origaspect / newaspect;
-		yoff = 1;
+		yoff = 1.0f;
 	}
 	else if (origaspect > newaspect)
 	{
-		xoff = 1;
+		xoff = 1.0f;
 		yoff = newaspect / origaspect;
 	}
 
 	// float off[12];
 	off[0] = off[3]  = -xoff;
 	off[1] = off[10] = -yoff;
-	off[4] = off[7]  = yoff;
-	off[6] = off[9]  = xoff;
+	off[4] = off[7]  =  yoff;
+	off[6] = off[9]  =  xoff;
 
 	// float fix[8];
 	fix[3] = fix[5] = yfix;
@@ -3724,9 +3797,6 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
 
 	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);
@@ -3734,9 +3804,6 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
 
 	pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-	if (useshader)
-		pglUseProgram(0);
-
 	tex_downloaded = screenTextures[tex];
 }
 

src/http-mserv.c

@@ -189,7 +189,7 @@ HMS_connect (const char *format, ...)
 	seek = strlen(hms_api) + 1;/* + '/' */
 
 	va_start (ap, format);
-	url = malloc(seek + vsnprintf(0, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
+	url = malloc(seek + vsnprintf(NULL, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
 	va_end (ap);
 
 	sprintf(url, "%s/", hms_api);
@@ -225,9 +225,10 @@ HMS_connect (const char *format, ...)
 	{
 		cc = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-
+#ifdef LOGMESSAGES
 		cc = curl_easy_setopt(curl, CURLOPT_STDERR, logstream);
 		if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
+#endif
 	}
 
 	if (M_CheckParm("-bindaddr") && M_IsNextParm())
@@ -317,6 +318,7 @@ static void
 HMS_end (struct HMS_buffer *buffer)
 {
 	curl_easy_cleanup(buffer->curl);
+	free(buffer->errbuf);
 	free(buffer->buffer);
 	free(buffer);
 }
@@ -471,8 +473,8 @@ HMS_fetch_servers (msg_server_t *list, int query_id)
 			*end = '\0';
 
 			address = strtok(p, " ");
-			port    = strtok(0, " ");
-			contact = strtok(0, "");
+			port    = strtok(NULL, " ");
+			contact = strtok(NULL, "");
 
 			if (address && port)
 			{
@@ -539,7 +541,7 @@ HMS_compare_mod_version (char *buffer, size_t buffer_size)
 	if (HMS_do(hms))
 	{
 		version      = strtok(hms->buffer, " ");
-		version_name = strtok(0, "\n");
+		version_name = strtok(NULL, "\n");
 
 		if (version && version_name)
 		{

src/hu_stuff.h

@@ -42,15 +42,6 @@
 #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
 //------------------------------------
@@ -68,12 +59,7 @@ 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.
 
@@ -102,6 +88,10 @@ extern patch_t *tallminus;
 // set true whenever the tab rankings are being shown for any reason
 extern boolean hu_showscores;
 
+extern consvar_t cv_chat_xoffset;
+extern consvar_t cv_chat_yoffset;
+extern consvar_t cv_chat_showlimit;
+
 // init heads up data at game startup.
 void HU_Init(void);
 
@@ -110,8 +100,6 @@ 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);
@@ -120,8 +108,7 @@ 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_drawLocalPlayerPing(INT32 x, INT32 y, INT32 flags);
 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);

src/i_joy.h

@@ -36,28 +36,7 @@ extern "C" {
 "JOYBUTTONS is greater than INT64 bits can hold"
 #endif
 
-/**	\brief	The struct JoyType_s
-
- share some joystick information (maybe 2 for splitscreen), to the game input code,
- actually, we need to know if it is a gamepad or analog controls
-*/
-
-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;
-
-};
-typedef struct JoyType_s JoyType_t;
-/**	\brief Joystick info
-	for palyer[sic] 1-4's joystick/gamepad
-*/
-
-extern JoyType_t Joystick[MAXSPLITSCREENPLAYERS];
+#define DigitalGamepadStyle(i) (cv_joyscale[i].value == 0)
 
 #ifdef __cplusplus
 } // extern "C"

src/i_net.h

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

src/i_system.h

@@ -29,6 +29,10 @@ extern "C" {
 */
 #define MAX_QUIT_FUNCS     16
 
+void I_GetConsoleEvents(void);
+
+extern boolean consolevent;
+extern boolean framebuffer;
 
 /**	\brief Graphic system had started up
 */
@@ -39,7 +43,7 @@ extern UINT8 graphics_started;
 extern UINT8 keyboard_started;
 
 /** \brief Set to true when inside a signal handler that will exit the program. */
-extern boolean g_in_exiting_signal_handler;
+boolean I_In_Exiting_Signal_Handler(void);
 
 /**	\brief	The I_GetFreeMem function
 
@@ -144,6 +148,11 @@ 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);
 
@@ -191,6 +200,15 @@ INT32 I_StartupSystem(void);
 */
 void I_ShutdownSystem(void);
 
+/**	\brief To check if a Interrupt or Terminate Signal was fired
+ */
+boolean I_Interrupted(void);
+static inline void I_HandleInterrupt(void)
+{
+	if (I_Interrupted())
+		I_Quit();
+}
+
 /**	\brief	The I_GetDiskFreeSpace function
 
 	\param	freespace	a INT64 pointer to hold the free space amount

src/i_tcp.c

@@ -392,6 +392,9 @@ static const char *SOCK_GetNodeAddress(INT32 node)
 	if (node == 0)
 		return "self";
 
+	if (node < 0 || node > MAXNETNODES)
+		return NULL;
+
 	if (!nodeconnected[node])
 		return NULL;
 
@@ -496,8 +499,10 @@ static void cleanupnodes(void)
 
 	// Why can't I start at zero?
 	for (j = 1; j < MAXNETNODES; j++)
+	{
 		if (!(nodeingame[j] || SV_SendingFile(j)))
 			nodeconnected[j] = false;
+	}
 }
 
 static SINT8 getfreenode(void)
@@ -507,11 +512,13 @@ static SINT8 getfreenode(void)
 	cleanupnodes();
 
 	for (j = 0; j < MAXNETNODES; j++)
+	{
 		if (!nodeconnected[j])
 		{
 			nodeconnected[j] = true;
 			return j;
 		}
+	}
 
 	/** \warning No free node? Just in case a node might not have been freed properly,
 	  *          look if there are connected nodes that aren't in game, and forget them.
@@ -568,13 +575,12 @@ void Command_Numnodes(void)
 
 #ifdef HOLEPUNCH
 /* not one of the reserved "local" addresses */
-static boolean
-is_external_address (UINT32 p)
+static boolean is_external_address(UINT32 p)
 {
 	UINT8 a = (p & 255);
 	UINT8 b = ((p >> 8) & 255);
 
-	if (p == (UINT32)~0)/* 255.255.255.255 */
+	if (p == (UINT32)~0) /* 255.255.255.255 */
 		return 0;
 
 	switch (a)
@@ -584,7 +590,7 @@ is_external_address (UINT32 p)
 		case 127:
 			return false;
 		case 172:
-			return (b & ~15) != 16;/* 16 - 31 */
+			return (b & ~15) != 16; /* 16 - 31 */
 		case 192:
 			return b != 168;
 		default:
@@ -763,6 +769,7 @@ static void SOCK_Send(void)
 				if (myfamily[i] == broadcastaddress[j].any.sa_family)
 				{
 					c = SOCK_SendToAddr(mysockets[i], &broadcastaddress[j]);
+
 					if (c == ERRSOCKET)
 					{
 						e = errno;
@@ -780,6 +787,7 @@ static void SOCK_Send(void)
 			if (myfamily[i] == clientaddress[doomcom->remotenode].any.sa_family)
 			{
 				c = SOCK_SendToAddr(mysockets[i], &clientaddress[doomcom->remotenode]);
+
 				if (c == ERRSOCKET)
 				{
 					e = errno;
@@ -792,6 +800,7 @@ static void SOCK_Send(void)
 	else
 	{
 		c = SOCK_SendToAddr(nodesocket[doomcom->remotenode], &clientaddress[doomcom->remotenode]);
+
 		if (c == ERRSOCKET)
 		{
 			e = errno;
@@ -810,7 +819,7 @@ static void SOCK_Send(void)
 static void SOCK_FreeNodenum(INT32 numnode)
 {
 	// can't disconnect from self :)
-	if (!numnode || numnode > MAXNETNODES)
+	if (numnode <= 0 || numnode > MAXNETNODES)
 		return;
 
 	DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1060,7 +1069,6 @@ static boolean UDP_Socket(void)
 #endif
 	const char *serv;
 
-
 	for (s = 0; s < mysocketses; s++)
 		mysockets[s] = ERRSOCKET;
 	for (s = 0; s < MAXNETNODES+1; s++)
@@ -1431,14 +1439,12 @@ static void SOCK_RegisterHolePunch(void)
 
 static boolean SOCK_OpenSocket(void)
 {
-	size_t i;
-
-	memset(clientaddress, 0, sizeof (clientaddress));
+	memset(clientaddress, 0, sizeof(clientaddress));
 
+	memset(nodeconnected, false, sizeof(nodeconnected));
 	nodeconnected[0] = true; // always connected to self
-	for (i = 1; i < MAXNETNODES; i++)
-		nodeconnected[i] = false;
 	nodeconnected[BROADCASTADDR] = true;
+
 	I_NetSend = SOCK_Send;
 	I_NetGet = SOCK_Get;
 	I_NetCloseSocket = SOCK_CloseSocket;
@@ -1478,7 +1484,7 @@ static boolean SOCK_Ban(INT32 node)
 {
 	INT32 ban;
 
-	if (node > MAXNETNODES)
+	if (node < 0 || node > MAXNETNODES)
 		return false;
 
 	ban = numbans;
@@ -1509,11 +1515,8 @@ static boolean SOCK_SetBanUsername(const char *username)
 		username = "Direct IP ban";
 	}
 
-	if (banned[numbans - 1].username)
-	{
-		Z_Free(banned[numbans - 1].username);
-		banned[numbans - 1].username = NULL;
-	}
+	Z_Free(banned[numbans - 1].username);
+	banned[numbans - 1].username = NULL;
 
 	banned[numbans - 1].username = Z_StrDup(username);
 
@@ -1527,11 +1530,8 @@ static boolean SOCK_SetBanReason(const char *reason)
 		reason = "No reason given";
 	}
 
-	if (banned[numbans - 1].reason)
-	{
-		Z_Free(banned[numbans - 1].reason);
-		banned[numbans - 1].reason = NULL;
-	}
+	Z_Free(banned[numbans - 1].reason);
+	banned[numbans - 1].reason = NULL;
 
 	banned[numbans - 1].reason = Z_StrDup(reason);
 

src/i_time.c

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

src/i_video.h

@@ -125,8 +125,6 @@ boolean I_CheckNativeRes(void);
 
 void I_SetBorderlessWindow(void);
 
-void I_HandleControllerHatRepeat(void);
-
 #ifdef USE_FBO_OGL
 
 void RefreshOGLSDLSurface(void);
@@ -135,6 +133,15 @@ boolean UseScreenFBO(void);
 extern boolean downsample;
 #endif
 
+// So we can call this from i_video event loop
+void I_ShutdownJoystick(UINT8 index);
+
+// Quick thing to make SDL_JOYDEVICEADDED events less of an abomination
+void I_UpdateJoystickDeviceIndex(UINT8 player);
+void I_UpdateJoystickDeviceIndices(UINT8 excludePlayer);
+
+void I_HandleControllerHatRepeat(void);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/info.h

@@ -19,6 +19,8 @@
 #include "sounds.h"
 #include "m_fixed.h"
 
+#define MAXDOOMEDNUM 4095
+
 // dehacked.c now has lists for the more named enums! PLEASE keep them up to date!
 // For great modding!!
 
@@ -450,7 +452,11 @@ void A_SpawnFreshCopy(void *actor);
 extern boolean actionsoverridden[NUMACTIONS];
 
 // ratio of states to sprites to mobj types is roughly 6 : 1 : 1
+#ifdef COMPAT_VANILLA
 #define NUMMOBJFREESLOTS 1024
+#else
+#define NUMMOBJFREESLOTS 4096 // should be sufficient
+#endif
 #define NUMSPRITEFREESLOTS NUMMOBJFREESLOTS
 #define NUMSTATEFREESLOTS (NUMMOBJFREESLOTS*8)
 

src/k_director.c

@@ -446,6 +446,12 @@ 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

src/k_hud.c

@@ -83,6 +83,7 @@ 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
 
@@ -92,10 +93,13 @@ 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};
 
+consvar_t cv_spinoutroll = {"spinoutroll", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 static CV_PossibleValue_t posanim_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Smooth"}, {0, NULL}};
 consvar_t cv_posanim        = {"postitionanimation", "On", CV_SAVE, posanim_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_smallposnum    = {"smallpositionnumber", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -108,6 +112,11 @@ consvar_t cv_fancyroulette = {"animatedroulette", "Off", CV_SAVE, CV_OnOff, NULL
 consvar_t cv_darkitembox   = {"darkitembox", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // itembox gets a dark border with specific items
 consvar_t cv_multiitemicon = {"multiitemicon", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
+enum { ROULETTECOLOR_NONE = -1, ROULETTECOLOR_HUD, ROULETTECOLOR_PLAYER, ROULETTECOLOR_ITEM };
+static CV_PossibleValue_t roulettecolor_cons_t[] = {
+	{ROULETTECOLOR_NONE, "None"}, {ROULETTECOLOR_HUD, "Hud"}, {ROULETTECOLOR_PLAYER, "Player"}, {ROULETTECOLOR_ITEM, "Item"}, {0, NULL}};
+consvar_t cv_roulettecolor = {"roulettecolor", "Hud", CV_SAVE, roulettecolor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 consvar_t cv_showlaptimes = {"showlaptimes", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_biglaps = {"biglaphud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // here for ppl who dont want to make 2 more patches for their custom hud
@@ -207,6 +216,7 @@ 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);
@@ -221,7 +231,9 @@ void K_RegisterKartHudStuff(void)
 
 	CV_RegisterVar(&cv_minihead);
 	CV_RegisterVar(&cv_showminimapnames);
+	CV_RegisterVar(&cv_showminimapfinished);
 	CV_RegisterVar(&cv_showminimapangle);
+	CV_RegisterVar(&cv_spinoutroll);
 
 	CV_RegisterVar(&cv_showlapemblem);
 
@@ -239,6 +251,8 @@ void K_RegisterKartHudStuff(void)
 	CV_RegisterVar(&cv_multiitemicon);
 	CV_RegisterVar(&cv_huditemamount);
 
+	CV_RegisterVar(&cv_roulettecolor);
+
 	CV_RegisterVar(&cv_highresportrait);
 
 	CV_RegisterVar(&cv_nametag);
@@ -270,7 +284,6 @@ 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};
 
@@ -308,7 +321,6 @@ 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};
 
@@ -474,11 +486,6 @@ 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);
@@ -533,14 +540,6 @@ 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 --
@@ -568,7 +567,7 @@ static patch_t *kp_racefinish[6];
 static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES];
 static patch_t *kp_winnernum[NUMPOSFRAMES];
 
-static patch_t *kp_facenum[MAXPLAYERS+1];
+patch_t *kp_facenum[MAXPLAYERS+1] = {};
 static patch_t *kp_facehighlight[8];
 
 static patch_t *kp_rankbumper;
@@ -875,7 +874,7 @@ void K_LoadKartHUDGraphics(void)
 
 	kp_yougotem = (patch_t *)W_CachePatchName("YOUGOTEM", PU_HUDGFX);
 
-	if (found_extra_kart || found_extra2_kart || found_extra3_kart)
+	if (found_extra_kart || found_extra2_kart)
 		K_LoadSaturnHUDGraphics();
 }
 
@@ -931,21 +930,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
 
 //}
 
-INT32 ITEM_X, ITEM_Y;	// Item Window
-INT32 TIME_X, TIME_Y;	// Time Sticker
-INT32 LAPS_X, LAPS_Y;	// Lap Sticker
-INT32 SPDM_X, SPDM_Y;	// Speedometer
-INT32 POSI_X, POSI_Y;	// Position Number
-INT32 FACE_X, FACE_Y;	// Top-four Faces
-INT32 STCD_X, STCD_Y;	// Starting countdown
-INT32 CHEK_Y;			// CHECK graphic
-INT32 MINI_X, MINI_Y;	// Minimap
-INT32 WANT_X, WANT_Y;	// Battle WANTED poster
+static INT32 ITEM_X, ITEM_Y;	// Item Window
+static INT32 TIME_X, TIME_Y;	// Time Sticker
+static INT32 LAPS_X, LAPS_Y;	// Lap Sticker
+static INT32 SPDM_X, SPDM_Y;	// Speedometer
+static INT32 POSI_X, POSI_Y;	// Position Number
+static INT32 FACE_X, FACE_Y;	// Top-four Faces
+static INT32 STCD_X, STCD_Y;	// Starting countdown
+static INT32 CHEK_Y;			// CHECK graphic
+static INT32 MINI_X, MINI_Y;	// Minimap
+static INT32 WANT_X, WANT_Y;	// Battle WANTED poster
 
 // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
-INT32 ITEM2_X, ITEM2_Y;
-INT32 LAPS2_X, LAPS2_Y;
-INT32 POSI2_X, POSI2_Y;
+static INT32 ITEM2_X, ITEM2_Y;
+static INT32 LAPS2_X, LAPS2_Y;
+static INT32 POSI2_X, POSI2_Y;
 
 static void K_initKartHUD(void)
 {
@@ -1065,7 +1064,7 @@ static void K_initKartHUD(void)
 	}
 
 	if (timeinmap > 113 || forceshowhud)
-		hudtrans = cv_translucenthud.value;
+		hudtrans = (UINT8)cv_translucenthud.value;
 	else if (timeinmap > 105)
 		hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105);
 	else
@@ -1122,9 +1121,9 @@ void K_KartPlayerHUDUpdate(player_t *player)
 UINT8 K_GetHudColor(void)
 {
 	if (cv_colorizedhud.value && cv_colorizedhudcolor.value)
-		return cv_colorizedhudcolor.value;
+		return (UINT8)cv_colorizedhudcolor.value;
 
-	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value);
+	return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : (UINT8)cv_playercolor.value);
 }
 
 boolean K_UseColorHud(void)
@@ -1145,10 +1144,9 @@ enum
 	SPEEDO_DIAL,
 	SPEEDO_PMETER,
 	SPEEDO_PMETERSMOL,
-	SPEEDO_EXTRA3,
 };
 
-static SINT8 K_GetSpeedometerStyle(void)
+static UINT8 K_GetSpeedometerStyle(void)
 {
 	if (cv_newspeedometer.value == 2 && xtra_speedo)
 		return SPEEDO_EXTRA;
@@ -1160,8 +1158,6 @@ 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;
 }
@@ -1179,8 +1175,6 @@ 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;
 	}
@@ -1192,7 +1186,6 @@ enum
 	GAUGE_SMALL,
 	GAUGE_BIGNUM,
 	GAUGE_NUMONLY,
-	GAUGE_EXTRA,
 };
 
 static SINT8 K_GetDriftgaugeStyle(void)
@@ -1205,8 +1198,6 @@ 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
@@ -1358,10 +1349,12 @@ 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;
 }
@@ -1403,7 +1396,6 @@ static void K_drawKartStats(void)
 		{
 			case SPEEDO_EXTRA:
 			case SPEEDO_ACHII:
-			case SPEEDO_EXTRA3:
 				spdoffset = -10;
 				break;
 			case SPEEDO_DIAL:
@@ -1415,8 +1407,6 @@ static void K_drawKartStats(void)
 				break;
 		}
 	}
-	else
-		spdoffset = 0;
 
 	if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
 		spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
@@ -1436,13 +1426,16 @@ static void K_drawKartStats(void)
 		fakeskin = K_GetPlayerSkin(stplyr);
 
 		// Skin name
-		if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
+		if (cv_showstats_skinname.value)
 		{
-			V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
-		}
-		else
-		{
-			V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
+			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);
+			}
 		}
 
 		// Icon and stats
@@ -1524,74 +1517,77 @@ static void K_drawKartItem(void)
 
 	if (stplyr->kartstuff[k_itemroulette])
 	{
-		localcolor = K_GetHudColor();
+		if (cv_roulettecolor.value == ROULETTECOLOR_PLAYER)
+			localcolor = stplyr->skincolor;
+		else if (cv_roulettecolor.value != ROULETTECOLOR_NONE)
+			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
 				localpatch = kp_sneaker[offset];
-				//localcolor = SKINCOLOR_RASPBERRY;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_RASPBERRY;
 				break;
 			case 1: // Banana
 				localpatch = kp_banana[offset];
-				//localcolor = SKINCOLOR_YELLOW;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_YELLOW;
 				break;
 			case 2: // Orbinaut
 				localpatch = kp_orbinaut[3+offset];
-				//localcolor = SKINCOLOR_STEEL;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
 				break;
 			case 3: // Mine
 				localpatch = kp_mine[offset];
-				//localcolor = SKINCOLOR_JET;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JET;
 				break;
 			case 4: // Grow
 				localpatch = kp_grow[offset];
-				//localcolor = SKINCOLOR_TEAL;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TEAL;
 				break;
 			case 5: // Hyudoro
 				localpatch = kp_hyudoro[offset];
-				//localcolor = SKINCOLOR_STEEL;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
 				break;
 			case 6: // Rocket Sneaker
 				localpatch = kp_rocketsneaker[offset];
-				//localcolor = SKINCOLOR_TANGERINE;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TANGERINE;
 				break;
 			case 7: // Jawz
 				localpatch = kp_jawz[offset];
-				//localcolor = SKINCOLOR_JAWZ;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JAWZ;
 				break;
 			case 8: // Self-Propelled Bomb
 				localpatch = kp_selfpropelledbomb[offset];
-				//localcolor = SKINCOLOR_JET;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_JET;
 				break;
 			case 9: // Shrink
 				localpatch = kp_shrink[offset];
-				//localcolor = SKINCOLOR_ORANGE;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_ORANGE;
 				break;
 			case 10: // Invincibility
 				localpatch = localinv;
-				//localcolor = SKINCOLOR_GREY;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_GREY;
 				break;
 			case 11: // Eggman Monitor
 				localpatch = kp_eggman[offset];
-				//localcolor = SKINCOLOR_ROSE;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_ROSE;
 				break;
 			case 12: // Ballhog
 				localpatch = kp_ballhog[offset];
-				//localcolor = SKINCOLOR_LILAC;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_LILAC;
 				break;
 			case 13: // Thunder Shield
 				localpatch = kp_thundershield[offset];
-				//localcolor = SKINCOLOR_CYAN;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_CYAN;
 				break;
 			/*case 14: // Pogo Spring
 				localpatch = kp_pogospring[offset];
-				localcolor = SKINCOLOR_TANGERINE;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_TANGERINE;
 				break;
 			case 15: // Kitchen Sink
 				localpatch = kp_kitchensink[offset];
-				localcolor = SKINCOLOR_STEEL;
+				if (cv_roulettecolor.value == ROULETTECOLOR_ITEM) localcolor = SKINCOLOR_STEEL;
 				break;*/
 			default:
 				break;
@@ -2096,7 +2092,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 && num >= 10)
+			if (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.
@@ -2178,8 +2174,9 @@ static boolean K_drawKartPositionFaces(void)
 	UINT8 *colormap;
 
 	ranklines = 0;
-	memset(completed, 0, sizeof (completed));
-	memset(rankplayer, 0, sizeof (rankplayer));
+
+	if (!LUA_HudEnabled(hud_minirankings))
+		return false; // Don't proceed but still return true for free play above if HUD is disabled.
 
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
@@ -2194,8 +2191,7 @@ static boolean K_drawKartPositionFaces(void)
 	if (numplayersingame <= 1)
 		return true;
 
-	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));
 
 	for (j = 0; j < numplayersingame; j++)
 	{
@@ -2252,6 +2248,7 @@ static boolean K_drawKartPositionFaces(void)
 
 		if (!playeringame[rankplayer[i]])
 			continue;
+
 		if (player->spectator || !player->mo)
 			continue;
 
@@ -2429,7 +2426,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) && (K_UseColorHud() ? big_lap_color : big_lap) && (!stplyr->exiting));
+	return (cv_biglaps.value && (cv_numlaps.value > 9) && !stplyr->exiting && (K_UseColorHud() ? big_lap_color : big_lap));
 }
 
 static void K_drawKartLaps(void)
@@ -2638,7 +2635,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
@@ -2707,34 +2704,28 @@ static void K_drawKartSpeedometer(void)
 
 		V_DrawKartString(SPDM_X, SPDM_Y, V_HUDTRANS|splitflags, metric);
 	}
-	else if (speedostyle == SPEEDO_EXTRA) // why bother if we dont?
+	else if (speedostyle == SPEEDO_EXTRA || speedostyle == SPEEDO_ACHII) // why bother if we dont?
 	{
-		if (K_UseColorSpeedo(SPEEDO_EXTRA)) //Colourized hud
+		patch_t *speedopat;
+		UINT8 *colormap = NULL;
+
+		if (K_UseColorSpeedo(speedostyle)) //Colourized hud
 		{
-			UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
-			V_DrawMappedPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallstickerclr, colormap);
+			colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+
+			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]);
 		}
 		else
-			V_DrawScaledPatch(SPDM_X + 1, SPDM_Y + 4, V_HUDTRANS|splitflags, skp_smallsticker);
+		{
+			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_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
-		{
-			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_DrawMappedPatch(SPDM_X + 31, SPDM_Y + 4, V_HUDTRANS|splitflags, speedopat, colormap);
 	}
 #ifdef ROTSPRITE
 	else if (speedostyle == SPEEDO_DIAL)  // why bother if we dont?
@@ -2747,46 +2738,36 @@ 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 speedIntervals[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 spdinterval[22] = { 2,  5,  7, 10,
+											  12, 15, 17, 20,
+											  22, 25, 27, 30,
+											  32, 35, 37, 40,
+											  42, 45, 47, 50,
+											  52, 55};
 
-		fuspeed = FixedDiv(stplyr->speed, mapobjectscale)/FRACUNIT;
+		const fixed_t spd = FixedDiv(stplyr->speed, mapobjectscale) / FRACUNIT;
 
-		for (INT32 i = 0; i < 22; ++i)
+		if (spd > 54)
 		{
-			if (fuspeed < speedIntervals[i])
+			spdpatch = (leveltime & 4) ? 24 : 23;
+		}
+		else
+		{
+			for (INT32 i = 0; i < 22; ++i)
 			{
-				spdpatch = i;
-				break;
+				if (spd < spdinterval[i])
+				{
+					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]);
 	}
 }
@@ -2814,7 +2795,7 @@ static void K_drawKartBumpersOrKarma(void)
 	{
 		const UINT8 speedostyle = K_GetSpeedometerStyle();
 
-		if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII) || (speedostyle == SPEEDO_EXTRA3))
+		if ((speedostyle == SPEEDO_EXTRA) || (speedostyle == SPEEDO_ACHII))
 			fy += 5;
 		else
 			fy += 7;
@@ -2906,10 +2887,12 @@ 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;
 
@@ -2991,7 +2974,7 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
 		if (stplyrnum > 0)
 			y = y + yres;
 	}
-	if (splitscreen >= 2) // 3P or 4P
+	else if (splitscreen >= 2) // 3P or 4P
 	{
 		x = x>>1;
 		y = y>>1;
@@ -3051,9 +3034,11 @@ 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;
 
@@ -3262,13 +3247,12 @@ static void K_drawDriftGauge(void)
 	if (!splitscreen && !camera->chase)
 		return;
 
-	if (forceshowhud)
-		goto skipcrap; // i will skip the drift early return and you cant stop me!
-
-	if (!stplyr->kartstuff[k_drift])
-		return;
-
-skipcrap:
+	// i will skip the drift early return and you cant stop me!
+	if (!forceshowhud)
+	{
+		if (!stplyr->kartstuff[k_drift])
+			return;
+	}
 
 	if (P_MobjWasRemoved(stplyr->mo))
 		return;
@@ -3293,12 +3277,11 @@ skipcrap:
 	{
 		case GAUGE_DEFAULT:
 		case GAUGE_SMALL:
-		case GAUGE_EXTRA:
 		case GAUGE_BIGNUM:
 			{
 				patch_t *driftpatch = NULL;
 
-				if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM || gaugestyle == GAUGE_EXTRA)
+				if (gaugestyle == GAUGE_DEFAULT || gaugestyle == GAUGE_BIGNUM)
 				{
 					barx = basex - vid.dup*23;
 					BAR_WIDTH = vid.dup*47;
@@ -3311,30 +3294,15 @@ skipcrap:
 
 				bary = basey - vid.dup*2;
 
-				if (gaugestyle == GAUGE_EXTRA) // i hate hud code i hate hud code i hate hud code i hate hud code i hate hud code.....
+				if (K_UseColorHud()) // Colourized hud
 				{
-					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);
+					colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
+					driftpatch = (gaugestyle == GAUGE_SMALL ? driftgaugesmallcolor : driftgaugecolor);
 				}
 				else
-				{
-					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);
+					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
 				{
@@ -3632,7 +3600,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(mo->player);
+	const boolean minihead = K_useSmallMinimapHead(player);
 
 	// thx wanted reticle for having weird offsets very cool
 	wntdamxpos = minihead ? amxpos + (1<<FRACBITS) : amxpos - (4<<FRACBITS);
@@ -3774,6 +3742,9 @@ 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
@@ -3818,7 +3789,7 @@ static void K_drawKartMinimap(void)
 
 		if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
 		{
-			UINT8 *colormap;
+			UINT8 *colormap = NULL;
 			drawinfo_t dims;
 			fixed_t interpx, interpy;
 			fixed_t xoff = 0, yoff = 0;
@@ -3829,10 +3800,27 @@ static void K_drawKartMinimap(void)
 			if (encoremode)
 				ang = ANGLE_180 - ang;
 
-			if (mobj->colorized)
-				colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
-			else
-				colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+			if (mobj->color)
+			{
+				if (mobj->colorized)
+				{
+					colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
+				}
+				else
+				{
+					const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
+
+					// special case if startcolor is not the default (160 / Green)
+					if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
+					{
+						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
+					}
+					else
+					{
+						colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
+					}
+				}
+			}
 
 			interpx = lerp(mobj->old_x, mobj->x);
 			interpy = lerp(mobj->old_y, mobj->y);
@@ -3997,6 +3985,7 @@ 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)
@@ -4061,7 +4050,7 @@ static void K_drawBattleFullscreen(void)
 		{
 			if (i == displayplayers[0])
 				continue;
-			if (playeringame[i] && !stplyr->spectator)
+			if (playeringame[i])
 				return;
 		}
 
@@ -4278,6 +4267,7 @@ static void K_drawInput(void)
 
 	y -= FRACUNIT;
 
+	// stick displays
 	if (cv_showinput.value == 2 || cv_showinput.value == 3)
 	{
 		INT32 axis;
@@ -4287,7 +4277,7 @@ static void K_drawInput(void)
 		const INT32 joyy = y>>FRACBITS;
 		static const INT32 joyxoffs = -8;
 		static const INT32 joyyoffs = -24;
-		const boolean usejoysprite  = (cv_showinput.value == 3 && joystickicon);
+		const boolean usejoysprite = (cv_showinput.value == 3 && joystickicon);
 
 		// O backing
 		if (usejoysprite)
@@ -4305,39 +4295,20 @@ static void K_drawInput(void)
 		// kart does not have anything we can get analogue joystick y axis values from
 		// during normal gameplay, so replicate shit here
 
-		// this is horrid but we cant get actual input in replays so uhh
-		if (demo.playback || !P_IsLocalPlayer(stplyr)) // yeah...........
+		const boolean analogjoystickmove = (!demo.playback && P_IsLocalPlayer(stplyr) && cv_usejoystick[stplyrnum].value && !DigitalGamepadStyle(stplyrnum));
+		axis = analogjoystickmove ? JoyAxis(AXISAIM, stplyrnum+1) : 0;
+
+		if (axis != 0)
 		{
-			hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN;
+			hudforward -= ((axis * KART_FULLTURN) / JOYAXISRANGE);
 		}
 		else
 		{
-			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;
-
-			axis = JoyAxis(AXISAIM, ssplayer);
-
-			if (analogjoystickmove && axis != 0)
-			{
-				// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
-				hudforward -= ((axis * KART_FULLTURN) / (JOYAXISRANGE-1));
-			}
-			else
-			{
-				if (InputDown(gc_aimforward, ssplayer) || (gamepadjoystickmove && axis < 0))
-				{
-					hudforward += KART_FULLTURN;
-				}
-				if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0))
-				{
-					hudforward-= KART_FULLTURN;
-				}
-			}
-
-			hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN);
+			hudforward = stplyr->kartstuff[k_throwdir] * KART_FULLTURN;
 		}
 
+		hudforward = CLAMP(hudforward, -KART_FULLTURN, KART_FULLTURN);
+
 		if (cmd->driftturn || hudforward)
 		{
 			INT16 turning = encoremode ? -cmd->driftturn : cmd->driftturn;
@@ -4370,7 +4341,7 @@ static void K_drawInput(void)
 			}
 		}
 	}
-	else
+	else // wheel
 	{
 		if (!cmd->driftturn) // no turn
 			target = 0;
@@ -4417,6 +4388,7 @@ 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
@@ -4425,6 +4397,9 @@ static void K_drawChallengerScreen(void)
 
 static void K_drawLapStartAnim(void)
 {
+	if (!cv_showlapemblem.value)
+		return;
+
 	// This is an EVEN MORE insanely complicated animation.
 	const UINT8 progress = 80-stplyr->kartstuff[k_lapanimation];
 	UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, K_GetHudColor(), GTC_CACHE);
@@ -4468,7 +4443,10 @@ static void K_drawLapStartAnim(void)
 		V_DrawFixedPatch(leftx, y, FRACUNIT, vflags, kp_lapanim_lap[min(progress/2, 6)], NULL);
 
 		char *lapnum = va("%02d", stplyr->laps + 1);
-		for (int i = 0; i < (int)strlen(lapnum); i++)
+
+		const int laplength = (int)strlen(lapnum);
+
+		for (int i = 0; i < laplength; i++)
 		{
 			int digit = lapnum[i] - '0';
 			int frame = min(2, progress/2 - 8 - (i*2));
@@ -4516,6 +4494,7 @@ static void K_drawDistributionDebugger(void)
 		kp_orbinaut[4],
 		kp_jawz[1]
 	};
+
 	INT32 useodds = 0;
 	INT32 pingame = 0, bestbumper = 0;
 	INT32 i;
@@ -4532,8 +4511,10 @@ 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];
 	}
@@ -4687,6 +4668,7 @@ void K_drawKartHUD(void)
 	{
 		if (LUA_HudEnabled(hud_battlefullscreen))
 			K_drawBattleFullscreen();
+
 		return;
 	}
 
@@ -4846,7 +4828,7 @@ void K_drawKartHUD(void)
 	{
 		if (stplyr->exiting)
 			K_drawKartFinish();
-		else if (stplyr->kartstuff[k_lapanimation] && !splitscreen && cv_showlapemblem.value)
+		else if (stplyr->kartstuff[k_lapanimation] && !splitscreen)
 			K_drawLapStartAnim();
 	}
 

src/k_hud.h

@@ -35,11 +35,16 @@ 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;
 extern consvar_t cv_multiitemicon;
 extern consvar_t cv_huditemamount;
+extern consvar_t cv_roulettecolor;
+
+// for use in timeattack menu
+extern patch_t *kp_facenum[MAXPLAYERS+1];
 
 #define NUMSPEEDOSTUFF 8
 extern CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF];