Merge branch 'main' into windows-clang-fixes

tested that vanity npcs now chat when close, and then on a cooldown

.github/workflows/build-and-push-docker.yml

@@ -1,4 +1,4 @@
-name: CI
+name: Build and Update Docker 
 
 on:
   push:

.github/workflows/build-and-test.yml

@@ -1,4 +1,4 @@
-name: CI
+name: Build And Test
 
 on:
   push:
@@ -14,6 +14,13 @@ jobs:
     strategy:
       matrix:
         os: [ windows-2022, ubuntu-22.04, macos-13 ]
+        include:
+          - os: windows-2022
+            configureType: windows-msvc
+          - os: ubuntu-22.04
+            configureType: linux-gnu
+          - os: macos-13
+            configureType: macos
 
     steps:
     - uses: actions/checkout@v4
@@ -33,19 +40,13 @@ jobs:
     - name: cmake
       uses: lukka/run-cmake@v10
       with:
-        workflowPreset: "ci-${{matrix.os}}"
+        configurePreset: "${{matrix.configureType}}"
+        buildPreset: "ci-${{matrix.os}}"
+        testPreset: "ci-${{matrix.os}}"
+
     - name: artifacts
       uses: actions/upload-artifact@v4
       with:
         name: build-${{matrix.os}}
         path: |
-          build/*/*Server*
+          build/*
-          build/*/*.ini
-          build/*/*.so
-          build/*/*.dll
-          build/*/vanity/
-          build/*/navmeshes/
-          build/*/migrations/
-          build/*/*.dcf
-          !build/*/*.pdb
-          !build/*/d*/

.gitignore

@@ -95,6 +95,7 @@ ipch/
 
 # Exceptions:
 CMakeSettings.json
+CMakeUserPresets.json
 *.vcxproj
 *.filters
 *.cmake
@@ -112,6 +113,8 @@ CMakeFiles/TargetDirectories.txt
 *.sln
 *.recipe
 
+CMakeUserPresets.json
+
 # clangd
 .cache
 thirdparty/zlib-1.2.11/

CMakeLists.txt

@@ -19,6 +19,14 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 	# Export the compile commands for debuggi
 set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) 	# Set CMAKE visibility policy to NEW on project and subprojects
 set(CMAKE_VISIBILITY_INLINES_HIDDEN ON) # Set C and C++ symbol visibility to hide inlined functions
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+  
+set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build, options are: Debug, Release, RelWithDebInfo, MinSizeRel")
+
+if (${CMAKE_BUILD_TYPE} MATCHES "") # CI likes to set CMAKE_BUILD_TYPE to an empty string
+    set(CMAKE_BUILD_TYPE "RelWithDebInfo")
+endif()
+
+set(DLU_CONFIG_DIR ${CMAKE_SOURCE_DIR}/build CACHE PATH "The directory where the server configuration files are stored")
 
 # Read variables from file
 FILE(READ "${CMAKE_SOURCE_DIR}/CMakeVariables.txt" variables)
@@ -66,12 +74,13 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
+	add_link_options("-Wl,-rpath,$ORIGIN/")
 	add_compile_options("-fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)
 
 	# For all except Clang and Apple Clang
 	if(NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-		add_compile_options("-static-libgcc" "-lstdc++fs")
+		add_compile_options("-static-libgcc" "-lstdc++fs" "-Wno-error=implicit-function-declaration" "-Wno-error=int-conversion")
 	endif()
 
 	if(${DYNAMIC} AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -89,10 +98,11 @@ elseif(WIN32)
 	add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()
 
-# Our output dir
+# Set the output directories
-#set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE ON) # unfortunately, forces all libraries to be built in series, which will slow down the build process
+# ./build/<platform + architecture (x64, x86, aarch64)>/<compiler>/<build_mode>/
+
+set(CMAKE_BINARY_DIR ${CMAKE_BINARY_DIR}/${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}/${CMAKE_CXX_COMPILER_ID}/${CMAKE_BUILD_TYPE})
 
-# TODO make this not have to override the build type directories
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
@@ -107,6 +117,15 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
+# Get DLU config directory
+if(DEFINED ENV{DLU_CONFIG_DIR})
+	set(DLU_CONFIG_DIR $ENV{DLU_CONFIG_DIR})
+else()
+	set(DLU_CONFIG_DIR ${CMAKE_BINARY_DIR})
+endif()
+
+message(STATUS "Configuration Directory is ${DLU_CONFIG_DIR}, and the build directory is ${CMAKE_BINARY_DIR}")
+
 find_package(MariaDB)
 
 # Create a /resServer directory
@@ -115,18 +134,11 @@ make_directory(${CMAKE_BINARY_DIR}/resServer)
 # Create a /logs directory
 make_directory(${CMAKE_BINARY_DIR}/logs)
 
-# Get DLU config directory
-if(DEFINED ENV{DLU_CONFIG_DIR})
-	set(DLU_CONFIG_DIR $ENV{DLU_CONFIG_DIR})
-else()
-	set(DLU_CONFIG_DIR ${PROJECT_BINARY_DIR})
-endif()
-message(STATUS "Variable: DLU_CONFIG_DIR = ${DLU_CONFIG_DIR}")
-
 # Copy resource files on first build
 set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
 message(STATUS "Checking resource file integrity")
 
+
 include(Utils)
 UpdateConfigOption(${DLU_CONFIG_DIR}/authconfig.ini "port" "auth_server_port")
 UpdateConfigOption(${DLU_CONFIG_DIR}/chatconfig.ini "port" "chat_server_port")
@@ -195,15 +207,15 @@ endforeach()
 message(STATUS "Resource file integrity check complete")
 
 # if navmeshes directory does not exist, create it
-if(NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes)
+if(NOT EXISTS ${CMAKE_BINARY_DIR}/navmeshes)
-	file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/navmeshes)
+	file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/navmeshes)
 endif()
 
 # Copy navmesh data on first build and extract it
-configure_file(${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${PROJECT_BINARY_DIR}/navmeshes.zip COPYONLY)
+configure_file(${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${CMAKE_BINARY_DIR}/navmeshes.zip COPYONLY)
 
-file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip DESTINATION ${PROJECT_BINARY_DIR}/navmeshes)
+file(ARCHIVE_EXTRACT INPUT ${CMAKE_BINARY_DIR}/navmeshes.zip DESTINATION ${CMAKE_BINARY_DIR}/navmeshes)
-file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)
+file(REMOVE ${CMAKE_BINARY_DIR}/navmeshes.zip)
 
 # Copy vanity files on first build
 set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "root.xml" "dev-tribute.xml" "atm.xml" "demo.xml")
@@ -213,20 +225,20 @@ foreach(file ${VANITY_FILES})
 endforeach()
 
 # Move our migrations for MasterServer to run
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/dlu/)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/migrations/dlu/)
 file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/dlu/*.sql)
 
 foreach(file ${SQL_FILES})
 	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${PROJECT_BINARY_DIR}/migrations/dlu/${file})
+	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${CMAKE_BINARY_DIR}/migrations/dlu/${file})
 endforeach()
 
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/cdserver/)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/migrations/cdserver/)
 file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/cdserver/*.sql)
 
 foreach(file ${SQL_FILES})
 	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${PROJECT_BINARY_DIR}/migrations/cdserver/${file})
+	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${CMAKE_BINARY_DIR}/migrations/cdserver/${file})
 endforeach()
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -312,7 +324,7 @@ add_subdirectory(dPhysics)
 add_subdirectory(dServer)
 
 # Create a list of common libraries shared between all binaries
-set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "MariaDB::ConnCpp" "magic_enum")
+set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "magic_enum")
 
 # Add platform specific common libraries
 if(UNIX)

CMakePresets.json

@@ -11,75 +11,37 @@
 			"displayName": "Default configure step",
 			"description": "Use 'build' dir and Unix makefiles",
 			"binaryDir": "${sourceDir}/build",
-			"environment": {
+			"generator": "Unix Makefiles",
-				"DLU_CONFIG_DIR": "${sourceDir}/build"
+			"hidden": true
-			},
-			"generator": "Unix Makefiles"
-		},
-		{
-			"name": "debug-config",
-			"hidden": true,
-			"cacheVariables": {
-				"CMAKE_BUILD_TYPE": "Debug"
-			}
-		},
-		{
-			"name": "relwithdebinfo-config",
-			"hidden": true,
-			"cacheVariables": {
-				"CMAKE_BUILD_TYPE": "RelWithDebInfo"
-			}
-		},
-		{
-			"name": "release-config",
-			"hidden": true,
-			"cacheVariables": {
-				"CMAKE_BUILD_TYPE": "Release"
-			}
-		},
-		{
-			"name": "clang-config",
-			"hidden": true,
-			"toolchainFile": "${sourceDir}/cmake/toolchains/linux-clang.cmake"
-		},
-		{
-			"name": "gnu-config",
-			"hidden": true,
-			"toolchainFile": "${sourceDir}/cmake/toolchains/linux-gnu.cmake"
-		},
-		{
-			"name": "windows-msvc",
-			"inherits": "default",
-			"displayName": "[Multi] Windows (MSVC)",
-			"description": "Set architecture to 64-bit (b/c RakNet)",
-			"generator": "Visual Studio 17 2022",
-			"binaryDir": "${sourceDir}/build/msvc",
-			"architecture": {
-				"value": "x64"
-			},
-			"condition": {
-				"type": "equals",
-				"lhs": "${hostSystemName}",
-				"rhs": "Windows"
-			}
 		},
 		{
 			"name": "windows-default",
-			"inherits": "windows-msvc",
+			"inherits": "default",
-			"displayName": "Windows only Configure Settings",
+			"displayName": "Windows Default Configure Settings",
 			"description": "Sets build and install directories",
-			"generator": "Ninja",
+			"generator": "Visual Studio 17 2022",
 			"condition": {
 				"type": "equals",
 				"lhs": "${hostSystemName}",
 				"rhs": "Windows"
 			},
-			"architecture": {
+			"hidden": true
-				"value": "x64"
-			}
 		},
 		{
-			"name": "linux-config",
+			"name": "windows-msvc",
+			"inherits": "windows-default",
+			"displayName": "Windows (MSVC)",
+			"description": "Create a build using MSVC"
+		},
+		{
+			"name": "windows-clang",
+			"inherits": "windows-default",
+			"displayName": "EXPERIMENTAL - Windows (Clang)",
+			"description": "Create a build using Clang",
+			"toolset": "ClangCL"
+		},
+		{
+			"name": "linux-default",
 			"inherits": "default",
 			"hidden": true,
 			"condition": {
@@ -89,553 +51,74 @@
 			}
 		},
 		{
-			"name": "linux-clang-debug",
+			"name": "linux-clang",
-			"inherits": [
+			"inherits": "linux-default",
-				"linux-config",
+			"toolchainFile": "${sourceDir}/cmake/toolchains/linux-clang.cmake",
-				"clang-config",
+			"displayName": "Linux (Clang)",
-				"debug-config"
+			"description": "Create a build using the Clang toolchain for Linux"
-			],
-			"displayName": "EXPERIMENTAL - [Debug] Linux (Clang)",
-			"description": "Create a debug build using the Clang toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/clang-debug"
 		},
 		{
-			"name": "linux-clang-relwithdebinfo",
+			"name": "linux-gnu",
-			"inherits": [
+			"inherits": "linux-default",
-				"linux-config",
+			"toolchainFile": "${sourceDir}/cmake/toolchains/linux-gnu.cmake",
-				"clang-config",
+			"displayName": "Linux (GNU)",
-				"relwithdebinfo-config"
+			"description": "Create a build using the GNU toolchain for Linux"
-			],
-			"displayName": "EXPERIMENTAL - [RelWithDebInfo] Linux (Clang)",
-			"description": "Create a release build with debug info using the Clang toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/clang-relwithdebinfo"
-		},
-		{
-			"name": "linux-clang-release",
-			"inherits": [
-				"linux-config",
-				"clang-config",
-				"release-config"
-			],
-			"displayName": "EXPERIMENTAL - [Release] Linux (Clang)",
-			"description": "Create a release build using the Clang toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/clang-release"
-		},
-		{
-			"name": "linux-gnu-debug",
-			"inherits": [
-				"linux-config",
-				"gnu-config",
-				"debug-config"
-			],
-			"displayName": "[Debug] Linux (GNU)",
-			"description": "Create a debug build using the GNU toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/gnu-debug"
-		},
-		{
-			"name": "linux-gnu-relwithdebinfo",
-			"inherits": [
-				"linux-config",
-				"gnu-config",
-				"relwithdebinfo-config"
-			],
-			"displayName": "[RelWithDebInfo] Linux (GNU)",
-			"description": "Create a release build with debug info using the GNU toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/gnu-relwithdebinfo"
-		},
-		{
-			"name": "linux-gnu-release",
-			"inherits": [
-				"linux-config",
-				"gnu-config",
-				"release-config"
-			],
-			"displayName": "[Release] Linux (GNU)",
-			"description": "Create a release build using the GNU toolchain for Linux",
-			"binaryDir": "${sourceDir}/build/gnu-release"
 		},
 		{
 			"name": "macos",
 			"inherits": "default",
-			"displayName": "[Multi] MacOS",
+			"displayName": "MacOS",
 			"description": "Create a build for MacOS",
 			"condition": {
 				"type": "equals",
 				"lhs": "${hostSystemName}",
 				"rhs": "Darwin"
-			},
+			}
-			"binaryDir": "${sourceDir}/build/macos"
 		}
 	],
 	"buildPresets": [
-		{
+        { "name": "ci-ubuntu-22.04", "configurePreset": "linux-gnu"    },
-			"name": "default",
+        { "name": "ci-macos-13",     "configurePreset": "macos"        },
-			"configurePreset": "default",
+        { "name": "ci-windows-2022", "configurePreset": "windows-msvc" }
-			"displayName": "Default Build",
-			"description": "Default Build",
-			"jobs": 2
-		},
-		{
-			"name": "windows-msvc-debug",
-			"inherits": "default",
-			"configurePreset": "windows-msvc",
-			"displayName": "[Debug] Windows (MSVC)",
-			"description": "This preset is used to build in debug mode using the MSVC toolchain on Windows",
-			"configuration": "Debug"
-		},
-		{
-			"name": "windows-msvc-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "windows-msvc",
-			"displayName": "[RelWithDebInfo] Windows (MSVC)",
-			"description": "This preset is used to build in debug mode using the MSVC toolchain on Windows",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "windows-msvc-release",
-			"inherits": "default",
-			"configurePreset": "windows-msvc",
-			"displayName": "[Release] Windows (MSVC)",
-			"description": "This preset is used to build in release mode using the MSVC toolchain on Windows",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-clang-debug",
-			"inherits": "default",
-			"configurePreset": "linux-clang-debug",
-			"displayName": "EXPERIMENTAL - [Debug] Linux (Clang)",
-			"description": "This preset is used to build in debug mode using the Clang toolchain on Linux",
-			"configuration": "Debug"
-		},
-		{
-			"name": "linux-clang-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "linux-clang-relwithdebinfo",
-			"displayName": "EXPERIMENTAL - [RelWithDebInfo] Linux (Clang)",
-			"description": "This preset is used to build in release mode with debug info using the Clang toolchain on Linux",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "linux-clang-release",
-			"inherits": "default",
-			"configurePreset": "linux-clang-release",
-			"displayName": "EXPERIMENTAL - [Release] Linux (Clang)",
-			"description": "This preset is used to build in release mode using the Clang toolchain on Linux",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-gnu-debug",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-debug",
-			"displayName": "[Debug] Linux (GNU)",
-			"description": "This preset is used to build in debug mode using the GNU toolchain on Linux",
-			"configuration": "Debug"
-		},
-		{
-			"name": "linux-gnu-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-relwithdebinfo",
-			"displayName": "[RelWithDebInfo] Linux (GNU)",
-			"description": "This preset is used to build in release mode with debug info using the GNU toolchain on Linux",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "linux-gnu-release",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-release",
-			"displayName": "[Release] Linux (GNU)",
-			"description": "This preset is used to build in release mode using the GNU toolchain on Linux",
-			"configuration": "Release"
-		},
-		{
-			"name": "macos-debug",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[Debug] MacOS",
-			"description": "This preset is used to build in debug mode on MacOS",
-			"configuration": "Debug"
-		},
-		{
-			"name": "macos-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[RelWithDebInfo] MacOS",
-			"description": "This preset is used to build in release mode with debug info on MacOS",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "macos-release",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[Release] MacOS",
-			"description": "This preset is used to build in release mode on MacOS",
-			"configuration": "Release"
-		}
 	],
 	"testPresets": [
+        {
+            "name": "default",
+            "hidden": true,
+            "execution": {
+                "jobs": 2
+            },
+            "output": {
+                "outputOnFailure": true
+            }
+        },
 		{
-			"name": "default",
+			"name": "ci-ubuntu-22.04",
-			"configurePreset": "default",
+			"configurePreset": "linux-gnu",
-			"execution": {
+			"displayName": "CI Tests on Linux",
-				"jobs": 2
+			"inherits": "default"
-			},
-			"output": {
-				"outputOnFailure": true
-			}
 		},
 		{
-			"name": "windows-msvc-test",
+			"name": "ci-macos-13",
-			"inherits": "default",
+			"configurePreset": "macos",
+			"displayName": "CI Tests on MacOS",
+			"inherits": "default"
+		},
+		{
+			"name": "ci-windows-2022",
 			"configurePreset": "windows-msvc",
-			"hidden": true,
+			"displayName": "CI Tests on windows",
+            "inherits": "default",
+            
+			"configuration": "RelWithDebInfo",
 			"filter": {
 				"exclude": {
 					"name": "((example)|(minigzip))+"
 				}
 			}
-		},
-		{
-			"name": "windows-msvc-debug",
-			"inherits": "windows-msvc-test",
-			"configurePreset": "windows-msvc",
-			"displayName": "[Debug] Windows (MSVC)",
-			"description": "Runs all tests on a Windows configuration",
-			"configuration": "Debug"
-		},
-		{
-			"name": "windows-msvc-relwithdebinfo",
-			"inherits": "windows-msvc-test",
-			"configurePreset": "windows-msvc",
-			"displayName": "[RelWithDebInfo] Windows (MSVC)",
-			"description": "Runs all tests on a Windows configuration",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "windows-msvc-release",
-			"inherits": "windows-msvc-test",
-			"configurePreset": "windows-msvc",
-			"displayName": "[Release] Windows (MSVC)",
-			"description": "Runs all tests on a Windows configuration",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-clang-debug",
-			"inherits": "default",
-			"configurePreset": "linux-clang-debug",
-			"displayName": "EXPERIMENTAL - [Debug] Linux (Clang)",
-			"description": "Runs all tests on a Linux Clang configuration",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-clang-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "linux-clang-relwithdebinfo",
-			"displayName": "EXPERIMENTAL - [RelWithDebInfo] Linux (Clang)",
-			"description": "Runs all tests on a Linux Clang configuration",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "linux-clang-release",
-			"inherits": "default",
-			"configurePreset": "linux-clang-release",
-			"displayName": "EXPERIMENTAL - [Release] Linux (Clang)",
-			"description": "Runs all tests on a Linux Clang configuration",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-gnu-debug",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-debug",
-			"displayName": "[Debug] Linux (GNU)",
-			"description": "Runs all tests on a Linux GNU configuration",
-			"configuration": "Release"
-		},
-		{
-			"name": "linux-gnu-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-relwithdebinfo",
-			"displayName": "[RelWithDebInfo] Linux (GNU)",
-			"description": "Runs all tests on a Linux GNU configuration",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "linux-gnu-release",
-			"inherits": "default",
-			"configurePreset": "linux-gnu-release",
-			"displayName": "[Release] Linux (GNU)",
-			"description": "Runs all tests on a Linux GNU configuration",
-			"configuration": "Release"
-		},
-		{
-			"name": "macos-debug",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[Debug] MacOS",
-			"description": "Runs all tests on a MacOS configuration",
-			"configuration": "Debug"
-		},
-		{
-			"name": "macos-relwithdebinfo",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[RelWithDebInfo] MacOS",
-			"description": "Runs all tests on a MacOS configuration",
-			"configuration": "RelWithDebInfo"
-		},
-		{
-			"name": "macos-release",
-			"inherits": "default",
-			"configurePreset": "macos",
-			"displayName": "[Release] MacOS",
-			"description": "Runs all tests on a MacOS configuration",
-			"configuration": "Release"
 		}
 	],
 	"workflowPresets": [
-		{
+
-			"name": "default",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "default"
-				},
-				{
-					"type": "build",
-					"name": "default"
-				},
-				{
-					"type": "test",
-					"name": "default"
-				}
-			]
-		},
-		{
-			"name": "windows-msvc-debug",
-			"displayName": "[Debug] Windows (MSVC)",
-			"description": "MSVC debug workflow preset for Windows",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "windows-msvc"
-				},
-				{
-					"type": "build",
-					"name": "windows-msvc-debug"
-				},
-				{
-					"type": "test",
-					"name": "windows-msvc-debug"
-				}
-			]
-		},
-		{
-			"name": "windows-msvc-relwithdebinfo",
-			"displayName": "[RelWithDebInfo] Windows (MSVC)",
-			"description": "MSVC release with debug info workflow preset for Windows",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "windows-msvc"
-				},
-				{
-					"type": "build",
-					"name": "windows-msvc-relwithdebinfo"
-				},
-				{
-					"type": "test",
-					"name": "windows-msvc-relwithdebinfo"
-				}
-			]
-		},
-		{
-			"name": "ci-windows-2022",
-			"displayName": "[Release] Windows (MSVC)",
-			"description": "CI workflow preset for Windows",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "windows-msvc"
-				},
-				{
-					"type": "build",
-					"name": "windows-msvc-release"
-				},
-				{
-					"type": "test",
-					"name": "windows-msvc-release"
-				}
-			]
-		},
-		{
-			"name": "linux-gnu-debug",
-			"displayName": "[Debug] Linux (GNU)",
-			"description": "GNU debug workflow preset for Linux",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-gnu-debug"
-				},
-				{
-					"type": "build",
-					"name": "linux-gnu-debug"
-				},
-				{
-					"type": "test",
-					"name": "linux-gnu-debug"
-				}
-			]
-		},
-		{
-			"name": "linux-gnu-relwithdebinfo",
-			"displayName": "[RelWithDebInfo] Linux (GNU)",
-			"description": "GNU release with debug info workflow preset for Linux",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-gnu-relwithdebinfo"
-				},
-				{
-					"type": "build",
-					"name": "linux-gnu-relwithdebinfo"
-				},
-				{
-					"type": "test",
-					"name": "linux-gnu-relwithdebinfo"
-				}
-			]
-		},
-		{
-			"name": "ci-ubuntu-22.04",
-			"displayName": "[Release] Linux (GNU)",
-			"description": "CI workflow preset for Ubuntu",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-gnu-release"
-				},
-				{
-					"type": "build",
-					"name": "linux-gnu-release"
-				},
-				{
-					"type": "test",
-					"name": "linux-gnu-release"
-				}
-			]
-		},
-		{
-			"name": "linux-clang-debug",
-			"displayName": "EXPERIMENTAL - [Debug] Linux (Clang)",
-			"description": "Clang debug workflow preset for Linux",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-clang-debug"
-				},
-				{
-					"type": "build",
-					"name": "linux-clang-debug"
-				},
-				{
-					"type": "test",
-					"name": "linux-clang-debug"
-				}
-			]
-		},
-		{
-			"name": "linux-clang-relwithdebinfo",
-			"displayName": "EXPERIMENTAL - [RelWithDebInfo] Linux (Clang)",
-			"description": "Clang release with debug info workflow preset for Linux",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-clang-relwithdebinfo"
-				},
-				{
-					"type": "build",
-					"name": "linux-clang-relwithdebinfo"
-				},
-				{
-					"type": "test",
-					"name": "linux-clang-relwithdebinfo"
-				}
-			]
-		},
-		{
-			"name": "linux-clang-release",
-			"displayName": "EXPERIMENTAL - [Release] Linux (Clang)",
-			"description": "Clang release workflow preset for Linux",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "linux-clang-release"
-				},
-				{
-					"type": "build",
-					"name": "linux-clang-release"
-				},
-				{
-					"type": "test",
-					"name": "linux-clang-release"
-				}
-			]
-		},
-		{
-			"name": "macos-debug",
-			"displayName": "[Debug] MacOS",
-			"description": "Release workflow preset for MacOS",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "macos"
-				},
-				{
-					"type": "build",
-					"name": "macos-debug"
-				},
-				{
-					"type": "test",
-					"name": "macos-debug"
-				}
-			]
-		},
-		{
-			"name": "macos-relwithdebinfo",
-			"displayName": "[RelWithDebInfo] MacOS",
-			"description": "Release with debug info workflow preset for MacOS",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "macos"
-				},
-				{
-					"type": "build",
-					"name": "macos-relwithdebinfo"
-				},
-				{
-					"type": "test",
-					"name": "macos-relwithdebinfo"
-				}
-			]
-		},
-		{
-			"name": "ci-macos-13",
-			"displayName": "[Release] MacOS",
-			"description": "CI workflow preset for MacOS",
-			"steps": [
-				{
-					"type": "configure",
-					"name": "macos"
-				},
-				{
-					"type": "build",
-					"name": "macos-release"
-				},
-				{
-					"type": "test",
-					"name": "macos-release"
-				}
-			]
-		}
 	]
 }

Dockerfile

@@ -23,23 +23,23 @@ RUN --mount=type=cache,id=build-apt-cache,target=/var/cache/apt \
     rm -rf /var/lib/apt/lists/*
 
 # Grab libraries and load them
-COPY --from=build /app/build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/mariadbcpp/libmariadbcpp.so /usr/local/lib/
 RUN ldconfig
 
 # Server bins
-COPY --from=build /app/build/*Server /app/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*Server /app/
 
 # Necessary suplimentary files
-COPY --from=build /app/build/*.ini /app/configs/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*.ini /app/configs/
-COPY --from=build /app/build/vanity/*.* /app/vanity/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/vanity/*.* /app/vanity/
-COPY --from=build /app/build/navmeshes /app/navmeshes
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/navmeshes /app/navmeshes
-COPY --from=build /app/build/migrations /app/migrations
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/migrations /app/migrations
-COPY --from=build /app/build/*.dcf /app/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*.dcf /app/
 
 # backup of config and vanity files to copy to the host incase 
 # of a mount clobbering the copy from above
-COPY --from=build /app/build/*.ini /app/default-configs/ 
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*.ini /app/default-configs/ 
-COPY --from=build /app/build/vanity/*.* /app/default-vanity/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/vanity/*.* /app/default-vanity/
 
 # needed as the container runs with the root user
 # and therefore sudo doesn't exist

cmake/FindMariaDB.cmake

@@ -2,8 +2,8 @@
 # On Windows ClangCL can't compile the connector from source but can link to an msvc compiled one,
 # so prefer the prebuilt binaries unless MARIADB_BUILD_SOURCE is specified
 if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
-	set(MARIADB_MSI_DIR "${PROJECT_BINARY_DIR}/msi")
+	set(MARIADB_MSI_DIR "${CMAKE_BINARY_DIR}/msi")
-	set(MARIADB_CONNECTOR_DIR "${PROJECT_BINARY_DIR}/mariadbcpp")
+	set(MARIADB_CONNECTOR_DIR "${CMAKE_BINARY_DIR}/mariadbcpp")
 	set(MARIADB_C_CONNECTOR_DIR "${MARIADB_CONNECTOR_DIR}/MariaDB/MariaDB Connector C 64-bit")
 	set(MARIADB_CPP_CONNECTOR_DIR "${MARIADB_CONNECTOR_DIR}/MariaDB/MariaDB C++ Connector 64-bit")
 
@@ -59,7 +59,7 @@ if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
 					COMMAND ${CMAKE_COMMAND} -E copy_if_different
 					"${MARIADBCPP_SHARED_LIBRARY_LOCATION}"
 					"${MARIADBC_SHARED_LIBRARY_LOCATION}"
-					"${PROJECT_BINARY_DIR}")
+					"${CMAKE_BINARY_DIR}")
 
 	# MariaDB uses plugins that the database needs to load, the prebuilt binaries by default will try to find the libraries in system directories,
 	# so set this define and the servers will set the MARIADB_PLUGIN_DIR environment variable to the appropriate directory.
@@ -86,13 +86,13 @@ else() # Build from source
 			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0)
 	endif()
 
-	set(MARIADBCPP_INSTALL_DIR ${PROJECT_BINARY_DIR}/prefix)
+	set(MARIADBCPP_INSTALL_DIR ${CMAKE_BINARY_DIR}/prefix)
-	set(MARIADBCPP_LIBRARY_DIR ${PROJECT_BINARY_DIR}/mariadbcpp)
+	set(MARIADBCPP_LIBRARY_DIR ${CMAKE_BINARY_DIR}/mariadbcpp)
 	set(MARIADBCPP_PLUGIN_DIR ${MARIADBCPP_LIBRARY_DIR}/plugin)
 	set(MARIADBCPP_SOURCE_DIR ${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp)
 	set(MARIADB_INCLUDE_DIR "${MARIADBCPP_SOURCE_DIR}/include")
 	ExternalProject_Add(mariadb_connector_cpp
-		PREFIX "${PROJECT_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
+		PREFIX "${CMAKE_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
 		SOURCE_DIR ${MARIADBCPP_SOURCE_DIR}
 		INSTALL_DIR ${MARIADBCPP_INSTALL_DIR}
 		CMAKE_ARGS  -Wno-dev
@@ -127,20 +127,20 @@ else() # Build from source
 endif()
 
 # Create mariadb connector library object
-add_library(MariaDB::ConnCpp SHARED IMPORTED GLOBAL)
+add_library(mariadb_cpp_connector SHARED IMPORTED GLOBAL)
-add_dependencies(MariaDB::ConnCpp mariadb_connector_cpp)
+add_dependencies(mariadb_cpp_connector mariadb_connector_cpp)
-set_target_properties(MariaDB::ConnCpp PROPERTIES
+set_target_properties(mariadb_cpp_connector PROPERTIES
 	IMPORTED_LOCATION "${MARIADBCPP_SHARED_LIBRARY_LOCATION}")
 
 if(WIN32)
-	set_target_properties(MariaDB::ConnCpp PROPERTIES
+	set_target_properties(mariadb_cpp_connector PROPERTIES
 		IMPORTED_IMPLIB "${MARIADB_IMPLIB_LOCATION}")
 elseif(APPLE)
-	set_target_properties(MariaDB::ConnCpp PROPERTIES
+	set_target_properties(mariadb_cpp_connector PROPERTIES
 		IMPORTED_SONAME "libmariadbcpp")
 endif()
 
 # Add directories to include lists
-target_include_directories(MariaDB::ConnCpp SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
+target_include_directories(mariadb_cpp_connector SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
 
-set(MariaDB_FOUND TRUE)
+set(mariadb_found TRUE)

dCommon/CMakeLists.txt

@@ -45,11 +45,15 @@ if (UNIX)
 elseif (WIN32)
 	include(FetchContent)
 
+    set(WITH_GTEST OFF CACHE BOOL "" FORCE)
+    set(ZLIB_ENABLE_TESTS OFF CACHE BOOL "" FORCE)
+    set(ZLIB_COMPAT ON CACHE BOOL "Enable ZLIB compatibility mode" FORCE)
+
 	# TODO Keep an eye on the zlib repository for an update to disable testing.  Don't forget to update CMakePresets
 	FetchContent_Declare(
 		zlib
-		URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
+		URL https://github.com/zlib-ng/zlib-ng/archive/refs/tags/2.2.2.zip
-		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
+		URL_HASH MD5=2cf9199fb785ea579a2a9905a75c38b3
 	)
 
 	# Disable warning about no project version.
@@ -60,7 +64,6 @@ elseif (WIN32)
 	FetchContent_MakeAvailable(zlib)
 
 	set(ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
-	set_target_properties(zlib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIRS}")
 	add_library(ZLIB::ZLIB ALIAS zlib)
 else ()
 	message(

dCommon/ZCompression.cpp

@@ -9,6 +9,7 @@ namespace ZCompression {
 	}
 
 	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst) {
+        
 		z_stream zInfo = { 0 };
 		zInfo.total_in = zInfo.avail_in = nLenSrc;
 		zInfo.total_out = zInfo.avail_out = nLenDst;

dCommon/dClient/AssetManager.cpp

@@ -4,8 +4,6 @@
 #include "Game.h"
 #include "Logger.h"
 
-#include "zlib.h"
-
 AssetManager::AssetManager(const std::filesystem::path& path) {
 	if (!std::filesystem::is_directory(path)) {
 		throw std::runtime_error("Attempted to load asset bundle (" + path.string() + ") however it is not a valid directory.");
@@ -82,7 +80,7 @@ bool AssetManager::HasFile(const char* name) {
 	if (fixedName.rfind("client\\res\\", 0) != 0) fixedName = "client\\res\\" + fixedName;
 
 	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -130,7 +128,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 	}
 	int32_t packIndex = -1;
 	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {

dCommon/dEnums/dPlatforms.h

@@ -8,6 +8,8 @@
 #define DARKFLAME_PLATFORM_IOS
 #elif TARGET_OS_MAC
 #define DARKFLAME_PLATFORM_MACOS
+#pragma clang diagnostic push // prevent pragma messages being counted as a warning
+#pragma clang diagnostic ignored "-W#pragma-messages"
 #else
 #error unknown Apple operating system
 #endif

dDatabase/CMakeLists.txt

@@ -2,6 +2,12 @@ add_subdirectory(CDClientDatabase)
 add_subdirectory(GameDatabase)
 
 add_library(dDatabase STATIC "MigrationRunner.cpp")
+
+add_custom_target(conncpp_dylib
+	${CMAKE_COMMAND} -E copy $<TARGET_FILE:mariadb_cpp_connector> ${CMAKE_BINARY_DIR})
+
+add_dependencies(dDatabase conncpp_dylib)
+
 target_include_directories(dDatabase PUBLIC ".")
 target_link_libraries(dDatabase
 	PUBLIC dDatabaseCDClient dDatabaseGame)

dDatabase/GameDatabase/CMakeLists.txt

@@ -21,7 +21,7 @@ target_include_directories(dDatabaseGame PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
 )
 target_link_libraries(dDatabaseGame
-	PUBLIC MariaDB::ConnCpp
+	PUBLIC mariadb_cpp_connector
 	INTERFACE dCommon)
 
 # Glob together all headers that need to be precompiled

dDatabase/GameDatabase/Database.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <conncpp.hpp>
 
 #include "GameDatabase.h"
 

dDatabase/GameDatabase/ITables/ILeaderboard.h

@@ -3,12 +3,45 @@
 
 #include <cstdint>
 #include <optional>
+#include <string>
+#include <vector>
 
 class ILeaderboard {
 public:
 
+	struct Entry {
+		uint32_t charId{};
+		uint32_t lastPlayedTimestamp{};
+		float primaryScore{};
+		float secondaryScore{};
+		uint32_t tertiaryScore{};
+		uint32_t numWins{};
+		uint32_t numTimesPlayed{};
+		uint32_t ranking{};
+		std::string name{};
+	};
+
+	struct Score {
+		auto operator<=>(const Score& rhs) const = default;
+
+		float primaryScore{ 0.0f };
+		float secondaryScore{ 0.0f };
+		float tertiaryScore{ 0.0f };
+	};
+
 	// Get the donation total for the given activity id.
 	virtual std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) = 0;
+
+	virtual std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) = 0;
+	virtual std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) = 0;
+	virtual std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) = 0;
+	virtual std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) = 0;
+	virtual std::optional<Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) = 0;
+
+	virtual void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
+	virtual void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
+	virtual void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) = 0;
+	virtual void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) = 0;
 };
 
 #endif  //!__ILEADERBOARD__H__

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -114,6 +114,15 @@ public:
 	void RemoveBehavior(const int32_t characterId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override;
+	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override;
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 private:

dDatabase/GameDatabase/MySQL/Tables/Leaderboard.cpp

@@ -1,5 +1,9 @@
 #include "MySQLDatabase.h"
 
+#include "Game.h"
+#include "Logger.h"
+#include "dConfig.h"
+
 std::optional<uint32_t> MySQLDatabase::GetDonationTotal(const uint32_t activityId) {
 	auto donation_total = ExecuteSelect("SELECT SUM(primaryScore) as donation_total FROM leaderboard WHERE game_id = ?;", activityId);
 
@@ -9,3 +13,79 @@ std::optional<uint32_t> MySQLDatabase::GetDonationTotal(const uint32_t activityI
 
 	return donation_total->getUInt("donation_total");
 }
+
+std::vector<ILeaderboard::Entry> ProcessQuery(UniqueResultSet& rows) {
+	std::vector<ILeaderboard::Entry> entries;
+	entries.reserve(rows->rowsCount());
+
+	while (rows->next()) {
+		auto& entry = entries.emplace_back();
+
+		entry.charId = rows->getUInt("character_id");
+		entry.lastPlayedTimestamp = rows->getUInt("lp_unix");
+		entry.primaryScore = rows->getFloat("primaryScore");
+		entry.secondaryScore = rows->getFloat("secondaryScore");
+		entry.tertiaryScore = rows->getFloat("tertiaryScore");
+		entry.numWins = rows->getUInt("numWins");
+		entry.numTimesPlayed = rows->getUInt("timesPlayed");
+		entry.name = rows->getString("char_name");
+		// entry.ranking is never set because its calculated in leaderboard in code.
+	}
+
+	return entries;
+}
+
+std::vector<ILeaderboard::Entry> MySQLDatabase::GetDescendingLeaderboard(const uint32_t activityId) {
+	auto leaderboard = ExecuteSelect("SELECT *, UNIX_TIMESTAMP(last_played) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(leaderboard);
+}
+
+std::vector<ILeaderboard::Entry> MySQLDatabase::GetAscendingLeaderboard(const uint32_t activityId) {
+	auto leaderboard = ExecuteSelect("SELECT *, UNIX_TIMESTAMP(last_played) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore ASC, secondaryscore ASC, tertiaryScore ASC, last_played ASC;", activityId);
+	return ProcessQuery(leaderboard);
+}
+
+std::vector<ILeaderboard::Entry> MySQLDatabase::GetAgsLeaderboard(const uint32_t activityId) {
+	auto query = Game::config->GetValue("classic_survival_scoring") != "1" ? 
+	"SELECT *, UNIX_TIMESTAMP(last_played) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;" : 
+	"SELECT *, UNIX_TIMESTAMP(last_played) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY secondaryscore DESC, primaryscore DESC, tertiaryScore DESC, last_played ASC;";
+	auto leaderboard = ExecuteSelect(query, activityId);
+	return ProcessQuery(leaderboard);
+}
+
+std::vector<ILeaderboard::Entry> MySQLDatabase::GetNsLeaderboard(const uint32_t activityId) {
+	auto leaderboard = ExecuteSelect("SELECT *, UNIX_TIMESTAMP(last_played) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore ASC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(leaderboard);
+}
+
+void MySQLDatabase::SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("INSERT leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, character_id = ?, game_id = ?;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+void MySQLDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("UPDATE leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+void MySQLDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}
+
+std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
+	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
+	auto res = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+	if (res->next()) {
+		toReturn = ILeaderboard::Score{
+			.primaryScore = res->getFloat("primaryScore"),
+			.secondaryScore = res->getFloat("secondaryScore"),
+			.tertiaryScore = res->getFloat("tertiaryScore")
+		};
+	}
+
+	return toReturn;
+}
+
+void MySQLDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET numWins = numWins + 1 WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -91,6 +91,15 @@ class TestSQLDatabase : public GameDatabase {
 	void RemoveBehavior(const int32_t behaviorId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override { return {}; };
+	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override { return {}; };
+	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override { return {}; };
+	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override { return {}; };
+	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override { return {}; };
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override {};
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override {};
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override { return {}; };
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override {};
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override {};
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
 };

dGame/Entity.cpp

@@ -83,6 +83,7 @@
 #include "ItemComponent.h"
 #include "GhostComponent.h"
 #include "AchievementVendorComponent.h"
+#include "VanityUtilities.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -1271,6 +1272,7 @@ void Entity::Update(const float deltaTime) {
 			auto timerName = timer.GetName();
 			m_Timers.erase(m_Timers.begin() + timerPosition);
 			GetScript()->OnTimerDone(this, timerName);
+			VanityUtilities::OnTimerDone(this, timerName);
 
 			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
 		} else {
@@ -1334,6 +1336,7 @@ void Entity::OnCollisionProximity(LWOOBJID otherEntity, const std::string& proxN
 	if (!other) return;
 
 	GetScript()->OnProximityUpdate(this, other, proxName, status);
+	VanityUtilities::OnProximityUpdate(this, other, proxName, status);
 
 	RocketLaunchpadControlComponent* rocketComp = GetComponent<RocketLaunchpadControlComponent>();
 	if (!rocketComp) return;
@@ -1351,6 +1354,11 @@ void Entity::OnCollisionPhantom(const LWOOBJID otherEntity) {
 		callback(other);
 	}
 
+	SwitchComponent* switchComp = GetComponent<SwitchComponent>();
+	if (switchComp) {
+		switchComp->OnUse(other);
+	}
+
 	TriggerEvent(eTriggerEventType::ENTER, other);
 
 	// POI system

dGame/LeaderboardManager.cpp

@@ -1,5 +1,6 @@
 #include "LeaderboardManager.h"
 
+#include <ranges>
 #include <sstream>
 #include <utility>
 
@@ -72,197 +73,191 @@ void Leaderboard::Serialize(RakNet::BitStream& bitStream) const {
 	bitStream.Write0();
 }
 
-void Leaderboard::QueryToLdf(std::unique_ptr<sql::ResultSet>& rows) {
+// Takes the resulting query from a leaderboard lookup and converts it to the LDF we need
-	Clear();
+// to send it to a client.
-	if (rows->rowsCount() == 0) return;
+void QueryToLdf(Leaderboard& leaderboard, const std::vector<ILeaderboard::Entry>& leaderboardEntries) {
+	using enum Leaderboard::Type;
+	leaderboard.Clear();
+	if (leaderboardEntries.empty()) return;
 
-	this->entries.reserve(rows->rowsCount());
+	for (const auto& leaderboardEntry : leaderboardEntries) {
-	while (rows->next()) {
 		constexpr int32_t MAX_NUM_DATA_PER_ROW = 9;
-		this->entries.push_back(std::vector<LDFBaseData*>());
+		auto& entry = leaderboard.PushBackEntry();
-		auto& entry = this->entries.back();
 		entry.reserve(MAX_NUM_DATA_PER_ROW);
-		entry.push_back(new LDFData<uint64_t>(u"CharacterID", rows->getInt("character_id")));
+		entry.push_back(new LDFData<uint64_t>(u"CharacterID", leaderboardEntry.charId));
-		entry.push_back(new LDFData<uint64_t>(u"LastPlayed", rows->getUInt64("lastPlayed")));
+		entry.push_back(new LDFData<uint64_t>(u"LastPlayed", leaderboardEntry.lastPlayedTimestamp));
-		entry.push_back(new LDFData<int32_t>(u"NumPlayed", rows->getInt("timesPlayed")));
+		entry.push_back(new LDFData<int32_t>(u"NumPlayed", leaderboardEntry.numTimesPlayed));
-		entry.push_back(new LDFData<std::u16string>(u"name", GeneralUtils::ASCIIToUTF16(rows->getString("name").c_str())));
+		entry.push_back(new LDFData<std::u16string>(u"name", GeneralUtils::ASCIIToUTF16(leaderboardEntry.name)));
-		entry.push_back(new LDFData<uint64_t>(u"RowNumber", rows->getInt("ranking")));
+		entry.push_back(new LDFData<uint64_t>(u"RowNumber", leaderboardEntry.ranking));
-		switch (leaderboardType) {
+		switch (leaderboard.GetLeaderboardType()) {
-		case Type::ShootingGallery:
+		case ShootingGallery:
-			entry.push_back(new LDFData<int32_t>(u"Score", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Score", leaderboardEntry.primaryScore));
 			// Score:1
-			entry.push_back(new LDFData<int32_t>(u"Streak", rows->getInt("secondaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Streak", leaderboardEntry.secondaryScore));
 			// Streak:1
-			entry.push_back(new LDFData<float>(u"HitPercentage", (rows->getInt("tertiaryScore") / 100.0f)));
+			entry.push_back(new LDFData<float>(u"HitPercentage", (leaderboardEntry.tertiaryScore / 100.0f)));
 			// HitPercentage:3 between 0 and 1
 			break;
-		case Type::Racing:
+		case Racing:
-			entry.push_back(new LDFData<float>(u"BestTime", rows->getDouble("primaryScore")));
+			entry.push_back(new LDFData<float>(u"BestTime", leaderboardEntry.primaryScore));
 			// BestLapTime:3
-			entry.push_back(new LDFData<float>(u"BestLapTime", rows->getDouble("secondaryScore")));
+			entry.push_back(new LDFData<float>(u"BestLapTime", leaderboardEntry.secondaryScore));
 			// BestTime:3
 			entry.push_back(new LDFData<int32_t>(u"License", 1));
 			// License:1 - 1 if player has completed mission 637 and 0 otherwise
-			entry.push_back(new LDFData<int32_t>(u"NumWins", rows->getInt("numWins")));
+			entry.push_back(new LDFData<int32_t>(u"NumWins", leaderboardEntry.numWins));
 			// NumWins:1
 			break;
-		case Type::UnusedLeaderboard4:
+		case UnusedLeaderboard4:
-			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Points", leaderboardEntry.primaryScore));
 			// Points:1
 			break;
-		case Type::MonumentRace:
+		case MonumentRace:
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.primaryScore));
 			// Time:1(?)
 			break;
-		case Type::FootRace:
+		case FootRace:
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.primaryScore));
 			// Time:1
 			break;
-		case Type::Survival:
+		case Survival:
-			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Points", leaderboardEntry.primaryScore));
 			// Points:1
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("secondaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.secondaryScore));
 			// Time:1
 			break;
-		case Type::SurvivalNS:
+		case SurvivalNS:
-			entry.push_back(new LDFData<int32_t>(u"Wave", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Wave", leaderboardEntry.primaryScore));
 			// Wave:1
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("secondaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.secondaryScore));
 			// Time:1
 			break;
-		case Type::Donations:
+		case Donations:
-			entry.push_back(new LDFData<int32_t>(u"Score", rows->getInt("primaryScore")));
+			entry.push_back(new LDFData<int32_t>(u"Score", leaderboardEntry.primaryScore));
 			// Score:1
 			break;
-		case Type::None:
+		case None:
-			// This type is included here simply to resolve a compiler warning on mac about unused enum types
+			[[fallthrough]];
-			break;
 		default:
 			break;
 		}
 	}
 }
 
-const std::string_view Leaderboard::GetOrdering(Leaderboard::Type leaderboardType) {
+std::vector<ILeaderboard::Entry> FilterTo10(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer, const Leaderboard::InfoType infoType) {
-	// Use a switch case and return desc for all 3 columns if higher is better and asc if lower is better
+	std::vector<ILeaderboard::Entry> toReturn;
-	switch (leaderboardType) {
+
-	case Type::Racing:
+	int32_t index = 0;
-	case Type::MonumentRace:
+	// for friends and top, we dont need to find this players index.
-		return "primaryScore ASC, secondaryScore ASC, tertiaryScore ASC";
+	if (infoType == Leaderboard::InfoType::MyStanding || infoType == Leaderboard::InfoType::Friends) {
-	case Type::Survival:
+		for (; index < leaderboard.size(); index++) {
-		return Game::config->GetValue("classic_survival_scoring") == "1" ?
+			if (leaderboard[index].charId == relatedPlayer) break;
-			"secondaryScore DESC, primaryScore DESC, tertiaryScore DESC" :
+		}
-			"primaryScore DESC, secondaryScore DESC, tertiaryScore DESC";
-	case Type::SurvivalNS:
-		return "primaryScore DESC, secondaryScore ASC, tertiaryScore DESC";
-	case Type::ShootingGallery:
-	case Type::FootRace:
-	case Type::UnusedLeaderboard4:
-	case Type::Donations:
-	case Type::None:
-	default:
-		return "primaryScore DESC, secondaryScore DESC, tertiaryScore DESC";
 	}
+
+	if (leaderboard.size() < 10) {
+		toReturn.assign(leaderboard.begin(), leaderboard.end());
+		index = 0;
+	} else if (index < 10) {
+		toReturn.assign(leaderboard.begin(), leaderboard.begin() + 10); // get the top 10 since we are in the top 10
+		index = 0;
+	} else if (index > leaderboard.size() - 10) {
+		toReturn.assign(leaderboard.end() - 10, leaderboard.end()); // get the bottom 10 since we are in the bottom 10
+		index = leaderboard.size() - 10;
+	} else {
+		toReturn.assign(leaderboard.begin() + index - 5, leaderboard.begin() + index + 5); // get the 5 above and below
+		index -= 5;
+	}
+
+	int32_t i = index;
+	for (auto& entry : toReturn) {
+		entry.ranking = ++i;
+	}
+
+	return toReturn;
 }
 
-void Leaderboard::SetupLeaderboard(bool weekly, uint32_t resultStart, uint32_t resultEnd) {
+std::vector<ILeaderboard::Entry> FilterWeeklies(const std::vector<ILeaderboard::Entry>& leaderboard) {
-	resultStart++;
+	// Filter the leaderboard to only include entries from the last week
-	resultEnd++;
+	const auto currentTime = std::chrono::system_clock::now();
-	// We need everything except 1 column so i'm selecting * from leaderboard
+	auto epochTime = currentTime.time_since_epoch().count();
-	const std::string queryBase =
+	constexpr auto SECONDS_IN_A_WEEK = 60 * 60 * 24 * 7; // if you think im taking leap seconds into account thats cute.
-		R"QUERY(
-		WITH leaderboardsRanked AS (
-			SELECT leaderboard.*, charinfo.name,
-				RANK() OVER
-				(
-				ORDER BY %s, UNIX_TIMESTAMP(last_played) ASC, id DESC
-			) AS ranking
-				FROM leaderboard JOIN charinfo on charinfo.id = leaderboard.character_id
-				WHERE game_id = ? %s
-		),
-		myStanding AS (
-			SELECT
-				ranking as myRank
-			FROM leaderboardsRanked
-			WHERE id = ?
-		),
-		lowestRanking AS (
-			SELECT MAX(ranking) AS lowestRank
-				FROM leaderboardsRanked
-		)
-		SELECT leaderboardsRanked.*, character_id, UNIX_TIMESTAMP(last_played) as lastPlayed, leaderboardsRanked.name, leaderboardsRanked.ranking FROM leaderboardsRanked, myStanding, lowestRanking
-		WHERE leaderboardsRanked.ranking
-		BETWEEN
-		LEAST(GREATEST(CAST(myRank AS SIGNED) - 5, %i), CAST(lowestRanking.lowestRank AS SIGNED) - 9)
-		AND
-		LEAST(GREATEST(myRank + 5, %i), lowestRanking.lowestRank)
-		ORDER BY ranking ASC;
-	)QUERY";
 
-	std::string friendsFilter =
+	std::vector<ILeaderboard::Entry> weeklyLeaderboard;
-		R"QUERY(
+	for (const auto& entry : leaderboard) {
-		AND (
+		if (epochTime - entry.lastPlayedTimestamp < SECONDS_IN_A_WEEK) {
-			character_id IN (
+			weeklyLeaderboard.push_back(entry);
-				SELECT fr.requested_player FROM (
+		}
-					SELECT CASE
-					WHEN player_id = ? THEN friend_id
-					WHEN friend_id = ? THEN player_id
-					END AS requested_player
-					FROM friends
-				) AS fr
-				JOIN charinfo AS ci
-				ON ci.id = fr.requested_player
-				WHERE fr.requested_player IS NOT NULL
-			)
-		OR character_id = ?
-		)
-	)QUERY";
-
-	std::string weeklyFilter = " AND UNIX_TIMESTAMP(last_played) BETWEEN UNIX_TIMESTAMP(date_sub(now(),INTERVAL 1 WEEK)) AND UNIX_TIMESTAMP(now()) ";
-
-	std::string filter;
-	// Setup our filter based on the query type
-	if (this->infoType == InfoType::Friends) filter += friendsFilter;
-	if (this->weekly) filter += weeklyFilter;
-	const auto orderBase = GetOrdering(this->leaderboardType);
-
-	// For top query, we want to just rank all scores, but for all others we need the scores around a specific player
-	std::string baseLookup;
-	if (this->infoType == InfoType::Top) {
-		baseLookup = "SELECT id, last_played FROM leaderboard WHERE game_id = ? " + (this->weekly ? weeklyFilter : std::string("")) + " ORDER BY ";
-		baseLookup += orderBase.data();
-	} else {
-		baseLookup = "SELECT id, last_played FROM leaderboard WHERE game_id = ? " + (this->weekly ? weeklyFilter : std::string("")) + " AND character_id = ";
-		baseLookup += std::to_string(static_cast<uint32_t>(this->relatedPlayer));
 	}
-	baseLookup += " LIMIT 1";
-	LOG_DEBUG("query is %s", baseLookup.c_str());
-	std::unique_ptr<sql::PreparedStatement> baseQuery(Database::Get()->CreatePreppedStmt(baseLookup));
-	baseQuery->setInt(1, this->gameID);
-	std::unique_ptr<sql::ResultSet> baseResult(baseQuery->executeQuery());
 
-	if (!baseResult->next()) return; // In this case, there are no entries in the leaderboard for this game.
+	return weeklyLeaderboard;
+}
 
-	uint32_t relatedPlayerLeaderboardId = baseResult->getInt("id");
+std::vector<ILeaderboard::Entry> FilterFriends(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer) {
-
+	// Filter the leaderboard to only include friends of the player
-	// Create and execute the actual save here. Using a heap allocated buffer to avoid stack overflow
+	auto friendOfPlayer = Database::Get()->GetFriendsList(relatedPlayer);
-	constexpr uint16_t STRING_LENGTH = 4096;
+	std::vector<ILeaderboard::Entry> friendsLeaderboard;
-	std::unique_ptr<char[]> lookupBuffer = std::make_unique<char[]>(STRING_LENGTH);
+	for (const auto& entry : leaderboard) {
-	int32_t res = snprintf(lookupBuffer.get(), STRING_LENGTH, queryBase.c_str(), orderBase.data(), filter.c_str(), resultStart, resultEnd);
+		const auto res = std::ranges::find_if(friendOfPlayer, [&entry, relatedPlayer](const FriendData& data) {
-	DluAssert(res != -1);
+			return entry.charId == data.friendID || entry.charId == relatedPlayer;
-	std::unique_ptr<sql::PreparedStatement> query(Database::Get()->CreatePreppedStmt(lookupBuffer.get()));
+			});
-	LOG_DEBUG("Query is %s vars are %i %i %i", lookupBuffer.get(), this->gameID, this->relatedPlayer, relatedPlayerLeaderboardId);
+		if (res != friendOfPlayer.cend()) {
-	query->setInt(1, this->gameID);
+			friendsLeaderboard.push_back(entry);
-	if (this->infoType == InfoType::Friends) {
+		}
-		query->setInt(2, this->relatedPlayer);
-		query->setInt(3, this->relatedPlayer);
-		query->setInt(4, this->relatedPlayer);
-		query->setInt(5, relatedPlayerLeaderboardId);
-	} else {
-		query->setInt(2, relatedPlayerLeaderboardId);
 	}
-	std::unique_ptr<sql::ResultSet> result(query->executeQuery());
+
-	QueryToLdf(result);
+	return friendsLeaderboard;
+}
+
+std::vector<ILeaderboard::Entry> ProcessLeaderboard(
+	const std::vector<ILeaderboard::Entry>& leaderboard,
+	const bool weekly,
+	const Leaderboard::InfoType infoType,
+	const uint32_t relatedPlayer) {
+	std::vector<ILeaderboard::Entry> toReturn;
+
+	if (infoType == Leaderboard::InfoType::Friends) {
+		const auto friendsLeaderboard = FilterFriends(leaderboard, relatedPlayer);
+		toReturn = FilterTo10(weekly ? FilterWeeklies(friendsLeaderboard) : friendsLeaderboard, relatedPlayer, infoType);
+	} else {
+		toReturn = FilterTo10(weekly ? FilterWeeklies(leaderboard) : leaderboard, relatedPlayer, infoType);
+	}
+
+	return toReturn;
+}
+
+void Leaderboard::SetupLeaderboard(bool weekly) {
+	const auto leaderboardType = LeaderboardManager::GetLeaderboardType(gameID);
+	std::vector<ILeaderboard::Entry> leaderboardRes;
+
+	switch (leaderboardType) {
+	case Type::SurvivalNS:
+		leaderboardRes = Database::Get()->GetNsLeaderboard(gameID);
+		break;
+	case Type::Survival:
+		leaderboardRes = Database::Get()->GetAgsLeaderboard(gameID);
+		break;
+	case Type::Racing:
+		[[fallthrough]];
+	case Type::MonumentRace:
+		leaderboardRes = Database::Get()->GetAscendingLeaderboard(gameID);
+		break;
+	case Type::ShootingGallery:
+		[[fallthrough]];
+	case Type::FootRace:
+		[[fallthrough]];
+	case Type::Donations:
+		[[fallthrough]];
+	case Type::None:
+		[[fallthrough]];
+	default:
+		leaderboardRes = Database::Get()->GetDescendingLeaderboard(gameID);
+		break;
+	}
+
+	const auto processedLeaderboard = ProcessLeaderboard(leaderboardRes, weekly, infoType, relatedPlayer);
+
+	QueryToLdf(*this, processedLeaderboard);
 }
 
 void Leaderboard::Send(const LWOOBJID targetID) const {
@@ -272,129 +267,43 @@ void Leaderboard::Send(const LWOOBJID targetID) const {
 	}
 }
 
-std::string FormatInsert(const Leaderboard::Type& type, const Score& score, const bool useUpdate) {
-	std::string insertStatement;
-	if (useUpdate) {
-		insertStatement =
-			R"QUERY(
-			UPDATE leaderboard
-			SET primaryScore = %f, secondaryScore = %f, tertiaryScore = %f,
-			timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;
-			)QUERY";
-	} else {
-		insertStatement =
-			R"QUERY(
-			INSERT leaderboard SET
-			primaryScore = %f, secondaryScore = %f, tertiaryScore = %f,
-			character_id = ?, game_id = ?;
-			)QUERY";
-	}
-
-	constexpr uint16_t STRING_LENGTH = 400;
-	// Then fill in our score
-	char finishedQuery[STRING_LENGTH];
-	int32_t res = snprintf(finishedQuery, STRING_LENGTH, insertStatement.c_str(), score.GetPrimaryScore(), score.GetSecondaryScore(), score.GetTertiaryScore());
-	DluAssert(res != -1);
-	return finishedQuery;
-}
-
 void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore, const float tertiaryScore) {
 	const Leaderboard::Type leaderboardType = GetLeaderboardType(activityId);
 
-	std::unique_ptr<sql::PreparedStatement> query(Database::Get()->CreatePreppedStmt("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;"));
+	const auto oldScore = Database::Get()->GetPlayerScore(playerID, activityId);
-	query->setInt(1, playerID);
-	query->setInt(2, activityId);
-	std::unique_ptr<sql::ResultSet> myScoreResult(query->executeQuery());
 
-	std::string saveQuery("UPDATE leaderboard SET timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;");
+	ILeaderboard::Score newScore{ .primaryScore = primaryScore, .secondaryScore = secondaryScore, .tertiaryScore = tertiaryScore };
-	Score newScore(primaryScore, secondaryScore, tertiaryScore);
+	if (oldScore.has_value()) {
-	if (myScoreResult->next()) {
+		bool lowerScoreBetter = leaderboardType == Leaderboard::Type::Racing || leaderboardType == Leaderboard::Type::MonumentRace;
-		Score oldScore;
-		bool lowerScoreBetter = false;
-		switch (leaderboardType) {
-			// Higher score better
-		case Leaderboard::Type::ShootingGallery: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-			oldScore.SetTertiaryScore(myScoreResult->getInt("tertiaryScore"));
-			break;
-		}
-		case Leaderboard::Type::FootRace: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			break;
-		}
-		case Leaderboard::Type::Survival: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-			break;
-		}
-		case Leaderboard::Type::SurvivalNS: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-			break;
-		}
-		case Leaderboard::Type::UnusedLeaderboard4:
-		case Leaderboard::Type::Donations: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			newScore.SetPrimaryScore(oldScore.GetPrimaryScore() + newScore.GetPrimaryScore());
-			break;
-		}
-		case Leaderboard::Type::Racing: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-
-			// For wins we dont care about the score, just the time, so zero out the tertiary.
-			// Wins are updated later.
-			oldScore.SetTertiaryScore(0);
-			newScore.SetTertiaryScore(0);
-			lowerScoreBetter = true;
-			break;
-		}
-		case Leaderboard::Type::MonumentRace: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			lowerScoreBetter = true;
-			// Do score checking here
-			break;
-		}
-		case Leaderboard::Type::None:
-		default:
-			LOG("Unknown leaderboard type %i for game %i. Cannot save score!", leaderboardType, activityId);
-			return;
-		}
 		bool newHighScore = lowerScoreBetter ? newScore < oldScore : newScore > oldScore;
 		// Nimbus station has a weird leaderboard where we need a custom scoring system
 		if (leaderboardType == Leaderboard::Type::SurvivalNS) {
-			newHighScore = newScore.GetPrimaryScore() > oldScore.GetPrimaryScore() ||
+			newHighScore = newScore.primaryScore > oldScore->primaryScore ||
-				(newScore.GetPrimaryScore() == oldScore.GetPrimaryScore() && newScore.GetSecondaryScore() < oldScore.GetSecondaryScore());
+				(newScore.primaryScore == oldScore->primaryScore && newScore.secondaryScore < oldScore->secondaryScore);
 		} else if (leaderboardType == Leaderboard::Type::Survival && Game::config->GetValue("classic_survival_scoring") == "1") {
-			Score oldScoreFlipped(oldScore.GetSecondaryScore(), oldScore.GetPrimaryScore());
+			ILeaderboard::Score oldScoreFlipped{oldScore->secondaryScore, oldScore->primaryScore, oldScore->tertiaryScore};
-			Score newScoreFlipped(newScore.GetSecondaryScore(), newScore.GetPrimaryScore());
+			ILeaderboard::Score newScoreFlipped{newScore.secondaryScore, newScore.primaryScore, newScore.tertiaryScore};
 			newHighScore = newScoreFlipped > oldScoreFlipped;
 		}
+
 		if (newHighScore) {
-			saveQuery = FormatInsert(leaderboardType, newScore, true);
+			Database::Get()->UpdateScore(playerID, activityId, newScore);
+		} else {
+			Database::Get()->IncrementTimesPlayed(playerID, activityId);
 		}
 	} else {
-		saveQuery = FormatInsert(leaderboardType, newScore, false);
+		Database::Get()->SaveScore(playerID, activityId, newScore);
 	}
-	LOG("save query %s %i %i", saveQuery.c_str(), playerID, activityId);
-	std::unique_ptr<sql::PreparedStatement> saveStatement(Database::Get()->CreatePreppedStmt(saveQuery));
-	saveStatement->setInt(1, playerID);
-	saveStatement->setInt(2, activityId);
-	saveStatement->execute();
 
 	// track wins separately
 	if (leaderboardType == Leaderboard::Type::Racing && tertiaryScore != 0.0f) {
-		std::unique_ptr<sql::PreparedStatement> winUpdate(Database::Get()->CreatePreppedStmt("UPDATE leaderboard SET numWins = numWins + 1 WHERE character_id = ? AND game_id = ?;"));
+		Database::Get()->IncrementNumWins(playerID, activityId);
-		winUpdate->setInt(1, playerID);
-		winUpdate->setInt(2, activityId);
-		winUpdate->execute();
 	}
 }
 
-void LeaderboardManager::SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t resultStart, const uint32_t resultEnd) {
+void LeaderboardManager::SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID) {
 	Leaderboard leaderboard(gameID, infoType, weekly, playerID, GetLeaderboardType(gameID));
-	leaderboard.SetupLeaderboard(weekly, resultStart, resultEnd);
+	leaderboard.SetupLeaderboard(weekly);
 	leaderboard.Send(targetID);
 }
 

dGame/LeaderboardManager.h

@@ -9,46 +9,10 @@
 #include "dCommonVars.h"
 #include "LDFFormat.h"
 
-namespace sql {
-	class ResultSet;
-};
-
 namespace RakNet {
 	class BitStream;
 };
 
-class Score {
-public:
-	Score() {
-		primaryScore = 0;
-		secondaryScore = 0;
-		tertiaryScore = 0;
-	}
-	Score(const float primaryScore, const float secondaryScore = 0, const float tertiaryScore = 0) {
-		this->primaryScore = primaryScore;
-		this->secondaryScore = secondaryScore;
-		this->tertiaryScore = tertiaryScore;
-	}
-	bool operator<(const Score& rhs) const {
-		return primaryScore < rhs.primaryScore || (primaryScore == rhs.primaryScore && secondaryScore < rhs.secondaryScore) || (primaryScore == rhs.primaryScore && secondaryScore == rhs.secondaryScore && tertiaryScore < rhs.tertiaryScore);
-	}
-	bool operator>(const Score& rhs) const {
-		return primaryScore > rhs.primaryScore || (primaryScore == rhs.primaryScore && secondaryScore > rhs.secondaryScore) || (primaryScore == rhs.primaryScore && secondaryScore == rhs.secondaryScore && tertiaryScore > rhs.tertiaryScore);
-	}
-	void SetPrimaryScore(const float score) { primaryScore = score; }
-	float GetPrimaryScore() const { return primaryScore; }
-
-	void SetSecondaryScore(const float score) { secondaryScore = score; }
-	float GetSecondaryScore() const { return secondaryScore; }
-
-	void SetTertiaryScore(const float score) { tertiaryScore = score; }
-	float GetTertiaryScore() const { return tertiaryScore; }
-private:
-	float primaryScore;
-	float secondaryScore;
-	float tertiaryScore;
-};
-
 using GameID = uint32_t;
 
 class Leaderboard {
@@ -79,7 +43,7 @@ public:
 
 	/**
 	 * @brief Resets the leaderboard state and frees its allocated memory
-	 * 
+	 *
 	 */
 	void Clear();
 
@@ -96,20 +60,16 @@ public:
 	 * @param resultStart The index to start the leaderboard at. Zero indexed.
 	 * @param resultEnd The index to end the leaderboard at. Zero indexed.
 	 */
-	void SetupLeaderboard(bool weekly, uint32_t resultStart = 0, uint32_t resultEnd = 10);
+	void SetupLeaderboard(bool weekly);
 
 	/**
 	 * Sends the leaderboard to the client specified by targetID.
 	 */
 	void Send(const LWOOBJID targetID) const;
 
-	// Helper function to get the columns, ordering and insert format for a leaderboard
+	
-	static const std::string_view GetOrdering(Type leaderboardType);
-private:
-	// Takes the resulting query from a leaderboard lookup and converts it to the LDF we need
-	// to send it to a client.
-	void QueryToLdf(std::unique_ptr<sql::ResultSet>& rows);
 
+private:
 	using LeaderboardEntry = std::vector<LDFBaseData*>;
 	using LeaderboardEntries = std::vector<LeaderboardEntry>;
 
@@ -119,10 +79,18 @@ private:
 	InfoType infoType;
 	Leaderboard::Type leaderboardType;
 	bool weekly;
+public:
+	LeaderboardEntry& PushBackEntry() {
+		return entries.emplace_back();
+	}
+
+	Type GetLeaderboardType() const {
+		return leaderboardType;
+	}
 };
 
 namespace LeaderboardManager {
-	void SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t resultStart = 0, const uint32_t resultEnd = 10);
+	void SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID);
 
 	void SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore = 0, const float tertiaryScore = 0);
 

dGame/dComponents/ProximityMonitorComponent.cpp

@@ -38,7 +38,7 @@ void ProximityMonitorComponent::SetProximityRadius(dpEntity* entity, const std::
 	m_ProximitiesData.insert(std::make_pair(name, entity));
 }
 
-const std::unordered_set<LWOOBJID>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) {
+const std::unordered_set<LWOOBJID>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) const {
 	const auto iter = m_ProximitiesData.find(name);
 
 	if (iter == m_ProximitiesData.cend()) {

dGame/dComponents/ProximityMonitorComponent.h

@@ -46,7 +46,7 @@ public:
 	 * @param name the proximity name to retrieve physics objects for
 	 * @return a set of physics entity object IDs for this name
 	 */
-	const std::unordered_set<LWOOBJID>& GetProximityObjects(const std::string& name);
+	const std::unordered_set<LWOOBJID>& GetProximityObjects(const std::string& name) const;
 
 	/**
 	 * Checks if the passed object is in proximity of the named proximity sensor

dGame/dComponents/SwitchComponent.cpp

@@ -82,7 +82,6 @@ void SwitchComponent::EntityEnter(Entity* entity) {
 			RenderComponent::PlayAnimation(m_Parent, u"engaged");
 			m_PetBouncer->SetPetBouncerEnabled(true);
 		} else {
-			GameMessages::SendKnockback(entity->GetObjectID(), m_Parent->GetObjectID(), m_Parent->GetObjectID(), 0.0f, NiPoint3(0.0f, 17.0f, 0.0f));
 			Game::entityManager->SerializeEntity(m_Parent);
 		}
 

dGame/dGameMessages/GameMessages.cpp

@@ -1691,7 +1691,7 @@ void GameMessages::HandleRequestActivitySummaryLeaderboardData(RakNet::BitStream
 
 	bool weekly = inStream.ReadBit();
 
-	LeaderboardManager::SendLeaderboard(gameID, queryType, weekly, entity->GetObjectID(), entity->GetObjectID(), resultsStart, resultsEnd);
+	LeaderboardManager::SendLeaderboard(gameID, queryType, weekly, entity->GetObjectID(), entity->GetObjectID());
 }
 
 void GameMessages::HandleActivityStateChangeRequest(RakNet::BitStream& inStream, Entity* entity) {

dGame/dPropertyBehaviors/ControlBehaviorMessages/MoveToInventoryMessage.h

@@ -8,7 +8,8 @@ class AMFArrayValue;
 /**
  * @brief Sent when a player moves a Behavior A at position B to their inventory. 
  */
-#pragma warning("This Control Behavior Message does not have a test yet. Non-developers can ignore this warning.")
+#pragma message("MoveToInventory.h This Control Behavior Message does not have a test yet. Non-developers can ignore this warning.")
+
 class MoveToInventoryMessage : public BehaviorMessageBase {
 public:
 	MoveToInventoryMessage(const AMFArrayValue& arguments);

dGame/dUtilities/Preconditions.cpp

@@ -137,7 +137,7 @@ bool Precondition::CheckValue(Entity* player, const uint32_t value, bool evaluat
 
 		return inventoryComponent->GetLotCount(value) >= count;
 	case PreconditionType::DoesNotHaveItem:
-		return inventoryComponent->IsEquipped(value) < count;
+		return (inventoryComponent->IsEquipped(value) ? 1 : 0) < count;
 	case PreconditionType::HasAchievement:
 		if (missionComponent == nullptr) return false;
 		return missionComponent->GetMissionState(value) >= eMissionState::COMPLETE;

dGame/dUtilities/VanityUtilities.cpp

@@ -59,9 +59,9 @@ void VanityUtilities::SpawnVanity() {
 
 	for (const auto& npc : objects) {
 		if (npc.m_ID == LWOOBJID_EMPTY) continue;
-		if (npc.m_LOT == 176){
+		if (npc.m_LOT == 176) {
 			Game::zoneManager->RemoveSpawner(npc.m_ID);
-		} else{
+		} else {
 			auto* entity = Game::entityManager->GetEntity(npc.m_ID);
 			if (!entity) continue;
 			entity->Smash(LWOOBJID_EMPTY, eKillType::VIOLENT);
@@ -86,14 +86,14 @@ void VanityUtilities::SpawnVanity() {
 		float rate = GeneralUtils::GenerateRandomNumber<float>(0, 1);
 		if (location.m_Chance < rate) continue;
 
-		if (object.m_LOT == 176){
+		if (object.m_LOT == 176) {
 			object.m_ID = SpawnSpawner(object, location);
 		} else {
 			// Spawn the NPC
 			auto* objectEntity = SpawnObject(object, location);
 			if (!objectEntity) continue;
 			object.m_ID = objectEntity->GetObjectID();
-			if (!object.m_Phrases.empty()){
+			if (!object.m_Phrases.empty()) {
 				objectEntity->SetVar<std::vector<std::string>>(u"chats", object.m_Phrases);
 				SetupNPCTalk(objectEntity);
 			}
@@ -107,7 +107,7 @@ LWOOBJID SpawnSpawner(const VanityObject& object, const VanityObjectLocation& lo
 	// guratantee we have no collisions
 	do {
 		obj.id = ObjectIDManager::GenerateObjectID();
-	} while(Game::zoneManager->GetSpawner(obj.id));
+	} while (Game::zoneManager->GetSpawner(obj.id));
 	obj.position = location.m_Position;
 	obj.rotation = location.m_Rotation;
 	obj.settings = object.m_Config;
@@ -146,7 +146,7 @@ Entity* SpawnObject(const VanityObject& object, const VanityObjectLocation& loca
 }
 
 void ParseXml(const std::string& file) {
-	if (loadedFiles.contains(file)){
+	if (loadedFiles.contains(file)) {
 		LOG("Trying to load vanity file %s twice!!!", file.c_str());
 		return;
 	}
@@ -232,7 +232,7 @@ void ParseXml(const std::string& file) {
 			auto* configElement = object->FirstChildElement("config");
 			std::vector<std::u16string> keys = {};
 			std::vector<LDFBaseData*> config = {};
-			if(configElement) {
+			if (configElement) {
 				for (auto* key = configElement->FirstChildElement("key"); key != nullptr;
 					key = key->NextSiblingElement("key")) {
 					// Get the config data
@@ -240,7 +240,7 @@ void ParseXml(const std::string& file) {
 					if (!data) continue;
 
 					LDFBaseData* configData = LDFBaseData::DataFromString(data);
-					if (configData->GetKey() == u"useLocationsAsRandomSpawnPoint" && configData->GetValueType() == eLDFType::LDF_TYPE_BOOLEAN){
+					if (configData->GetKey() == u"useLocationsAsRandomSpawnPoint" && configData->GetValueType() == eLDFType::LDF_TYPE_BOOLEAN) {
 						useLocationsAsRandomSpawnPoint = static_cast<bool>(configData);
 						continue;
 					}
@@ -250,7 +250,7 @@ void ParseXml(const std::string& file) {
 			}
 			if (!keys.empty()) config.push_back(new LDFData<std::vector<std::u16string>>(u"syncLDF", keys));
 
-			VanityObject objectData {
+			VanityObject objectData{
 				.m_Name = name,
 				.m_LOT = lot,
 				.m_Equipment = inventory,
@@ -288,7 +288,7 @@ void ParseXml(const std::string& file) {
 					continue;
 				}
 
-				VanityObjectLocation locationData {
+				VanityObjectLocation locationData{
 					.m_Position = { x.value(), y.value(), z.value() },
 					.m_Rotation = { rw.value(), rx.value(), ry.value(), rz.value() },
 				};
@@ -403,26 +403,39 @@ void SetupNPCTalk(Entity* npc) {
 	npc->SetProximityRadius(20.0f, "talk");
 }
 
-void NPCTalk(Entity* npc) {
+void VanityUtilities::OnProximityUpdate(Entity* entity, Entity* other, const std::string& proxName, const std::string& name) {
-	auto* proximityMonitorComponent = npc->GetComponent<ProximityMonitorComponent>();
+	if (proxName != "talk") return;
+	const auto* const proximityMonitorComponent = entity->GetComponent<ProximityMonitorComponent>();
+	if (!proximityMonitorComponent) return;
 
-	if (!proximityMonitorComponent->GetProximityObjects("talk").empty()) {
+	if (name == "ENTER" && !entity->HasTimer("talk")) {
-		const auto& chats = npc->GetVar<std::vector<std::string>>(u"chats");
+		NPCTalk(entity);
-
-		if (chats.empty()) {
-			return;
-		}
-
-		const auto& selected
-			= chats[GeneralUtils::GenerateRandomNumber<int32_t>(0, static_cast<int32_t>(chats.size() - 1))];
-
-		GameMessages::SendNotifyClientZoneObject(
-			npc->GetObjectID(), u"sendToclient_bubble", 0, 0, npc->GetObjectID(), selected, UNASSIGNED_SYSTEM_ADDRESS);
 	}
+}
+
+void VanityUtilities::OnTimerDone(Entity* npc, const std::string& name) {
+	if (name == "talk") {
+		const auto* const proximityMonitorComponent = npc->GetComponent<ProximityMonitorComponent>();
+		if (!proximityMonitorComponent || proximityMonitorComponent->GetProximityObjects("talk").empty()) return;
+
+		NPCTalk(npc);
+	}
+}
+
+void NPCTalk(Entity* npc) {
+	const auto& chats = npc->GetVar<std::vector<std::string>>(u"chats");
+
+	if (chats.empty()) return;
+
+	const auto& selected
+		= chats[GeneralUtils::GenerateRandomNumber<int32_t>(0, static_cast<int32_t>(chats.size() - 1))];
+
+	GameMessages::SendNotifyClientZoneObject(
+		npc->GetObjectID(), u"sendToclient_bubble", 0, 0, npc->GetObjectID(), selected, UNASSIGNED_SYSTEM_ADDRESS);
 
 	Game::entityManager->SerializeEntity(npc);
 
 	const float nextTime = GeneralUtils::GenerateRandomNumber<float>(15, 60);
 
-	npc->AddCallbackTimer(nextTime, [npc]() { NPCTalk(npc); });
+	npc->AddTimer("talk", nextTime);
 }

dGame/dUtilities/VanityUtilities.h

@@ -31,4 +31,8 @@ namespace VanityUtilities {
 	std::string ParseMarkdown(
 		const std::string& file
 	);
+
+	void OnProximityUpdate(Entity* entity, Entity* other, const std::string& proxName, const std::string& name);
+
+	void OnTimerDone(Entity* entity, const std::string& name);
 };

dScripts/02_server/Map/AM/RandomSpawnerFin.cpp

@@ -65,13 +65,13 @@ void RandomSpawnerFin::OnStartup(Entity* self) {
 	};
 
 	sectionMultipliers = {
-		{"secA", 1},
+		{"secA", 1.0f},
-		{"secB", 1},
+		{"secB", 1.0f},
 		{"secC", 1.2f},
 		{"secD", 1.3f},
 		{"secE", 1.6f},
-		{"secF", 1},
+		{"secF", 1.0f},
-		{"secG", 1},
+		{"secG", 1.0f},
 		{"secH", 1.2f},
 	};
 

dScripts/02_server/Map/AM/RandomSpawnerPit.cpp

@@ -65,7 +65,7 @@ void RandomSpawnerPit::OnStartup(Entity* self) {
 	};
 
 	sectionMultipliers = {
-		{"secA", 1},
+		{"secA", 1.0f},
 		{"secB", 1.2f},
 		{"secC", 1.2f},
 		{"secD", 1},

dScripts/02_server/Map/AM/RandomSpawnerStr.cpp

@@ -65,8 +65,8 @@ void RandomSpawnerStr::OnStartup(Entity* self) {
 	};
 
 	sectionMultipliers = {
-		{"secA", 1},
+		{"secA", 1.0f},
-		{"secB", 1},
+		{"secB", 1.0f},
 		{"secC", 1.2f},
 	};
 

dScripts/ActivityManager.cpp

@@ -121,7 +121,7 @@ void ActivityManager::GetLeaderboardData(Entity* self, const LWOOBJID playerID,
 	auto* sac = self->GetComponent<ScriptedActivityComponent>();
 	uint32_t gameID = sac != nullptr ? sac->GetActivityID() : self->GetLOT();
 	// Save the new score to the leaderboard and show the leaderboard to the player
-	LeaderboardManager::SendLeaderboard(activityID, Leaderboard::InfoType::MyStanding, false, playerID, self->GetObjectID(), 0, numResults);
+	LeaderboardManager::SendLeaderboard(activityID, Leaderboard::InfoType::MyStanding, false, playerID, self->GetObjectID());
 }
 
 void ActivityManager::ActivityTimerStart(Entity* self, const std::string& timerName, const float_t updateInterval,

tests/CMakeLists.txt

@@ -4,15 +4,6 @@ enable_testing()
 find_package(GoogleTest REQUIRED)
 include(GoogleTest)
 
-if(APPLE)
-	set(CMAKE_INSTALL_RPATH_USE_LINK_PATH True)
-	set(CMAKE_BUILD_WITH_INSTALL_RPATH True)
-	set(CMAKE_INSTALL_RPATH "@executable_path")
-endif()
-
-add_custom_target(conncpp_tests
-	${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-
 # Add the subdirectories
 add_subdirectory(dCommonTests)
 add_subdirectory(dGameTests)

tests/dCommonTests/CMakeLists.txt

@@ -17,18 +17,13 @@ list(APPEND DCOMMONTEST_SOURCES ${DENUMS_TESTS})
 
 # Set our executable
 add_executable(dCommonTests ${DCOMMONTEST_SOURCES})
-add_dependencies(dCommonTests conncpp_tests)
 
-# Apple needs some special linkage for the mariadb connector for tests.
+# Needs to be in binary dir for ctest 
 if(APPLE)
-add_custom_command(TARGET dCommonTests POST_BUILD
+	add_custom_target(dCommonTestsLink
-	COMMAND otool ARGS -l dCommonTests
+		${CMAKE_COMMAND} -E copy $<TARGET_FILE:mariadb_cpp_connector> ${CMAKE_CURRENT_BINARY_DIR})
-	COMMAND otool ARGS -L dCommonTests
+
-	COMMAND ls
+	add_dependencies(dCommonTests dCommonTestsLink)
-	COMMAND otool ARGS -D libmariadbcpp.dylib
-	COMMAND install_name_tool ARGS -change libmariadbcpp.dylib @rpath/libmariadbcpp.dylib dCommonTests
-	COMMAND otool ARGS -L dCommonTests
-	WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 endif()
 
 # Link needed libraries

tests/dGameTests/CMakeLists.txt

@@ -13,14 +13,12 @@ file(COPY ${COMPONENT_TEST_DATA} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
 # Add the executable.  Remember to add all tests above this!
 add_executable(dGameTests ${DGAMETEST_SOURCES})
-add_dependencies(dGameTests conncpp_tests)
 
-# Apple needs some special linkage for the mariadb connector for tests.
 if(APPLE)
-add_custom_command(TARGET dGameTests POST_BUILD
+	add_custom_target(dGameTestsLink
-	COMMAND install_name_tool ARGS -change libmariadbcpp.dylib @rpath/libmariadbcpp.dylib dGameTests
+		${CMAKE_COMMAND} -E copy $<TARGET_FILE:mariadb_cpp_connector> ${CMAKE_CURRENT_BINARY_DIR})
-	COMMAND otool ARGS -L dGameTests
+
-	WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+	add_dependencies(dGameTests dGameTestsLink)
 endif()
 
 target_link_libraries(dGameTests ${COMMON_LIBRARIES} GTest::gtest_main