Merge branch 'main' into object-debugger-stuff

Tested that the client reflects the correct server progression after a test map and manually setting a flag off.
tested that session flags correctly pick up on progression updates

.github/copilot-instructions.md

@@ -1,29 +0,0 @@
-# GitHub Copilot Instructions
-
- * c++20 standard, please use the latest features except NO modules.
-   * use `.contains` for searching in associative containers
- * use const as much as possible.  If it can be const, it should be made const
- * DO NOT USE const_cast EVER.
- * use `cstdint` bitwidth types ALWAYS for integral types.
- * NEVER use std::wstring. If wide strings are necessary, use std::u16string with conversion utilties in GeneralUtils.h.
- * Functions are ALWAYS PascalCase.
- * local variables are camelCase
- * NEVER use snake case
- * indentation is TABS, not SPACES.
- * TABS are 4 spaces by default
- * Use trailing braces ALWAYS
- * global variables are prefixed with `g_`
- * if global variables or functions are needed, they should be located in an anonymous namespace
- * Use `GeneralUtils::TryParse` for ANY parsing of strings to integrals.
- * Use brace initialization when possible.
- * ALWAYS default initialize variables.
- * Pointers should be avoided unless necessary. Use references when the pointer has been checked and should not be null
- * headers should be as compact as possible. Do NOT include extra data that isnt needed.
- * Remember to include logs (LOG macro uses printf style logging) while putting verbose logs under LOG_DEBUG.
- * NEVER USE `RakNet::BitStream::ReadBit`
- * NEVER assume pointers are good, always check if they are null. Once a pointer is checked and is known to be non-null, further accesses no longer need checking
- * Be wary of TOCTOU. Prevent all possible issues relating to TOCTOU.
- * new memory allocations should never be used unless absolutely necessary.
-    * new for reconstruction of objects is allowed
- * Prefer following the format of the file over correct formatting.  Consistency over correctness.
- * When using auto, ALWAYS put a * for pointers.

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

@@ -1,14 +1,14 @@
-name: Docker
+name: CI
 
 on:
   push:
     branches:
-      - main
+      - "main"
     tags:
       - "v*.*.*"
   pull_request:
     branches:
-      - main
+      - "main"
 
 env:
   REGISTRY: ghcr.io
@@ -20,21 +20,15 @@ jobs:
     permissions:
       contents: read
       packages: write
-      attestations: write
-      id-token: write
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
-
       - name: Log in to the Container registry
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
@@ -42,32 +36,21 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@80c7e94dd9b9319bd5eb7a0e0fe9291e23a2a2e9 # v6.1.0
+        uses: docker/metadata-action@v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          # generate Docker tags based on the following events/attributes
           tags: |
             type=ref,event=pr
             type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'main') }}
-            type=raw,value=canary,enable=${{ github.ref == format('refs/heads/{0}', 'main') }}
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=semver,pattern={{major}}
 
       - name: Build and push Docker image
-        id: push
-        uses: docker/build-push-action@f9f3042f7e2789586610d6e8b85c8f03e5195baf # v7.2.0
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
-      - name: Sign Docker image
-        if: github.event_name != 'pull_request'
-        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
-        with:
-          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          subject-digest: ${{ steps.push.outputs.digest }}
-          push-to-registry: true

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

@@ -3,8 +3,6 @@ name: CI
 on:
   push:
     branches: [ main ]
-    tags:
-      - "v*.*.*"
   pull_request:
     branches: [ main ]
 
@@ -12,51 +10,38 @@ jobs:
   build-and-test:
     name: Build & Test (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ github.event_name == 'pull_request' }}
+    continue-on-error: true
     strategy:
       matrix:
-        include:
-          - os: windows-2025
-            artifact: windows
-            debug_preset: windows-msvc-relwithdebinfo
-          - os: ubuntu-24.04
-            artifact: linux
-            debug_preset: linux-gnu-relwithdebinfo
-          - os: macos-15-intel
-            artifact: macos
-            debug_preset: macos-relwithdebinfo
+        os: [ windows-2022, ubuntu-22.04, macos-13 ]
 
     steps:
-    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
       with:
         submodules: true
     - name: Add msbuild to PATH (Windows only)
-      if: ${{ matrix.os == 'windows-2025' }}
-      uses: microsoft/setup-msbuild@30375c66a4eea26614e0d39710365f22f8b0af57 # v3
+      if: ${{ matrix.os == 'windows-2022' }}
+      uses: microsoft/setup-msbuild@767f00a3f09872d96a0cb9fcd5e6a4ff33311330
       with:
-        vs-version: '[18,19)'
+        vs-version: '[17,18)'
         msbuild-architecture: x64
-    - name: Get CMake
-      uses: lukka/get-cmake@591817e96fcad43505fb4eae36172462abb3a42e # v4.3.3
-      with:
-        cmakeVersion: "latest"
-    - name: cmake
-      uses: lukka/run-cmake@5d55ea7949e25f69f0ecb516d8d572297e03a956 # v10.9
-      with:
-        workflowPreset: "${{ matrix.debug_preset }}"
-
-    - name: Extract Linux debug symbols
-      if: matrix.os == 'ubuntu-24.04'
+    - name: Install libssl and switch to XCode 15.2 (Mac Only)
+      if: ${{ matrix.os == 'macos-13' }}
       run: |
-        find build -type f -name '*Server' | while read bin; do
-          objcopy --only-keep-debug "$bin" "${bin}.debug"
-          objcopy --strip-debug --add-gnu-debuglink="${bin}.debug" "$bin"
-        done
-
-    - name: artifacts
-      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        brew install openssl@3
+        sudo xcode-select -s /Applications/Xcode_15.2.app/Contents/Developer
+    - name: Get CMake 3.x
+      uses: lukka/get-cmake@28983e0d3955dba2bb0a6810caae0c6cf268ec0c
       with:
-        name: build-${{matrix.artifact}}
+        cmakeVersion: "~3.25.0"  # <--= optional, use most recent 3.25.x version
+    - name: cmake
+      uses: lukka/run-cmake@67c73a83a46f86c4e0b96b741ac37ff495478c38
+      with:
+        workflowPreset: "ci-${{matrix.os}}"
+    - name: artifacts
+      uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
+      with:
+        name: build-${{matrix.os}}
         path: |
           build/*/*Server*
           build/*/*.ini
@@ -67,30 +52,5 @@ jobs:
           build/*/navmeshes/
           build/*/migrations/
           build/*/*.dcf
+          !build/*/*.pdb
           !build/*/d*/
-          !build/*/*.dSYM/
-          !build/**/*.debug
-
-    - name: debug symbols (Windows)
-      if: matrix.os == 'windows-2025'
-      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-      with:
-        name: debug-${{matrix.artifact}}
-        path: |
-          build/*/*.pdb
-          build/*/d*/
-        retention-days: 30
-    - name: debug symbols (Linux)
-      if: matrix.os == 'ubuntu-24.04'
-      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-      with:
-        name: debug-${{matrix.artifact}}
-        path: build/**/*.debug
-        retention-days: 30
-    - name: debug symbols (macOS)
-      if: matrix.os == 'macos-15-intel'
-      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-      with:
-        name: debug-${{matrix.artifact}}
-        path: build/**/*.dSYM/
-        retention-days: 30

.github/workflows/canary.yml

@@ -1,93 +0,0 @@
-name: Canary
-
-on:
-  workflow_run:
-    workflows: ["CI"]
-    branches: [main]
-    types: [completed]
-
-permissions:
-  contents: write
-  actions: read
-
-jobs:
-  canary-release:
-    name: Publish Canary Release
-    if: github.event.workflow_run.conclusion == 'success'
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Get last release tag
-        id: last_tag
-        run: |
-          tag=$(git describe --tags --abbrev=0 --match "v*.*.*" 2>/dev/null || echo "none")
-          echo "tag=$tag" >> "$GITHUB_OUTPUT"
-
-      - name: Generate changelog since last release tag
-        uses: orhun/git-cliff-action@f50e11560dce63f7c33227798f90b924471a88b5 # v4.8.0
-        id: cliff
-        with:
-          config: cliff.toml
-          args: --unreleased --strip header
-        env:
-          OUTPUT: CHANGES.md
-          GITHUB_REPO: ${{ github.repository }}
-
-      - name: Prepend header to changelog
-        run: |
-          last="${{ steps.last_tag.outputs.tag }}"
-          sha="${{ github.event.workflow_run.head_sha }}"
-          short="${sha:0:7}"
-          if [ "$last" != "none" ]; then
-            header="Changes since **$last** ([full diff](https://github.com/${{ github.repository }}/compare/${last}...${sha}))\n\n"
-          else
-            header="Changes up to \`${short}\`\n\n"
-          fi
-          printf "%b" "$header" | cat - CHANGES.md > CHANGES.tmp && mv CHANGES.tmp CHANGES.md
-
-      - name: Download artifacts from CI run
-        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
-        with:
-          run_id: ${{ github.event.workflow_run.id }}
-          path: artifacts/
-
-      - name: Package artifacts
-        run: |
-          declare -A platform_map=(
-            ["build-windows"]="darkflame-universe-windows"
-            ["build-linux"]="darkflame-universe-linux"
-            ["build-macos"]="darkflame-universe-macos"
-          )
-          cd artifacts
-          for dir in build-*/; do
-            name="${dir%/}"
-            out="${platform_map[$name]:-$name}"
-            zip -r "../${out}.zip" "$dir"
-          done
-          cd ..
-          ls -lh *.zip
-
-      - name: Delete existing canary release
-        run: gh release delete canary --yes --cleanup-tag 2>/dev/null || true
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create canary pre-release
-        uses: ncipollo/release-action@339a81892b84b4eeb0f6e744e4574d79d0d9b8dd # v1.21.0
-        with:
-          tag: canary
-          name: "Canary ${{ steps.last_tag.outputs.tag }}+${{ github.event.workflow_run.head_sha }}"
-          bodyFile: CHANGES.md
-          artifacts: "*.zip"
-          artifactContentType: application/zip
-          token: ${{ secrets.GITHUB_TOKEN }}
-          prerelease: true
-          draft: false
-          allowUpdates: true
-          removeArtifacts: true
-          commit: ${{ github.event.workflow_run.head_sha }}

.github/workflows/pr-title-check.yml

@@ -1,38 +0,0 @@
-name: PR Title Check
-
-on:
-  pull_request_target:
-    types: [opened, edited, synchronize, reopened]
-
-permissions:
-  pull-requests: write
-  statuses: write
-
-jobs:
-  check-title:
-    name: Conventional Commit Title
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check PR title follows Conventional Commits
-        uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          types: |
-            feat
-            fix
-            perf
-            refactor
-            docs
-            chore
-            test
-            ci
-            revert
-          requireScope: false
-          subjectPattern: ^.+$
-          subjectPatternError: |
-            The PR title "{title}" must have a description after the type/scope prefix.
-            Example: "feat: add new login flow" or "fix(auth): handle null token"
-          wip: true
-          validateSingleCommit: false

.github/workflows/release.yml

@@ -1,70 +0,0 @@
-name: Release
-
-on:
-  workflow_run:
-    workflows: ["CI"]
-    types: [completed]
-
-permissions:
-  contents: write
-  actions: read
-
-jobs:
-  release:
-    name: Create Release
-    # Only run when CI completed successfully on a tag push (not a PR branch named like a version)
-    if: |
-      github.event.workflow_run.conclusion == 'success' &&
-      github.event.workflow_run.event == 'push' &&
-      startsWith(github.event.workflow_run.head_branch, 'v')
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Generate changelog
-        uses: orhun/git-cliff-action@f50e11560dce63f7c33227798f90b924471a88b5 # v4.8.0
-        id: cliff
-        with:
-          config: cliff.toml
-          args: --latest --strip header
-        env:
-          OUTPUT: CHANGES.md
-          GITHUB_REPO: ${{ github.repository }}
-
-      - name: Download artifacts from CI run
-        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
-        with:
-          run_id: ${{ github.event.workflow_run.id }}
-          path: artifacts/
-
-      - name: Package artifacts
-        run: |
-          declare -A platform_map=(
-            ["build-windows"]="darkflame-universe-windows"
-            ["build-linux"]="darkflame-universe-linux"
-            ["build-macos"]="darkflame-universe-macos"
-          )
-          cd artifacts
-          for dir in build-*/; do
-            name="${dir%/}"
-            out="${platform_map[$name]:-$name}"
-            zip -r "../${out}.zip" "$dir"
-          done
-          cd ..
-          ls -lh *.zip
-
-      - name: Create GitHub Release
-        uses: ncipollo/release-action@339a81892b84b4eeb0f6e744e4574d79d0d9b8dd # v1.21.0
-        with:
-          tag: ${{ github.event.workflow_run.head_branch }}
-          name: ${{ github.event.workflow_run.head_branch }}
-          bodyFile: CHANGES.md
-          artifacts: "*.zip"
-          artifactContentType: application/zip
-          token: ${{ secrets.GITHUB_TOKEN }}
-          prerelease: false
-          draft: false

.gitignore

@@ -126,5 +126,3 @@ docker-compose.override.yml
 # CMake scripts
 !cmake/*
 !cmake/toolchains/*
-.mcp.json
-.claude/

CMakeLists.txt

@@ -15,7 +15,6 @@ set(CMAKE_C_STANDARD 99)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 	# Export the compile commands for debugging
 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
@@ -68,11 +67,7 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
-	if(APPLE)
-		add_link_options("-Wl,-rpath,@loader_path/")
-	else()
-		add_link_options("-Wl,-rpath,$ORIGIN/")
-	endif()
+	add_link_options("-Wl,-rpath,$ORIGIN/")
 	add_compile_options("-fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)
 

CMakePresets.json

@@ -49,7 +49,7 @@
 			"inherits": "default",
 			"displayName": "[Multi] Windows (MSVC)",
 			"description": "Set architecture to 64-bit (b/c RakNet)",
-			"generator": "Visual Studio 18 2026",
+			"generator": "Visual Studio 17 2022",
 			"binaryDir": "${sourceDir}/build/msvc",
 			"architecture": {
 				"value": "x64"
@@ -162,13 +162,6 @@
 				"rhs": "Darwin"
 			},
 			"binaryDir": "${sourceDir}/build/macos"
-		},
-		{
-			"name": "macos-relwithdebinfo",
-			"inherits": ["macos", "relwithdebinfo-config"],
-			"displayName": "[RelWithDebInfo] MacOS",
-			"description": "Create a RelWithDebInfo build for MacOS",
-			"binaryDir": "${sourceDir}/build/macos-relwithdebinfo"
 		}
 	],
 	"buildPresets": [
@@ -262,7 +255,7 @@
 		{
 			"name": "macos-relwithdebinfo",
 			"inherits": "default",
-			"configurePreset": "macos-relwithdebinfo",
+			"configurePreset": "macos",
 			"displayName": "[RelWithDebInfo] MacOS",
 			"description": "This preset is used to build in release mode with debug info on MacOS",
 			"configuration": "RelWithDebInfo"
@@ -381,7 +374,7 @@
 		{
 			"name": "macos-relwithdebinfo",
 			"inherits": "default",
-			"configurePreset": "macos-relwithdebinfo",
+			"configurePreset": "macos",
 			"displayName": "[RelWithDebInfo] MacOS",
 			"description": "Runs all tests on a MacOS configuration",
 			"configuration": "RelWithDebInfo"
@@ -610,7 +603,7 @@
 			"steps": [
 				{
 					"type": "configure",
-					"name": "macos-relwithdebinfo"
+					"name": "macos"
 				},
 				{
 					"type": "build",
@@ -623,7 +616,7 @@
 			]
 		},
 		{
-			"name": "ci-macos-15-intel",
+			"name": "ci-macos-13",
 			"displayName": "[Release] MacOS",
 			"description": "CI workflow preset for MacOS",
 			"steps": [

Dockerfile

@@ -16,9 +16,7 @@ RUN --mount=type=cache,target=/app/build,id=build-cache \
     cd /app/build && \
     cmake .. && \
     make -j$(nproc --ignore 1) && \
-    cp -r /app/build/* /tmp/persisted-build/ && \
-    mkdir -p /tmp/persisted-build/mariadbcpp && \
-    cp /app/build/thirdparty/mariadb-connector-cpp/src/mariadb_connector_cpp-build/libmariadbcpp.so /tmp/persisted-build/mariadbcpp/
+    cp -r /app/build/* /tmp/persisted-build/
 
 FROM debian:12 as runtime
 

cliff.toml

@@ -1,35 +0,0 @@
-[changelog]
-header = ""
-body = """
-{% for group, commits in commits | group_by(attribute="group") %}
-### {{ group | upper_first }}
-{% for commit in commits %}
-- {% if commit.scope %}**{{ commit.scope }}**: {% endif %}{{ commit.message }} ([{{ commit.id | truncate(length=7, end="") }}](https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}/commit/{{ commit.id }}))\
-{% if commit.github.username %} by [@{{ commit.github.username }}](https://github.com/{{ commit.github.username }}){% endif %}
-{% endfor %}
-{% endfor %}
-"""
-footer = ""
-trim = true
-
-[git]
-conventional_commits = true
-filter_unconventional = true
-split_commits = false
-commit_parsers = [
-  { message = "^feat", group = "Features" },
-  { message = "^fix", group = "Bug Fixes" },
-  { message = "^perf", group = "Performance" },
-  { message = "^refactor", group = "Refactoring" },
-  { message = "^docs", group = "Documentation" },
-  { message = "^chore", group = "Chores" },
-  { message = "^test", group = "Testing" },
-  { message = "^ci", group = "CI/CD" },
-  { message = "^revert", group = "Reverts" },
-]
-filter_commits = false
-tag_pattern = "v[0-9].*"
-skip_tags = "canary"
-ignore_tags = ""
-topo_order = false
-sort_commits = "oldest"

cmake/FindMariaDB.cmake

@@ -10,15 +10,14 @@ if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
 	file(MAKE_DIRECTORY "${MARIADB_MSI_DIR}")
 	file(MAKE_DIRECTORY "${MARIADB_CONNECTOR_DIR}")
 
-	# These values track the published Windows MSI packages used by the prebuilt path.
-	# Keep the Connector/C++ package version aligned with the checked out submodule tag when possible.
-	# Go to https://mariadb.com/downloads/connectors/ to find the up-to-date URL parts.
-	set(MARIADB_CONNECTOR_C_VERSION "3.4.8")
-	set(MARIADB_CONNECTOR_C_BUCKET "4516894")
-	set(MARIADB_CONNECTOR_C_MD5 "50f6fc0c77b8d3bacbeac0126e179861")
-	set(MARIADB_CONNECTOR_CPP_VERSION "1.1.7")
-	set(MARIADB_CONNECTOR_CPP_BUCKET "4464908")
-	set(MARIADB_CONNECTOR_CPP_MD5 "08644a7ff084b5933325cadb904796e5")
+    # These values need to be updated whenever a new minor release replaces an old one
+	# Go to https://mariadb.com/downloads/connectors/ to find the up-to-date URL parts
+    set(MARIADB_CONNECTOR_C_VERSION "3.2.7")
+	set(MARIADB_CONNECTOR_C_BUCKET "2319651")
+	set(MARIADB_CONNECTOR_C_MD5 "f8636d733f1d093af9d4f22f3239f885")
+    set(MARIADB_CONNECTOR_CPP_VERSION "1.0.2")
+	set(MARIADB_CONNECTOR_CPP_BUCKET "2531525")
+	set(MARIADB_CONNECTOR_CPP_MD5 "3034bbd6ca00a0125345f9fd1a178401")
 	
 	set(MARIADB_CONNECTOR_C_MSI "mariadb-connector-c-${MARIADB_CONNECTOR_C_VERSION}-win64.msi")
 	set(MARIADB_CONNECTOR_CPP_MSI "mariadb-connector-cpp-${MARIADB_CONNECTOR_CPP_VERSION}-win64.msi")
@@ -80,39 +79,23 @@ else() # Build from source
 			-DWITH_EXTERNAL_ZLIB=ON
 			-DOPENSSL_ROOT_DIR=${OPENSSL_ROOT_DIR}
 			-DCMAKE_C_FLAGS=-w # disable zlib warnings
-			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0\ -Wno-inconsistent-missing-override\ -include\ cstdint)
+			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0)
 	else()
 		set(MARIADB_EXTRA_CMAKE_ARGS
 			-DCMAKE_C_FLAGS=-w # disable zlib warnings
-			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0\ -include\ cstdint)
+			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0)
 	endif()
 
-	set(MARIADBCPP_BUILD_DIR "${PROJECT_BINARY_DIR}/thirdparty/mariadb-connector-cpp/src/mariadb_connector_cpp-build")
 	set(MARIADBCPP_INSTALL_DIR ${PROJECT_BINARY_DIR}/prefix)
+	set(MARIADBCPP_LIBRARY_DIR ${PROJECT_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")
-
-	if(WIN32)
-		set(MARIADBCPP_LIBRARY_DIR ${PROJECT_BINARY_DIR}/mariadbcpp)
-		set(MARIADBCPP_PLUGIN_DIR ${MARIADBCPP_LIBRARY_DIR}/plugin)
-		set(MARIADB_INSTALL_COMMAND)
-	else()
-		set(MARIADBCPP_LIBRARY_DIR ${MARIADBCPP_BUILD_DIR})
-		set(MARIADBCPP_PLUGIN_DIR ${MARIADBCPP_BUILD_DIR}/libmariadb)
-		set(MARIADB_INSTALL_COMMAND INSTALL_COMMAND ${CMAKE_COMMAND} -E true)
-	endif()
-
-	if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")
-		set(MARIADB_POLICY_VERSION_ARG -DCMAKE_POLICY_VERSION_MINIMUM=3.5)
-	endif()
-
 	ExternalProject_Add(mariadb_connector_cpp
 		PREFIX "${PROJECT_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
 		SOURCE_DIR ${MARIADBCPP_SOURCE_DIR}
-		BINARY_DIR ${MARIADBCPP_BUILD_DIR}
 		INSTALL_DIR ${MARIADBCPP_INSTALL_DIR}
 		CMAKE_ARGS  -Wno-dev
-					${MARIADB_POLICY_VERSION_ARG}
 					-DWITH_UNIT_TESTS=OFF
 					-DMARIADB_LINK_DYNAMIC=OFF
 					-DCMAKE_BUILD_RPATH_USE_ORIGIN=${CMAKE_BUILD_RPATH_USE_ORIGIN}
@@ -120,7 +103,6 @@ else() # Build from source
 					-DINSTALL_LIBDIR=${MARIADBCPP_LIBRARY_DIR}
 					-DINSTALL_PLUGINDIR=${MARIADBCPP_PLUGIN_DIR}
 					${MARIADB_EXTRA_CMAKE_ARGS}
-		${MARIADB_INSTALL_COMMAND}
 		BUILD_ALWAYS true
 	)
 

dChatServer/ChatIgnoreList.cpp

@@ -3,7 +3,6 @@
 #include "MessageType/Chat.h"
 #include "BitStreamUtils.h"
 #include "Game.h"
-#include "dConfig.h"
 #include "Logger.h"
 #include "eObjectBits.h"
 
@@ -73,8 +72,8 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 		return;
 	}
 
-	const int32_t MAX_IGNORES = Game::config->GetValue("max_ignores", 32);
-	if (receiver.ignoredPlayers.size() >= MAX_IGNORES) {
+	constexpr int32_t MAX_IGNORES = 32;
+	if (receiver.ignoredPlayers.size() > MAX_IGNORES) {
 		LOG_DEBUG("Player %llu has too many ignores", playerId);
 		return;
 	}

dChatServer/ChatPacketHandler.cpp

@@ -435,11 +435,6 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	inStream.IgnoreBytes(4);
 	inStream.Read(channel);
 	inStream.Read(size);
-	if (size > MAX_MESSAGE_LENGTH) {
-		LOG("Received a probably spoofed chat message, ignoring msg");
-		return;
-	}
-
 	inStream.IgnoreBytes(77);
 
 	LUWString message(size);
@@ -484,11 +479,6 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	if (channel != eChatChannel::PRIVATE_CHAT) LOG("WARNING: Received Private chat with the wrong channel!");
 
 	inStream.Read(size);
-	if (size > MAX_MESSAGE_LENGTH) {
-		LOG("Received a probably spoofed chat message, ignoring msg");
-		return;
-	}
-
 	inStream.IgnoreBytes(77);
 
 	inStream.Read(LUReceiverName);

dChatServer/ChatServer.cpp

@@ -202,11 +202,8 @@ int main(int argc, char** argv) {
 	//Delete our objects here:
 	Database::Destroy("ChatServer");
 	delete Game::server;
-	Game::server = nullptr;
 	delete Game::logger;
-	Game::logger = nullptr;
 	delete Game::config;
-	Game::config = nullptr;
 
 	return EXIT_SUCCESS;
 }

dChatServer/PlayerContainer.cpp

@@ -105,7 +105,15 @@ void PlayerContainer::RemovePlayer(const LWOOBJID playerID) {
 	auto* team = TeamContainer::GetTeam(playerID);
 
 	if (team != nullptr) {
-		TeamContainer::RemoveMember(team, playerID, false, false, true);
+		const auto memberName = GeneralUtils::UTF8ToUTF16(player.playerName);
+
+		for (const auto memberId : team->memberIDs) {
+			const auto& otherMember = GetPlayerData(memberId);
+
+			if (!otherMember) continue;
+
+			TeamContainer::SendTeamSetOffWorldFlag(otherMember, playerID, { 0, 0, 0 });
+		}
 	}
 
 	ChatWeb::SendWSPlayerUpdate(player, eActivityType::PlayerLoggedOut);
@@ -168,7 +176,6 @@ LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
 	return toReturn;
 }
 
-// TODO Make this a pointer again or do something to make it so you cant edit the LWOOBJID_EMPTY entry?  it should be ignored in all cases anyways though...
 PlayerData& PlayerContainer::GetPlayerDataMutable(const LWOOBJID& playerID) {
 	return m_Players.contains(playerID) ? m_Players[playerID] : m_Players[LWOOBJID_EMPTY];
 }

dChatServer/TeamContainer.cpp

@@ -477,7 +477,7 @@ TeamData* TeamContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
 		}
 	}
 
-	newTeam->lootFlag = 0;
+	newTeam->lootFlag = 1;
 
 	TeamStatusUpdate(newTeam);
 

dCommon/AMFDeserialize.cpp

@@ -3,7 +3,6 @@
 #include <stdexcept>
 
 #include "Amf3.h"
-#include "StringifiedEnum.h"
 
 /**
  * AMF3 Reference document https://rtmp.veriskope.com/pdf/amf3-file-format-spec.pdf
@@ -54,7 +53,7 @@ std::unique_ptr<AMFBaseValue> AMFDeserialize::Read(RakNet::BitStream& inStream)
 	case eAmf::VectorObject:
 		[[fallthrough]];
 	case eAmf::Dictionary:
-		throw std::invalid_argument(StringifiedEnum::ToString(marker).data());
+		throw marker;
 	default:
 		throw std::invalid_argument("Invalid AMF3 marker" + std::to_string(static_cast<int32_t>(marker)));
 	}
@@ -89,11 +88,6 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
 	// Right shift by 1 bit to get index if reference or size of next string if value
 	length = length >> 1;
 	if (isReference) {
-		constexpr int32_t maxStringSize = 1024 * 1024;
-		if (length > maxStringSize) {
-			LOG("1MB string attempted to be allocated in AMF deserialize, possible spoof, aborting deserialize.");
-			throw std::invalid_argument("1MB string attempted to be allocated in AMF deserialize, possible spoof, aborting deserialize.");
-		}
 		std::string value(length, 0);
 		inStream.Read(&value[0], length);
 		// Empty strings are never sent by reference
@@ -123,12 +117,6 @@ std::unique_ptr<AMFArrayValue> AMFDeserialize::ReadAmfArray(RakNet::BitStream& i
 		if (key.size() == 0) break;
 		arrayValue->Insert(key, Read(inStream));
 	}
-
-	constexpr int32_t maxArraySize = 10'000;
-	if (sizeOfDenseArray > maxArraySize) {
-		LOG("Someone sent 10,000 dense array entries, probably a bad packet.");
-		throw std::invalid_argument("Someone sent 10,000 dense array entries, probably a bad packet.");
-	}
 	// Finally read dense portion
 	for (uint32_t i = 0; i < sizeOfDenseArray; i++) {
 		arrayValue->Insert(i, Read(inStream));

dCommon/Amf3.h

@@ -374,21 +374,6 @@ public:
 		return value->Insert<AmfType>("value", std::make_unique<AmfType>());
 	}
 
-	AMFArrayValue& PushDebug(const NiPoint3& point) {
-		PushDebug<AMFDoubleValue>("X") = point.x;
-		PushDebug<AMFDoubleValue>("Y") = point.y;
-		PushDebug<AMFDoubleValue>("Z") = point.z;
-		return *this;
-	}
-
-	AMFArrayValue& PushDebug(const NiQuaternion& rot) {
-		PushDebug<AMFDoubleValue>("W") = rot.w;
-		PushDebug<AMFDoubleValue>("X") = rot.x;
-		PushDebug<AMFDoubleValue>("Y") = rot.y;
-		PushDebug<AMFDoubleValue>("Z") = rot.z;
-		return *this;
-	}
-
 private:
 	/**
 	 * The associative portion.  These values are key'd with strings to an AMFValue.

dCommon/BrickByBrickFix.cpp

@@ -52,7 +52,8 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 
 				if (actualUncompressedSize != -1) {
 					uint32_t previousSize = completeUncompressedModel.size();
-					completeUncompressedModel.append(reinterpret_cast<char*>(uncompressedChunk.get()), actualUncompressedSize);
+					completeUncompressedModel.append(reinterpret_cast<char*>(uncompressedChunk.get()));
+					completeUncompressedModel.resize(previousSize + actualUncompressedSize);
 				} else {
 					LOG("Failed to inflate chunk %i for model %llu.  Error: %i", chunkCount, model.id, err);
 					break;

dCommon/CMakeLists.txt

@@ -49,10 +49,11 @@ if (UNIX)
 elseif (WIN32)
 	include(FetchContent)
 
+	# 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.3.2.zip
-		URL_HASH MD5=adbba6eef8960c3412818b2e241f46dc
+		URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
+		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
 		GIT_PROGRESS TRUE
 		GIT_SHALLOW 1
 	)
@@ -61,12 +62,12 @@ elseif (WIN32)
 	set(CMAKE_POLICY_DEFAULT_CMP0048 NEW)
 	# Disable warning about the minimum version of cmake used for bcrypt being deprecated in the future
 	set(CMAKE_WARN_DEPRECATED OFF CACHE BOOL "" FORCE)
-	# Disable zlib tests
-	set(ZLIB_BUILD_TESTING OFF CACHE BOOL "" FORCE)
 
 	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(
 		FATAL_ERROR

dCommon/GeneralUtils.cpp

@@ -308,9 +308,8 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 	for (const auto& t : std::filesystem::directory_iterator(folder)) {
 		if (t.is_directory() || t.is_symlink()) continue;
 		auto filename = t.path().filename().string();
-		// Ensure the file has a name in the format of xxxxxxxx_anything_goes_here.sql
-		const auto migrationNumber = TryParse<uint32_t>(GeneralUtils::SplitString(filename, '_').at(0));
-		if (migrationNumber.has_value()) filenames.emplace(migrationNumber.value(), std::move(filename));
+		const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
+		filenames.emplace(index, std::move(filename));
 	}
 
 	// Now sort the map by the oldest migration.

dCommon/GeneralUtils.h

@@ -3,7 +3,7 @@
 // C++
 #include <charconv>
 #include <cstdint>
-#include <cmath>
+#include <cmath> 
 #include <ctime>
 #include <functional>
 #include <optional>
@@ -19,7 +19,6 @@
 #include "dPlatforms.h"
 #include "Game.h"
 #include "Logger.h"
-#include "DluAssert.h"
 
 #include <glm/ext/vector_float3.hpp>
 
@@ -205,12 +204,6 @@ namespace GeneralUtils {
 		return isParsed ? static_cast<T>(result) : std::optional<T>{};
 	}
 
-	// A version of TryParse that will return `errorVal` if `str` failed to parse.
-	template <Numeric T>
-	[[nodiscard]] T TryParse(std::string_view str, const T errorVal) {
-		return TryParse<T>(str).value_or(errorVal);
-	}
-
 	template<typename T>
 		requires(!Numeric<T>)
 	[[nodiscard]] std::optional<T> TryParse(std::string_view str);
@@ -243,12 +236,6 @@ namespace GeneralUtils {
 		return std::nullopt;
 	}
 
-	// A version of TryParse that will return `errorVal` if `str` failed to parse.
-	template <std::floating_point T>
-	[[nodiscard]] T TryParse(std::string_view str, const T errorVal) {
-		return TryParse<T>(str).value_or(errorVal);
-	}
-
 #endif
 
 	/**
@@ -270,11 +257,6 @@ namespace GeneralUtils {
 		return z ? std::make_optional<T>(x.value(), y.value(), z.value()) : std::nullopt;
 	}
 
-	// Alternative overload of TryParse with a default value
-	[[nodiscard]] inline NiPoint3 TryParse(const std::string_view strX, const std::string_view strY, const std::string_view strZ, const NiPoint3 errorVal) {
-		return TryParse<NiPoint3>(strX, strY, strZ).value_or(errorVal);
-	}
-
 	/**
 	 * The TryParse overload for handling NiPoint3 by passing a span of three strings
 	 * @param str The string vector representing the X, Y, and Z coordinates
@@ -285,11 +267,6 @@ namespace GeneralUtils {
 		return (str.size() == 3) ? TryParse<T>(str[0], str[1], str[2]) : std::nullopt;
 	}
 
-	// Alternative overload of TryParse with a default value
-	[[nodiscard]] inline NiPoint3 TryParse(const std::span<const std::string> str, const NiPoint3 errorVal) {
-		return TryParse<NiPoint3>(str).value_or(errorVal);
-	}
-
 	template <typename T>
 	std::u16string to_u16string(const T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
@@ -328,7 +305,7 @@ namespace GeneralUtils {
 	template<typename Container>
 	inline Container::value_type GetRandomElement(const Container& container) {
 		DluAssert(!container.empty());
-		return container[GenerateRandomNumber<typename Container::size_type>(0, container.size() - 1)];
+		return container[GenerateRandomNumber<typename Container::value_type>(0, container.size() - 1)];
 	}
 
 	/**

dCommon/LDFFormat.cpp

@@ -10,151 +10,163 @@
 #include <string_view>
 #include <vector>
 
+using LDFKey = std::string_view;
+using LDFTypeAndValue = std::string_view;
+
+using LDFType = std::string_view;
+using LDFValue = std::string_view;
+
 //! Returns a pointer to a LDFData value based on string format
-std::unique_ptr<LDFBaseData> LDFBaseData::DataFromString(const std::string_view& format) {
-	std::unique_ptr<LDFBaseData> toReturn;
+LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	// A valid LDF must be at least 3 characters long (=0:) is the shortest valid LDF (empty UTF-16 key with no initial value)
-	if (!format.empty() && format.length() > 2) {
-		auto equalsPosition = format.find('=');
-		// You can have an empty key, just make sure the type and value might exist
-		if (equalsPosition != std::string::npos && equalsPosition != (format.size() - 1)) {
+	if (format.empty() || format.length() <= 2) return nullptr;
+	auto equalsPosition = format.find('=');
+	// You can have an empty key, just make sure the type and value might exist
+	if (equalsPosition == std::string::npos || equalsPosition == (format.size() - 1)) return nullptr;
 
-			const std::string_view keyValue = format.substr(0, equalsPosition);
-			const std::string_view typeAndValue = format.substr(equalsPosition + 1, format.size());
+	std::pair<LDFKey, LDFTypeAndValue> keyValue;
+	keyValue.first = format.substr(0, equalsPosition);
+	keyValue.second = format.substr(equalsPosition + 1, format.size());
 
-			const auto key = GeneralUtils::ASCIIToUTF16(keyValue);
+	std::u16string key = GeneralUtils::ASCIIToUTF16(keyValue.first);
 
-			const auto colonPosition = typeAndValue.find(':');
+	auto colonPosition = keyValue.second.find(':');
 
-			// If : is the first thing after an =, then this is an invalid LDF since
-			// we dont have a type to use.
-			if (colonPosition != std::string::npos && colonPosition != 0) {
-				const std::string_view ldfType = typeAndValue.substr(0, colonPosition);
-				const std::string_view ldfValue = typeAndValue.substr(colonPosition + 1, typeAndValue.size());
+	// If : is the first thing after an =, then this is an invalid LDF since
+	// we dont have a type to use.
+	if (colonPosition == std::string::npos || colonPosition == 0) return nullptr;
 
-				// Only allow empty values for string values.
-				if (!ldfValue.empty() || (ldfType == "0" /* UTF-16 */ || ldfType == "13" /* UTF-8 */)) {
-					const eLDFType type = GeneralUtils::TryParse<eLDFType>(ldfType, LDF_TYPE_UNKNOWN);
-					switch (type) {
-					case LDF_TYPE_UTF_16: {
-						std::u16string data = GeneralUtils::UTF8ToUTF16(ldfValue);
-						toReturn.reset(new LDFData<std::u16string>(key, data));
-						break;
-					}
+	std::pair<LDFType, LDFValue> ldfTypeAndValue;
+	ldfTypeAndValue.first = keyValue.second.substr(0, colonPosition);
+	ldfTypeAndValue.second = keyValue.second.substr(colonPosition + 1, keyValue.second.size());
 
-					case LDF_TYPE_S32: {
-						const auto data = GeneralUtils::TryParse<int32_t>(ldfValue);
-						if (data) {
-							toReturn.reset(new LDFData<int32_t>(key, data.value()));
-						} else {
-							LOG("Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfValue.data(), format.data());
-						}
+	// Only allow empty values for string values.
+	if (ldfTypeAndValue.second.size() == 0 && !(ldfTypeAndValue.first == "0" || ldfTypeAndValue.first == "13")) return nullptr;
 
-						break;
-					}
-
-					case LDF_TYPE_FLOAT: {
-						const auto data = GeneralUtils::TryParse<float>(ldfValue);
-						if (data) {
-							toReturn.reset(new LDFData<float>(key, data.value()));
-						} else {
-							LOG("Warning: Attempted to process invalid float value (%s) from string (%s)", ldfValue.data(), format.data());
-						}
-						break;
-					}
-
-					case LDF_TYPE_DOUBLE: {
-						const auto data = GeneralUtils::TryParse<double>(ldfValue);
-						if (data) {
-							toReturn.reset(new LDFData<double>(key, data.value()));
-						} else {
-							LOG("Warning: Attempted to process invalid double value (%s) from string (%s)", ldfValue.data(), format.data());
-						}
-						break;
-					}
-
-					case LDF_TYPE_U32:
-					{
-						uint32_t data;
-						bool parsed = true;
-						// Have to do this really weird parsing to allow for copy ellision
-						if (ldfValue == "true") {
-							data = 1;
-						} else if (ldfValue == "false") {
-							data = 0;
-						} else {
-							const auto dataOptional = GeneralUtils::TryParse<uint32_t>(ldfValue);
-							if (!dataOptional) {
-								LOG("Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfValue.data(), format.data());
-								parsed = false;
-							} else {
-								data = dataOptional.value();
-							}
-						}
-
-						if (parsed) toReturn.reset(new LDFData<uint32_t>(key, data));
-						break;
-					}
-
-					case LDF_TYPE_BOOLEAN: {
-						bool data;
-						bool parsed = true;
-						// Have to do this really weird parsing to allow for copy ellision
-						if (ldfValue == "true") {
-							data = true;
-						} else if (ldfValue == "false") {
-							data = false;
-						} else {
-							const auto dataOptional = GeneralUtils::TryParse<bool>(ldfValue);
-							if (!dataOptional) {
-								LOG("Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfValue.data(), format.data());
-								parsed = false;
-							} else {
-								data = dataOptional.value();
-							}
-						}
-
-						if (parsed) toReturn.reset(new LDFData<bool>(key, data));
-						break;
-					}
-
-					case LDF_TYPE_U64: {
-						const auto data = GeneralUtils::TryParse<uint64_t>(ldfValue);
-						if (data) {
-							toReturn.reset(new LDFData<uint64_t>(key, data.value()));
-						} else {
-							LOG("Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfValue.data(), format.data());
-						}
-						break;
-					}
-
-					case LDF_TYPE_OBJID: {
-						const auto data = GeneralUtils::TryParse<LWOOBJID>(ldfValue);
-						if (data) {
-							toReturn.reset(new LDFData<LWOOBJID>(key, data.value()));
-						} else {
-							LOG("Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfValue.data(), format.data());
-						}
-						break;
-					}
-
-					case LDF_TYPE_UTF_8: {
-						toReturn.reset(new LDFData<std::string>(key, ldfValue.data()));
-						break;
-					}
-
-					case LDF_TYPE_UNKNOWN:
-						[[fallthrough]];
-					default: {
-						LOG("Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfValue.data(), format.data());
-						break;
-					}
-
-					}
-				}
-			}
-		}
+	eLDFType type;
+	char* storage;
+	try {
+		type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
+	} catch (std::exception) {
+		LOG("Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
+		return nullptr;
 	}
 
-	return toReturn;
+	LDFBaseData* returnValue = nullptr;
+	switch (type) {
+	case LDF_TYPE_UTF_16: {
+		std::u16string data = GeneralUtils::UTF8ToUTF16(ldfTypeAndValue.second);
+		returnValue = new LDFData<std::u16string>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_S32: {
+		const auto data = GeneralUtils::TryParse<int32_t>(ldfTypeAndValue.second);
+		if (!data) {
+			LOG("Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		returnValue = new LDFData<int32_t>(key, data.value());
+
+		break;
+	}
+
+	case LDF_TYPE_FLOAT: {
+		const auto data = GeneralUtils::TryParse<float>(ldfTypeAndValue.second);
+		if (!data) {
+			LOG("Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		returnValue = new LDFData<float>(key, data.value());
+		break;
+	}
+
+	case LDF_TYPE_DOUBLE: {
+		const auto data = GeneralUtils::TryParse<double>(ldfTypeAndValue.second);
+		if (!data) {
+			LOG("Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		returnValue = new LDFData<double>(key, data.value());
+		break;
+	}
+
+	case LDF_TYPE_U32:
+	{
+		uint32_t data;
+
+		if (ldfTypeAndValue.second == "true") {
+			data = 1;
+		} else if (ldfTypeAndValue.second == "false") {
+			data = 0;
+		} else {
+			const auto dataOptional = GeneralUtils::TryParse<uint32_t>(ldfTypeAndValue.second);
+			if (!dataOptional) {
+				LOG("Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+				return nullptr;
+			}
+			data = dataOptional.value();
+		}
+
+		returnValue = new LDFData<uint32_t>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_BOOLEAN: {
+		bool data;
+
+		if (ldfTypeAndValue.second == "true") {
+			data = true;
+		} else if (ldfTypeAndValue.second == "false") {
+			data = false;
+		} else {
+			const auto dataOptional = GeneralUtils::TryParse<bool>(ldfTypeAndValue.second);
+			if (!dataOptional) {
+				LOG("Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+				return nullptr;
+			}
+			data = dataOptional.value();
+		}
+
+		returnValue = new LDFData<bool>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_U64: {
+		const auto data = GeneralUtils::TryParse<uint64_t>(ldfTypeAndValue.second);
+		if (!data) {
+			LOG("Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		returnValue = new LDFData<uint64_t>(key, data.value());
+		break;
+	}
+
+	case LDF_TYPE_OBJID: {
+		const auto data = GeneralUtils::TryParse<LWOOBJID>(ldfTypeAndValue.second);
+		if (!data) {
+			LOG("Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		returnValue = new LDFData<LWOOBJID>(key, data.value());
+		break;
+	}
+
+	case LDF_TYPE_UTF_8: {
+		std::string data = ldfTypeAndValue.second.data();
+		returnValue = new LDFData<std::string>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_UNKNOWN: {
+		LOG("Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		break;
+	}
+
+	default: {
+		LOG("Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
+		break;
+	}
+	}
+	return returnValue;
 }

dCommon/LDFFormat.h

@@ -1,12 +1,11 @@
-#ifndef LDFFORMAT_H
-#define LDFFORMAT_H
+#ifndef __LDFFORMAT__H__
+#define __LDFFORMAT__H__
 
 // Custom Classes
 #include "dCommonVars.h"
 #include "GeneralUtils.h"
 
 // C++
-#include <map>
 #include <string>
 #include <string_view>
 #include <sstream>
@@ -47,17 +46,17 @@ public:
 
 	virtual std::string GetValueAsString() const = 0;
 
-	virtual std::unique_ptr<LDFBaseData> Copy() const = 0;
+	virtual LDFBaseData* Copy() const = 0;
 
 	/**
 	 * Given an input string, return the data as a LDF key.
 	 */
-	static std::unique_ptr<LDFBaseData> DataFromString(const std::string_view& format);
+	static LDFBaseData* DataFromString(const std::string_view& format);
 
 };
 
 template<typename T>
-class LDFData : public LDFBaseData {
+class LDFData: public LDFBaseData {
 private:
 	std::u16string key;
 	T value;
@@ -165,8 +164,8 @@ public:
 		return this->GetValueString();
 	}
 
-	std::unique_ptr<LDFBaseData> Copy() const override {
-		return std::make_unique<LDFData<T>>(key, value);
+	LDFBaseData* Copy() const override {
+		return new LDFData<T>(key, value);
 	}
 
 	inline static const T Default = {};
@@ -227,89 +226,4 @@ template<> inline std::string LDFData<LWOOBJID>::GetValueString() const { return
 
 template<> inline std::string LDFData<std::string>::GetValueString() const { return this->value; }
 
-struct LwoNameValue {
-	using LDFPtr = std::unique_ptr<LDFBaseData>;
-	using ValueType = std::map<std::u16string, LDFPtr>;
-
-	LwoNameValue& operator=(const LwoNameValue& other) {
-		this->values = other.Copy();
-		return *this;
-	}
-
-	template<typename T>
-	void Insert(const std::u16string& key, const T& value) {
-		this->values.insert_or_assign(key, std::unique_ptr(std::make_unique<LDFData<T>>(key, value)));
-	}
-
-	void Insert(const std::u16string& key, const char* value) {
-		this->Insert<std::string>(key, value);
-	}
-
-	void Insert(const std::u16string& key, const char16_t* value) {
-		this->Insert<std::u16string>(key, value);
-	}
-
-	template<typename T>
-	void Insert(const std::string& key, const T& value) {
-		this->Insert<T>(GeneralUtils::UTF8ToUTF16(key), value);
-	}
-
-	void Insert(const std::string& key, const char* value) {
-		this->Insert<std::string>(GeneralUtils::UTF8ToUTF16(key), value);
-	}
-
-	void Insert(const std::string& key, const char16_t* value) {
-		this->Insert<std::u16string>(GeneralUtils::UTF8ToUTF16(key), value);
-	}
-
-	const LDFPtr& ParseInsert(const std::string& data) {
-		LDFPtr toInsert(LDFBaseData::DataFromString(data));
-		return toInsert ?
-		this->values.insert_or_assign(toInsert->GetKey(), std::move(toInsert)).first->second :
-		this->values.insert_or_assign(u"FAILED_TO_PARSE_" + GeneralUtils::UTF8ToUTF16(data), std::make_unique<LDFData<std::string>>("", "")).first->second;
-	}
-
-	const LDFPtr& ParseInsert(const std::u16string& data) {
-		return this->ParseInsert(GeneralUtils::UTF16ToWTF8(data));
-	}
-
-	ValueType::const_iterator begin() const {
-		return this->values.cbegin();
-	}
-
-	ValueType::const_iterator end() const {
-		return this->values.cend();
-	}
-
-	void Erase(const std::u16string& key) {
-		this->values.erase(key);
-	}
-
-	void Erase(const std::string& key) {
-		this->Erase(GeneralUtils::ASCIIToUTF16(key));
-	}
-
-	ValueType::iterator find(const ValueType::key_type& key) {
-		return this->values.find(key);
-	}
-
-	ValueType::const_iterator find(const ValueType::key_type& key) const {
-		return this->values.find(key);
-	}
-
-	LwoNameValue() = default;
-
-	LwoNameValue(const LwoNameValue& other) {
-		this->values = other.Copy();
-	}
-
-	ValueType values;
-private:
-	ValueType Copy() const {
-		ValueType copy;
-		for (const auto& [key, value] : this->values) copy.insert_or_assign(key, value->Copy());
-		return copy;
-	}
-};
-
-#endif  //!LDFFORMAT_H
+#endif  //!__LDFFORMAT__H__

dCommon/Logger.cpp

@@ -96,17 +96,3 @@ bool Logger::GetLogToConsole() const {
 	}
 	return toReturn;
 }
-
-FuncEntry::FuncEntry(const char* funcName, const char* fileName, const uint32_t line) {
-	m_FuncName = funcName;
-	if (!m_FuncName) m_FuncName = "Unknown";
-	m_Line = line;
-	m_FileName = fileName;
-	LOG("--> %s::%s:%i", m_FileName, m_FuncName, m_Line);
-}
-
-FuncEntry::~FuncEntry() {
-	if (!m_FuncName || !m_FileName) return;
-
-	LOG("<-- %s::%s:%i", m_FileName, m_FuncName, m_Line);
-}

dCommon/Logger.h

@@ -32,19 +32,6 @@ constexpr const char* GetFileNameFromAbsolutePath(const char* path) {
 #define LOG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->Log(str_, message, ##__VA_ARGS__); } while(0)
 #define LOG_DEBUG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->LogDebug(str_, message, ##__VA_ARGS__); } while(0)
 
-// Place this right at the start of a function. Will log a message when called and then once you leave the function.
-#define LOG_ENTRY auto str_ = GetFileNameFromAbsolutePath(__FILE__); FuncEntry funcEntry_(__FUNCTION__, str_, __LINE__)
-
-class FuncEntry {
-public:
-	FuncEntry(const char* funcName, const char* fileName, const uint32_t line);
-	~FuncEntry();
-private:
-	const char* m_FuncName = nullptr;
-	const char* m_FileName = nullptr;
-	uint32_t m_Line = 0;
-};
-
 // Writer class for writing data to files.
 class Writer {
 public:

dCommon/Lxfml.cpp

@@ -5,43 +5,13 @@
 #include "TinyXmlUtils.h"
 
 #include <ranges>
-#include <unordered_map>
-#include <unordered_set>
-#include <functional>
-#include <sstream>
-
-namespace {
-	// The base LXFML xml file to use when creating new models.
-	std::string g_base = R"(<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<LXFML versionMajor="5" versionMinor="0">
-<Meta>
-    <Application name="LEGO Universe" versionMajor="0" versionMinor="0"/>
-    <Brand name="LEGOUniverse"/>
-    <BrickSet version="457"/>
-</Meta>
-<Bricks>
-</Bricks>
-<RigidSystems>
-</RigidSystems>
-<GroupSystems>
-    <GroupSystem>
-    </GroupSystem>
-</GroupSystems>
-</LXFML>)";
-}
 
 Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoint3& curPosition) {
 	Result toReturn;
-	
-	// Handle empty or invalid input
-	if (data.empty()) {
-		return toReturn;
-	}
-	
 	tinyxml2::XMLDocument doc;
-	// Use length-based parsing to avoid expensive string copy
-	const auto err = doc.Parse(data.data(), data.size());
+	const auto err = doc.Parse(data.data());
 	if (err != tinyxml2::XML_SUCCESS) {
+		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
 		return toReturn;
 	}
 
@@ -50,6 +20,7 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 
 	auto lxfml = reader["LXFML"];
 	if (!lxfml) {
+		LOG("Failed to find LXFML element.");
 		return toReturn;
 	}
 
@@ -78,19 +49,16 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 		// Calculate the lowest and highest points on the entire model
 		for (const auto& transformation : transformations | std::views::values) {
 			auto split = GeneralUtils::SplitString(transformation, ',');
-		if (split.size() < 12) continue;
-	
-		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
-		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
-		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
-			
-		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) continue;
-		
-		auto x = xOpt.value();
-		auto y = yOpt.value();
-		auto z = zOpt.value();
-		if (x < lowest.x) lowest.x = x;
-		if (y < lowest.y) lowest.y = y;
+			if (split.size() < 12) {
+				LOG("Not enough in the split?");
+				continue;
+			}
+
+			auto x = GeneralUtils::TryParse<float>(split[9]).value();
+			auto y = GeneralUtils::TryParse<float>(split[10]).value();
+			auto z = GeneralUtils::TryParse<float>(split[11]).value();
+			if (x < lowest.x) lowest.x = x;
+			if (y < lowest.y) lowest.y = y;
 			if (z < lowest.z) lowest.z = z;
 
 			if (highest.x < x) highest.x = x;
@@ -119,19 +87,13 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	for (auto& transformation : transformations | std::views::values) {
 		auto split = GeneralUtils::SplitString(transformation, ',');
 		if (split.size() < 12) {
+			LOG("Not enough in the split?");
 			continue;
 		}
 
-		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
-		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
-		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
-		
-		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) {
-			continue;
-		}		
-		auto x = xOpt.value() - newRootPos.x + curPosition.x;
-		auto y = yOpt.value() - newRootPos.y + curPosition.y;
-		auto z = zOpt.value() - newRootPos.z + curPosition.z;
+		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x + curPosition.x;
+		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y + curPosition.y;
+		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z + curPosition.z;
 		std::stringstream stream;
 		for (int i = 0; i < 9; i++) {
 			stream << split[i];
@@ -166,345 +128,3 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	toReturn.center = newRootPos;
 	return toReturn;
 }
-
-// Deep-clone an XMLElement (attributes, text, and child elements) into a target document
-// with maximum depth protection to prevent infinite loops
-static tinyxml2::XMLElement* CloneElementDeep(const tinyxml2::XMLElement* src, tinyxml2::XMLDocument& dstDoc, int maxDepth = 100) {
-	if (!src || maxDepth <= 0) return nullptr;
-	auto* dst = dstDoc.NewElement(src->Name());
-
-	// copy attributes
-	for (const tinyxml2::XMLAttribute* attr = src->FirstAttribute(); attr; attr = attr->Next()) {
-		dst->SetAttribute(attr->Name(), attr->Value());
-	}
-
-	// copy children (elements and text)
-	for (const tinyxml2::XMLNode* child = src->FirstChild(); child; child = child->NextSibling()) {
-		if (const tinyxml2::XMLElement* childElem = child->ToElement()) {
-			// Recursively clone child elements with decremented depth
-			auto* clonedChild = CloneElementDeep(childElem, dstDoc, maxDepth - 1);
-			if (clonedChild) dst->InsertEndChild(clonedChild);
-		} else if (const tinyxml2::XMLText* txt = child->ToText()) {
-			auto* n = dstDoc.NewText(txt->Value());
-			dst->InsertEndChild(n);
-		} else if (const tinyxml2::XMLComment* c = child->ToComment()) {
-			auto* n = dstDoc.NewComment(c->Value());
-			dst->InsertEndChild(n);
-		}
-	}
-
-	return dst;
-}
-
-std::vector<Lxfml::Result> Lxfml::Split(const std::string_view data, const NiPoint3& curPosition) {
-	std::vector<Result> results;
-	
-	// Handle empty or invalid input
-	if (data.empty()) {
-		return results;
-	}
-	
-	// Prevent processing extremely large inputs that could cause hangs
-	if (data.size() > 10000000) { // 10MB limit
-		return results;
-	}
-	
-	tinyxml2::XMLDocument doc;
-	// Use length-based parsing to avoid expensive string copy
-	const auto err = doc.Parse(data.data(), data.size());
-	if (err != tinyxml2::XML_SUCCESS) {
-		return results;
-	}
-
-	auto* lxfml = doc.FirstChildElement("LXFML");
-	if (!lxfml) {
-		return results;
-	}
-
-	// Build maps: partRef -> Part element, partRef -> Brick element, boneRef -> partRef, brickRef -> Brick element
-	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToPart;
-	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToBrick;
-	std::unordered_map<std::string, std::string> boneRefToPartRef;
-	std::unordered_map<std::string, tinyxml2::XMLElement*> brickByRef;
-
-	auto* bricksParent = lxfml->FirstChildElement("Bricks");
-	if (bricksParent) {
-		for (auto* brick = bricksParent->FirstChildElement("Brick"); brick; brick = brick->NextSiblingElement("Brick")) {
-			const char* brickRef = brick->Attribute("refID");
-			if (brickRef) brickByRef.emplace(std::string(brickRef), brick);
-			for (auto* part = brick->FirstChildElement("Part"); part; part = part->NextSiblingElement("Part")) {
-				const char* partRef = part->Attribute("refID");
-				if (partRef) {
-					partRefToPart.emplace(std::string(partRef), part);
-					partRefToBrick.emplace(std::string(partRef), brick);
-				}
-				auto* bone = part->FirstChildElement("Bone");
-				if (bone) {
-					const char* boneRef = bone->Attribute("refID");
-					if (boneRef) boneRefToPartRef.emplace(std::string(boneRef), partRef ? std::string(partRef) : std::string());
-				}
-			}
-		}
-	}
-
-	// Collect RigidSystem elements
-	std::vector<tinyxml2::XMLElement*> rigidSystems;
-	auto* rigidSystemsParent = lxfml->FirstChildElement("RigidSystems");
-	if (rigidSystemsParent) {
-		for (auto* rs = rigidSystemsParent->FirstChildElement("RigidSystem"); rs; rs = rs->NextSiblingElement("RigidSystem")) {
-			rigidSystems.push_back(rs);
-		}
-	}
-
-	// Collect top-level groups (immediate children of GroupSystem)
-	std::vector<tinyxml2::XMLElement*> groupRoots;
-	auto* groupSystemsParent = lxfml->FirstChildElement("GroupSystems");
-	if (groupSystemsParent) {
-		for (auto* gs = groupSystemsParent->FirstChildElement("GroupSystem"); gs; gs = gs->NextSiblingElement("GroupSystem")) {
-			for (auto* group = gs->FirstChildElement("Group"); group; group = group->NextSiblingElement("Group")) {
-				groupRoots.push_back(group);
-			}
-		}
-	}
-
-	// Track used bricks and rigidsystems
-	std::unordered_set<std::string> usedBrickRefs;
-	std::unordered_set<tinyxml2::XMLElement*> usedRigidSystems;
-
-	// Track used groups to avoid processing them twice
-	std::unordered_set<tinyxml2::XMLElement*> usedGroups;
-
-	// Helper to create output document from sets of brick refs and rigidsystem pointers
-	auto makeOutput = [&](const std::unordered_set<std::string>& bricksToInclude, const std::vector<tinyxml2::XMLElement*>& rigidSystemsToInclude, const std::vector<tinyxml2::XMLElement*>& groupsToInclude = {}) {
-		tinyxml2::XMLDocument outDoc;
-		outDoc.Parse(g_base.c_str());
-		auto* outRoot = outDoc.FirstChildElement("LXFML");
-		auto* outBricks = outRoot->FirstChildElement("Bricks");
-		auto* outRigidSystems = outRoot->FirstChildElement("RigidSystems");
-		auto* outGroupSystems = outRoot->FirstChildElement("GroupSystems");
-
-		// clone and insert bricks
-		for (const auto& bref : bricksToInclude) {
-			auto it = brickByRef.find(bref);
-			if (it == brickByRef.end()) continue;
-			tinyxml2::XMLElement* cloned = CloneElementDeep(it->second, outDoc);
-			if (cloned) outBricks->InsertEndChild(cloned);
-		}
-
-		// clone and insert rigidsystems
-		for (auto* rsPtr : rigidSystemsToInclude) {
-			tinyxml2::XMLElement* cloned = CloneElementDeep(rsPtr, outDoc);
-			if (cloned) outRigidSystems->InsertEndChild(cloned);
-		}
-
-		// clone and insert group(s) if requested
-		if (outGroupSystems && !groupsToInclude.empty()) {
-			// clear default children
-			while (outGroupSystems->FirstChild()) outGroupSystems->DeleteChild(outGroupSystems->FirstChild());
-			// create a GroupSystem element and append requested groups
-			auto* newGS = outDoc.NewElement("GroupSystem");
-			for (auto* gptr : groupsToInclude) {
-				tinyxml2::XMLElement* clonedG = CloneElementDeep(gptr, outDoc);
-				if (clonedG) newGS->InsertEndChild(clonedG);
-			}
-			outGroupSystems->InsertEndChild(newGS);
-		}
-
-		// Print to string
-		tinyxml2::XMLPrinter printer;
-		outDoc.Print(&printer);
-		// Normalize position and compute center using existing helper
-		std::string xmlString = printer.CStr();
-		if (xmlString.size() > 5000000) { // 5MB limit for normalization
-			Result emptyResult;
-			emptyResult.lxfml = xmlString;
-			return emptyResult;
-		}
-		auto normalized = NormalizePosition(xmlString, curPosition);
-		return normalized;
-	};
-
-	// 1) Process groups (each top-level Group becomes one output; nested groups are included)
-	for (auto* groupRoot : groupRoots) {
-		// Skip if this group was already processed as part of another group
-		if (usedGroups.find(groupRoot) != usedGroups.end()) continue;
-
-		// Helper to collect all partRefs in a group's subtree
-		std::function<void(const tinyxml2::XMLElement*, std::unordered_set<std::string>&)> collectParts = [&](const tinyxml2::XMLElement* g, std::unordered_set<std::string>& partRefs) {
-			if (!g) return;
-			const char* partAttr = g->Attribute("partRefs");
-			if (partAttr) {
-				for (auto& tok : GeneralUtils::SplitString(partAttr, ',')) partRefs.insert(tok);
-			}
-			for (auto* child = g->FirstChildElement("Group"); child; child = child->NextSiblingElement("Group")) collectParts(child, partRefs);
-		};
-
-		// Collect all groups that need to be merged into this output
-		std::vector<tinyxml2::XMLElement*> groupsToInclude{ groupRoot };
-		usedGroups.insert(groupRoot);
-
-		// Build initial sets of bricks and boneRefs from the starting group
-		std::unordered_set<std::string> partRefs;
-		collectParts(groupRoot, partRefs);
-
-		std::unordered_set<std::string> bricksIncluded;
-		std::unordered_set<std::string> boneRefsIncluded;
-		for (const auto& pref : partRefs) {
-			auto pit = partRefToBrick.find(pref);
-			if (pit != partRefToBrick.end()) {
-				const char* bref = pit->second->Attribute("refID");
-				if (bref) bricksIncluded.insert(std::string(bref));
-			}
-			auto partIt = partRefToPart.find(pref);
-			if (partIt != partRefToPart.end()) {
-				auto* bone = partIt->second->FirstChildElement("Bone");
-				if (bone) {
-					const char* bref = bone->Attribute("refID");
-					if (bref) boneRefsIncluded.insert(std::string(bref));
-				}
-			}
-		}
-
-		// Iteratively include any RigidSystems that reference any boneRefsIncluded
-		// and check if those rigid systems' bricks span other groups
-		bool changed = true;
-		std::vector<tinyxml2::XMLElement*> rigidSystemsToInclude;
-		int maxIterations = 1000; // Safety limit to prevent infinite loops
-		int iteration = 0;
-		while (changed && iteration < maxIterations) {
-			changed = false;
-			iteration++;
-
-			// First, expand rigid systems based on current boneRefsIncluded
-			for (auto* rs : rigidSystems) {
-				if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
-				// parse boneRefs of this rigid system (from its <Rigid> children)
-				bool intersects = false;
-				std::vector<std::string> rsBoneRefs;
-				for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
-					const char* battr = rigid->Attribute("boneRefs");
-					if (!battr) continue;
-					for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
-						rsBoneRefs.push_back(tok);
-						if (boneRefsIncluded.find(tok) != boneRefsIncluded.end()) intersects = true;
-					}
-				}
-				if (!intersects) continue;
-				// include this rigid system and all boneRefs it references
-				usedRigidSystems.insert(rs);
-				rigidSystemsToInclude.push_back(rs);
-				for (const auto& br : rsBoneRefs) {
-					boneRefsIncluded.insert(br);
-					auto bpIt = boneRefToPartRef.find(br);
-					if (bpIt != boneRefToPartRef.end()) {
-						auto partRef = bpIt->second;
-						auto pbIt = partRefToBrick.find(partRef);
-						if (pbIt != partRefToBrick.end()) {
-							const char* bref = pbIt->second->Attribute("refID");
-							if (bref && bricksIncluded.insert(std::string(bref)).second) changed = true;
-						}
-					}
-				}
-			}
-
-			// Second, check if the newly included bricks span any other groups
-			// If so, merge those groups into the current output
-			for (auto* otherGroup : groupRoots) {
-				if (usedGroups.find(otherGroup) != usedGroups.end()) continue;
-
-				// Collect partRefs from this other group
-				std::unordered_set<std::string> otherPartRefs;
-				collectParts(otherGroup, otherPartRefs);
-
-				// Check if any of these partRefs correspond to bricks we've already included
-				bool spansOtherGroup = false;
-				for (const auto& pref : otherPartRefs) {
-					auto pit = partRefToBrick.find(pref);
-					if (pit != partRefToBrick.end()) {
-						const char* bref = pit->second->Attribute("refID");
-						if (bref && bricksIncluded.find(std::string(bref)) != bricksIncluded.end()) {
-							spansOtherGroup = true;
-							break;
-						}
-					}
-				}
-
-				if (spansOtherGroup) {
-					// Merge this group into the current output
-					usedGroups.insert(otherGroup);
-					groupsToInclude.push_back(otherGroup);
-					changed = true;
-
-					// Add all partRefs, boneRefs, and bricks from this group
-					for (const auto& pref : otherPartRefs) {
-						auto pit = partRefToBrick.find(pref);
-						if (pit != partRefToBrick.end()) {
-							const char* bref = pit->second->Attribute("refID");
-							if (bref) bricksIncluded.insert(std::string(bref));
-						}
-						auto partIt = partRefToPart.find(pref);
-						if (partIt != partRefToPart.end()) {
-							auto* bone = partIt->second->FirstChildElement("Bone");
-							if (bone) {
-								const char* bref = bone->Attribute("refID");
-								if (bref) boneRefsIncluded.insert(std::string(bref));
-							}
-						}
-					}
-				}
-			}
-		}
-		
-		if (iteration >= maxIterations) {
-			// Iteration limit reached, stop processing to prevent infinite loops
-			// The file is likely malformed, so just skip further processing
-			return results;
-		}		
-		// include bricks from bricksIncluded into used set
-		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
-
-		// make output doc and push result (include all merged groups' XML)
-		auto normalized = makeOutput(bricksIncluded, rigidSystemsToInclude, groupsToInclude);
-		results.push_back(normalized);
-	}
-
-	// 2) Process remaining RigidSystems (each becomes its own file)
-	for (auto* rs : rigidSystems) {
-		if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
-		std::unordered_set<std::string> bricksIncluded;
-		// collect boneRefs referenced by this rigid system
-		for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
-			const char* battr = rigid->Attribute("boneRefs");
-			if (!battr) continue;
-			for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
-				auto bpIt = boneRefToPartRef.find(tok);
-				if (bpIt != boneRefToPartRef.end()) {
-					auto partRef = bpIt->second;
-					auto pbIt = partRefToBrick.find(partRef);
-					if (pbIt != partRefToBrick.end()) {
-						const char* bref = pbIt->second->Attribute("refID");
-						if (bref) bricksIncluded.insert(std::string(bref));
-					}
-				}
-			}
-		}
-		// mark used
-		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
-		usedRigidSystems.insert(rs);
-
-		std::vector<tinyxml2::XMLElement*> rsVec{ rs };
-		auto normalized = makeOutput(bricksIncluded, rsVec);
-		results.push_back(normalized);
-	}
-
-	// 3) Any remaining bricks not included become their own files
-	for (const auto& [bref, brickPtr] : brickByRef) {
-		if (usedBrickRefs.find(bref) != usedBrickRefs.end()) continue;
-		std::unordered_set<std::string> bricksIncluded{ bref };
-		auto normalized = makeOutput(bricksIncluded, {});
-		results.push_back(normalized);
-		usedBrickRefs.insert(bref);
-	}
-
-	return results;
-}

dCommon/Lxfml.h

@@ -6,7 +6,6 @@
 
 #include <string>
 #include <string_view>
-#include <vector>
 
 #include "NiPoint3.h"
 
@@ -19,7 +18,6 @@ namespace Lxfml {
 	// Normalizes a LXFML model to be positioned relative to its local 0, 0, 0 rather than a game worlds 0, 0, 0.
 	// Returns a struct of its new center and the updated LXFML containing these edits.
 	[[nodiscard]] Result NormalizePosition(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
-	[[nodiscard]] std::vector<Result> Split(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
 
 	// these are only for the migrations due to a bug in one of the implementations.
 	[[nodiscard]] Result NormalizePositionOnlyFirstPart(const std::string_view data);

dCommon/LxfmlBugged.cpp

@@ -53,21 +53,16 @@ Lxfml::Result Lxfml::NormalizePositionOnlyFirstPart(const std::string_view data)
 			continue;
 		}
 
-		try {
-			auto x = GeneralUtils::TryParse<float>(split[9]).value();
-			auto y = GeneralUtils::TryParse<float>(split[10]).value();
-			auto z = GeneralUtils::TryParse<float>(split[11]).value();
-			if (x < lowest.x) lowest.x = x;
-			if (y < lowest.y) lowest.y = y;
-			if (z < lowest.z) lowest.z = z;
+		auto x = GeneralUtils::TryParse<float>(split[9]).value();
+		auto y = GeneralUtils::TryParse<float>(split[10]).value();
+		auto z = GeneralUtils::TryParse<float>(split[11]).value();
+		if (x < lowest.x) lowest.x = x;
+		if (y < lowest.y) lowest.y = y;
+		if (z < lowest.z) lowest.z = z;
 
-			if (highest.x < x) highest.x = x;
-			if (highest.y < y) highest.y = y;
-			if (highest.z < z) highest.z = z;
-		} catch (std::exception& e) {
-			LOG("Failed to parse a split value of either (%s), (%s), or (%s).", split[9].c_str(), split[10].c_str(), split[11].c_str());
-			return toReturn; // Early return since we failed to parse this lxfml.
-		}
+		if (highest.x < x) highest.x = x;
+		if (highest.y < y) highest.y = y;
+		if (highest.z < z) highest.z = z;
 	}
 
 	auto delta = (highest - lowest) / 2.0f;

dCommon/Metrics.cpp

@@ -1,77 +1,105 @@
-#include "Metrics.h"
-
-#include "StringifiedEnum.h"
+#include "Metrics.hpp"
 
 #include <chrono>
 
-namespace {
-	std::unordered_map<MetricVariable, Metric> g_Metrics = {};
-	std::vector<MetricVariable> g_Variables = {
-		MetricVariable::GameLoop,
-		MetricVariable::PacketHandling,
-		MetricVariable::UpdateEntities,
-		MetricVariable::UpdateSpawners,
-		MetricVariable::Physics,
-		MetricVariable::UpdateReplica,
-		MetricVariable::Ghosting,
-		MetricVariable::CPUTime,
-		MetricVariable::Sleep,
-		MetricVariable::Frame,
-	};
-}
+std::unordered_map<MetricVariable, Metric*> Metrics::m_Metrics = {};
+std::vector<MetricVariable> Metrics::m_Variables = {
+	MetricVariable::GameLoop,
+	MetricVariable::PacketHandling,
+	MetricVariable::UpdateEntities,
+	MetricVariable::UpdateSpawners,
+	MetricVariable::Physics,
+	MetricVariable::UpdateReplica,
+	MetricVariable::Ghosting,
+	MetricVariable::CPUTime,
+	MetricVariable::Sleep,
+	MetricVariable::Frame,
+};
 
 void Metrics::AddMeasurement(MetricVariable variable, int64_t value) {
-	auto& metric = g_Metrics[variable];
+	const auto& iter = m_Metrics.find(variable);
+
+	Metric* metric;
+
+	if (iter == m_Metrics.end()) {
+		metric = new Metric();
+
+		m_Metrics[variable] = metric;
+	} else {
+		metric = iter->second;
+	}
 
 	AddMeasurement(metric, value);
 }
 
-void Metrics::AddMeasurement(Metric& metric, int64_t value) {
-	const auto index = metric.measurementIndex;
+void Metrics::AddMeasurement(Metric* metric, int64_t value) {
+	const auto index = metric->measurementIndex;
 
-	metric.measurements[index] = value;
+	metric->measurements[index] = value;
 
-	if (metric.max == -1 || value > metric.max) {
-		metric.max = value;
-	} else if (metric.min == -1 || metric.min > value) {
-		metric.min = value;
+	if (metric->max == -1 || value > metric->max) {
+		metric->max = value;
+	} else if (metric->min == -1 || metric->min > value) {
+		metric->min = value;
 	}
 
-	if (metric.measurementSize < MAX_MEASURMENT_POINTS) {
-		metric.measurementSize++;
+	if (metric->measurementSize < MAX_MEASURMENT_POINTS) {
+		metric->measurementSize++;
 	}
 
-	metric.measurementIndex = (index + 1) % MAX_MEASURMENT_POINTS;
+	metric->measurementIndex = (index + 1) % MAX_MEASURMENT_POINTS;
 }
 
-const Metric& Metrics::GetMetric(MetricVariable variable) {
-	auto& metric = g_Metrics[variable];
+const Metric* Metrics::GetMetric(MetricVariable variable) {
+	const auto& iter = m_Metrics.find(variable);
+
+	if (iter == m_Metrics.end()) {
+		return nullptr;
+	}
+
+	Metric* metric = iter->second;
 
 	int64_t average = 0;
 
-	for (size_t i = 0; i < metric.measurementSize; i++) {
-		average += metric.measurements[i];
+	for (size_t i = 0; i < metric->measurementSize; i++) {
+		average += metric->measurements[i];
 	}
 
-	average /= metric.measurementSize;
+	average /= metric->measurementSize;
 
-	metric.average = average;
+	metric->average = average;
 
 	return metric;
 }
 
 void Metrics::StartMeasurement(MetricVariable variable) {
-	auto& metric = g_Metrics[variable];
+	const auto& iter = m_Metrics.find(variable);
 
-	metric.activeMeasurement = std::chrono::high_resolution_clock::now();
+	Metric* metric;
+
+	if (iter == m_Metrics.end()) {
+		metric = new Metric();
+
+		m_Metrics[variable] = metric;
+	} else {
+		metric = iter->second;
+	}
+
+	metric->activeMeasurement = std::chrono::high_resolution_clock::now();
 }
 
 void Metrics::EndMeasurement(MetricVariable variable) {
 	const auto end = std::chrono::high_resolution_clock::now();
 
-	auto& metric = g_Metrics[variable];
+	const auto& iter = m_Metrics.find(variable);
 
-	const auto elapsed = end - metric.activeMeasurement;
+	if (iter == m_Metrics.end()) {
+		return;
+	}
+
+	Metric* metric = iter->second;
+
+	const auto elapsed = end - metric->activeMeasurement;
 
 	const auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
 
@@ -82,12 +110,44 @@ float Metrics::ToMiliseconds(int64_t nanoseconds) {
 	return static_cast<float>(nanoseconds) / 1e6;
 }
 
-const std::string_view Metrics::MetricVariableToString(MetricVariable variable) {
-	return StringifiedEnum::ToString(variable);
+std::string Metrics::MetricVariableToString(MetricVariable variable) {
+	switch (variable) {
+	case MetricVariable::GameLoop:
+		return "GameLoop";
+	case MetricVariable::PacketHandling:
+		return "PacketHandling";
+	case MetricVariable::UpdateEntities:
+		return "UpdateEntities";
+	case MetricVariable::UpdateSpawners:
+		return "UpdateSpawners";
+	case MetricVariable::Physics:
+		return "Physics";
+	case MetricVariable::UpdateReplica:
+		return "UpdateReplica";
+	case MetricVariable::Sleep:
+		return "Sleep";
+	case MetricVariable::CPUTime:
+		return "CPUTime";
+	case MetricVariable::Frame:
+		return "Frame";
+	case MetricVariable::Ghosting:
+		return "Ghosting";
+
+	default:
+		return "Invalid";
+	}
 }
 
 const std::vector<MetricVariable>& Metrics::GetAllMetrics() {
-	return g_Variables;
+	return m_Variables;
+}
+
+void Metrics::Clear() {
+	for (const auto& pair : m_Metrics) {
+		delete pair.second;
+	}
+
+	m_Metrics.clear();
 }
 
 /* RSS Memory utilities

dCommon/Metrics.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "dCommonVars.h"
-#include <vector>
-#include <map>
-#include <string_view>
-#include <unordered_map>
-#include <chrono>
-
-#define MAX_MEASURMENT_POINTS 1024
-
-enum class MetricVariable : int32_t {
-	GameLoop,
-	PacketHandling,
-	UpdateEntities,
-	UpdateSpawners,
-	Physics,
-	UpdateReplica,
-	Ghosting,
-	CPUTime,
-	Sleep,
-	Frame,
-};
-
-struct Metric {
-	int64_t measurements[MAX_MEASURMENT_POINTS] = {};
-	size_t measurementIndex = 0;
-	size_t measurementSize = 0;
-	int64_t max = -1;
-	int64_t min = -1;
-	int64_t average = 0;
-	std::chrono::time_point<std::chrono::high_resolution_clock> activeMeasurement;
-};
-
-namespace Metrics {
-	void AddMeasurement(MetricVariable variable, int64_t value);
-	void AddMeasurement(Metric& metric, int64_t value);
-	const Metric& GetMetric(MetricVariable variable);
-	void StartMeasurement(MetricVariable variable);
-	void EndMeasurement(MetricVariable variable);
-	float ToMiliseconds(int64_t nanoseconds);
-	const std::string_view MetricVariableToString(MetricVariable variable);
-	const std::vector<MetricVariable>& GetAllMetrics();
-
-	size_t GetPeakRSS();
-	size_t GetCurrentRSS();
-	size_t GetProcessID();
-};

dCommon/Metrics.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "dCommonVars.h"
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <chrono>
+
+#define MAX_MEASURMENT_POINTS 1024
+
+enum class MetricVariable : int32_t
+{
+	GameLoop,
+	PacketHandling,
+	UpdateEntities,
+	UpdateSpawners,
+	Physics,
+	UpdateReplica,
+	Ghosting,
+	CPUTime,
+	Sleep,
+	Frame,
+};
+
+struct Metric
+{
+	int64_t measurements[MAX_MEASURMENT_POINTS] = {};
+	size_t measurementIndex = 0;
+	size_t measurementSize = 0;
+	int64_t max = -1;
+	int64_t min = -1;
+	int64_t average = 0;
+	std::chrono::time_point<std::chrono::high_resolution_clock> activeMeasurement;
+};
+
+class Metrics
+{
+public:
+	~Metrics();
+
+	static void AddMeasurement(MetricVariable variable, int64_t value);
+	static void AddMeasurement(Metric* metric, int64_t value);
+	static const Metric* GetMetric(MetricVariable variable);
+	static void StartMeasurement(MetricVariable variable);
+	static void EndMeasurement(MetricVariable variable);
+	static float ToMiliseconds(int64_t nanoseconds);
+	static std::string MetricVariableToString(MetricVariable variable);
+	static const std::vector<MetricVariable>& GetAllMetrics();
+
+	static size_t GetPeakRSS();
+	static size_t GetCurrentRSS();
+	static size_t GetProcessID();
+
+	static void Clear();
+
+private:
+	Metrics();
+
+	static std::unordered_map<MetricVariable, Metric*> m_Metrics;
+	static std::vector<MetricVariable> m_Variables;
+};

dCommon/NiPoint3.h

@@ -1,8 +1,6 @@
 #ifndef __NIPOINT3_H__
 #define __NIPOINT3_H__
-#ifndef GLM_ENABLE_EXPERIMENTAL
-# define GLM_ENABLE_EXPERIMENTAL
-#endif
+
 /*!
   \file NiPoint3.hpp
   \brief Defines a point in space in XYZ coordinates

dCommon/NiQuaternion.h

@@ -1,8 +1,6 @@
 #ifndef NIQUATERNION_H
 #define NIQUATERNION_H
-#ifndef GLM_ENABLE_EXPERIMENTAL
-# define GLM_ENABLE_EXPERIMENTAL
-#endif
+
 // Custom Classes
 #include "NiPoint3.h"
 

dCommon/Sd0.cpp

@@ -45,12 +45,6 @@ Sd0::Sd0(std::istream& buffer) {
 		uint32_t bufferSize = buffer.tellg();
 		buffer.seekg(0, std::ios::beg);
 		WriteSize(firstChunk, bufferSize);
-		// its expected that if we got here, we got an old sd0 buffer where we ignored the sd0 part
-		// that means this can be at most the compressed chunk limit.
-		if (bufferSize > MAX_UNCOMPRESSED_CHUNK_SIZE) {
-			LOG("Possible bad chunk size of %i specified, rejecting.", bufferSize);
-			return;
-		}
 		firstChunk.resize(firstChunk.size() + bufferSize);
 		auto* dataStart = reinterpret_cast<char*>(firstChunk.data() + GetDataOffset(true));
 		if (!buffer.read(dataStart, bufferSize)) {
@@ -77,12 +71,6 @@ Sd0::Sd0(std::istream& buffer) {
 
 		WriteSize(chunk, chunkSize);
 
-		// Assuming a good buffer that is large enough to take up 2 zlib buffers
-		// any buffer should be compressed enough to take up less size than its uncompressed counterpart
-		if (chunkSize > MAX_UNCOMPRESSED_CHUNK_SIZE) {
-			LOG("Possible bad chunk size of %i specified, rejecting.", chunkSize);
-			break;
-		}
 		chunk.resize(chunkSize + dataOffset);
 		auto* dataStart = reinterpret_cast<char*>(chunk.data() + dataOffset);
 		if (!buffer.read(dataStart, chunkSize)) {
@@ -107,11 +95,6 @@ void Sd0::FromData(const uint8_t* data, size_t bufferSize) {
 			startOffset, numToCopy,
 			compressedChunk.data(), compressedChunk.size());
 
-		if (compressedSize == -1) {
-			LOG("Failed to compress chunk, aborting");
-			break;
-		}
-
 		auto& chunk = m_Chunks.emplace_back();
 		bool firstBuffer = m_Chunks.size() == 1;
 		auto dataOffset = GetDataOffset(firstBuffer);
@@ -136,12 +119,6 @@ std::string Sd0::GetAsStringUncompressed() const {
 		auto dataOffset = GetDataOffset(first);
 		first = false;
 		const auto chunkSize = chunk.size();
-		if (chunkSize <= static_cast<size_t>(dataOffset)) {
-			LOG("Bad chunkSize for data, aborting");
-			toReturn = "";
-			totalSize = 0;
-			break;
-		}
 
 		auto oldSize = toReturn.size();
 		toReturn.resize(oldSize + MAX_UNCOMPRESSED_CHUNK_SIZE);
@@ -151,13 +128,6 @@ std::string Sd0::GetAsStringUncompressed() const {
 			reinterpret_cast<uint8_t*>(toReturn.data()) + oldSize, MAX_UNCOMPRESSED_CHUNK_SIZE,
 			error);
 
-		if (uncompressedSize == -1) {
-			LOG("Failed to decompress chunk, aborting");
-			toReturn = "";
-			totalSize = 0;
-			break;
-		}
-
 		totalSize += uncompressedSize;
 	}
 

dCommon/ZCompression.cpp

@@ -3,12 +3,12 @@
 #include "zlib.h"
 
 namespace ZCompression {
-	uint32_t GetMaxCompressedLength(uint32_t nLenSrc) {
-		uint32_t n16kBlocks = (nLenSrc + 16383) / 16384; // round up any fraction of a block
+	int32_t GetMaxCompressedLength(int32_t nLenSrc) {
+		int32_t n16kBlocks = (nLenSrc + 16383) / 16384; // round up any fraction of a block
 		return (nLenSrc + 6 + (n16kBlocks * 5));
 	}
 
-	int32_t Compress(const uint8_t* abSrc, uint32_t nLenSrc, uint8_t* abDst, uint32_t nLenDst) {
+	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;
@@ -27,7 +27,7 @@ namespace ZCompression {
 		return(nRet);
 	}
 
-	int32_t Decompress(const uint8_t* abSrc, uint32_t nLenSrc, uint8_t* abDst, uint32_t nLenDst, int32_t& nErr) {
+	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr) {
 		// Get the size of the decompressed data
 		z_stream zInfo = { 0 };
 		zInfo.total_in = zInfo.avail_in = nLenSrc;

dCommon/ZCompression.h

@@ -3,10 +3,10 @@
 #include <cstdint>
 
 namespace ZCompression {
-	uint32_t GetMaxCompressedLength(uint32_t nLenSrc);
+	int32_t GetMaxCompressedLength(int32_t nLenSrc);
 
-	int32_t Compress(const uint8_t* abSrc, uint32_t nLenSrc, uint8_t* abDst, uint32_t nLenDst);
+	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst);
 
-	int32_t Decompress(const uint8_t* abSrc, uint32_t nLenSrc, uint8_t* abDst, uint32_t nLenDst, int32_t& nErr);
+	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr);
 }
 

dCommon/dClient/AssetManager.cpp

@@ -7,7 +7,7 @@
 #include "zlib.h"
 
 constexpr uint32_t CRC32_INIT = 0xFFFFFFFF;
-constexpr auto NULL_TERMINATOR = std::string_view{ "\0\0\0", 4 };
+constexpr auto NULL_TERMINATOR = std::string_view{"\0\0\0", 4};
 
 AssetManager::AssetManager(const std::filesystem::path& path) {
 	if (!std::filesystem::is_directory(path)) {
@@ -25,7 +25,7 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 		if (!std::filesystem::exists(m_Path / ".." / "versions")) {
 			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
 		}
-
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / "..");
@@ -34,7 +34,7 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 		if (!std::filesystem::exists(m_Path / ".." / ".." / "versions")) {
 			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
 		}
-
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / ".." / "..");
@@ -54,15 +54,15 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 	}
 
 	switch (m_AssetBundleType) {
-	case eAssetBundleType::Packed: {
-		this->LoadPackIndex();
-		break;
-	}
-	case eAssetBundleType::None:
-		[[fallthrough]];
-	case eAssetBundleType::Unpacked: {
-		break;
-	}
+		case eAssetBundleType::Packed: {
+			this->LoadPackIndex();
+			break;
+		}
+		case eAssetBundleType::None:
+			[[fallthrough]];
+		case eAssetBundleType::Unpacked: {
+			break;
+		}
 	}
 }
 
@@ -79,7 +79,7 @@ bool AssetManager::HasFile(std::string fixedName) const {
 	std::replace(fixedName.begin(), fixedName.end(), '\\', '/');
 	if (std::filesystem::exists(m_ResPath / fixedName)) return true;
 
-	if (this->m_AssetBundleType == eAssetBundleType::Unpacked || !m_PackIndex) return false;
+	if (this->m_AssetBundleType == eAssetBundleType::Unpacked) return false;
 
 	std::replace(fixedName.begin(), fixedName.end(), '/', '\\');
 	if (fixedName.rfind("client\\res\\", 0) != 0) fixedName = "client\\res\\" + fixedName;
@@ -145,12 +145,8 @@ bool AssetManager::GetFile(std::string fixedName, char** data, uint32_t* len) co
 	}
 
 	const auto& pack = this->m_PackIndex->GetPacks().at(packIndex);
-	bool success = false;
-	try {
-		success = pack.ReadFileFromPack(crc, data, len);
-	} catch (std::exception& e) {
-		LOG("Failed to read file %s from pack file", fixedName.c_str());
-	}
+	const bool success = pack.ReadFileFromPack(crc, data, len);
+
 	return success;
 }
 

dCommon/dClient/AssetManager.h

@@ -81,9 +81,6 @@ public:
 	[[nodiscard]]
 	AssetStream GetFile(const char* name) const;
 
-	[[nodiscard]]
-	AssetStream GetFile(const std::string& name) const { return GetFile(name.c_str()); };
-
 private:
 	void LoadPackIndex();
 

dCommon/dClient/Pack.cpp

@@ -46,7 +46,6 @@ bool Pack::HasFile(const uint32_t crc) const {
 }
 
 bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) const {
-	const auto pathStr = m_FilePath.string();
 	// Time for some wacky C file reading for speed reasons
 
 	PackRecord pkRecord{};
@@ -66,21 +65,16 @@ bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) cons
 	bool isCompressed = (pkRecord.m_IsCompressed & 0xff) > 0;
 	auto inPackSize = isCompressed ? pkRecord.m_CompressedSize : pkRecord.m_UncompressedSize;
 
-	FILE* file = nullptr;
+	FILE* file;
 #ifdef _WIN32
-	fopen_s(&file, pathStr.c_str(), "rb");
+	fopen_s(&file, m_FilePath.string().c_str(), "rb");
 #elif __APPLE__
 	// macOS has 64bit file IO by default
-	file = fopen(pathStr.c_str(), "rb");
+	file = fopen(m_FilePath.string().c_str(), "rb");
 #else
-	file = fopen64(pathStr.c_str(), "rb");
+	file = fopen64(m_FilePath.string().c_str(), "rb");
 #endif
 
-	if (!file) {
-		LOG("No file found for path %s", pathStr.c_str());
-		throw std::runtime_error("Could not find file " + pathStr);
-	}
-
 	fseek(file, pos, SEEK_SET);
 
 	if (!isCompressed) {
@@ -108,18 +102,14 @@ bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) cons
 		int32_t readInData = fread(&size, sizeof(uint32_t), 1, file);
 		pos += 4; // Move pointer position 4 to the right
 
-		std::unique_ptr<char[]> chunk(new char[size]);
-		int32_t readInData2 = fread(chunk.get(), sizeof(int8_t), size, file);
+		char* chunk = static_cast<char*>(malloc(size));
+		int32_t readInData2 = fread(chunk, sizeof(int8_t), size, file);
 		pos += size; // Move pointer position the amount of bytes read to the right
 
 		int32_t err;
-		const auto countToRead = ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk.get()), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
-		if (countToRead == -1) {
-			LOG("Error decompressing zlib data from file %s", pathStr.c_str());
-			throw std::runtime_error("Error decompressing zlib data from file " + pathStr);
-		}
-		currentReadPos += countToRead;
+		currentReadPos += ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
 
+		free(chunk);
 	}
 
 	*data = decompressedData;

dCommon/dConfig.cpp

@@ -84,7 +84,3 @@ void dConfig::ProcessLine(const std::string& line) {
 
 	this->m_ConfigValues.insert(std::make_pair(key, value));
 }
-
-std::string dConfig::GetValue(const std::string& key, const char* emptyValue) {
-	return GetValue(key, std::string(emptyValue));
-};

dCommon/dConfig.h

@@ -5,8 +5,6 @@
 #include <map>
 #include <string>
 
-#include "GeneralUtils.h"
-
 class dConfig {
 public:
 	dConfig(const std::string& filepath);
@@ -24,14 +22,6 @@ public:
 	 */
 	const std::string& GetValue(std::string key);
 
-	// Gets a value from the config and returns the parsed value, or the default value should parsing have failed.
-	template<typename T>
-	T GetValue(const std::string& key, const T emptyValue = T()) {
-		return GeneralUtils::TryParse<T>(GetValue(key)).value_or(emptyValue);
-	}
-
-	std::string GetValue(const std::string& key, const char* emptyValue);
-
 	/**
 	 * Loads the config from a file
 	 */
@@ -53,9 +43,3 @@ private:
 	std::vector<std::function<void()>> m_ConfigHandlers;
 	std::string m_ConfigFilePath;
 };
-
-template<>
-inline std::string dConfig::GetValue(const std::string& key, const std::string emptyValue) {
-	const auto& value = GetValue(key);
-	return value.empty() ? emptyValue : value;
-};

dCommon/dEnums/dCommonVars.h

@@ -16,8 +16,8 @@
 
 // These are the same define, but they mean two different things in different contexts
 // so a different define to distinguish what calculation is happening will help clarity.
-#define FRAMES_TO_MS(x) (1000 / (x))
-#define MS_TO_FRAMES(x) (1000 / (x))
+#define FRAMES_TO_MS(x) 1000 / x
+#define MS_TO_FRAMES(x) 1000 / x
 
 //=========== FRAME TIMINGS ===========
 constexpr uint32_t highFramerate = 60;
@@ -58,7 +58,6 @@ constexpr LWOCLONEID LWOCLONEID_INVALID = -1;     	//!< Invalid LWOCLONEID
 constexpr LWOINSTANCEID LWOINSTANCEID_INVALID = -1; //!< Invalid LWOINSTANCEID
 constexpr LWOMAPID LWOMAPID_INVALID = -1;       	//!< Invalid LWOMAPID
 constexpr uint64_t LWOZONEID_INVALID = 0;       	//!< Invalid LWOZONEID
-constexpr uint32_t MAX_MESSAGE_LENGTH = 0x500000;   //!< Prevent exceptionally large msgs from being processed. Should always be used to check user provided inputs.
 
 constexpr float PI = 3.14159f;
 
@@ -111,6 +110,18 @@ private:
 
 constexpr LWOSCENEID LWOSCENEID_INVALID = -1;
 
+struct LWONameValue {
+	uint32_t length = 0;        //!< The length of the name
+	std::u16string name;			//!< The name
+
+	LWONameValue() = default;
+
+	LWONameValue(const std::u16string& name) {
+		this->name = name;
+		this->length = static_cast<uint32_t>(name.length());
+	}
+};
+
 struct FriendData {
 public:
 	bool isOnline = false;

dCommon/dEnums/eCharacterVersion.h

@@ -20,8 +20,7 @@ enum class eCharacterVersion : uint32_t {
 	NJ_JAYMISSIONS,
 	NEXUS_FORCE_EXPLORER, // Fixes pet ids in player inventories
 	PET_IDS, // Fixes pet ids in player inventories
-	INVENTORY_PERSISTENT_IDS, // Fixes racing meta missions
-	UP_TO_DATE, // will become RACING_META_MISSIONS
+	UP_TO_DATE, // will become INVENTORY_PERSISTENT_IDS
 };
 
 #endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eMissionState.h

@@ -50,10 +50,7 @@ enum class eMissionState : int {
 	/**
 	* The mission has been completed before and has now been completed again. Used for daily missions.
 	*/
-	COMPLETE_READY_TO_COMPLETE = 12,
-
-	// The mission is failed (don't know where this is used)
-	FAILED = 16,
+	COMPLETE_READY_TO_COMPLETE = 12
 };
 
 #endif  //!__MISSIONSTATE__H__

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp

@@ -1,5 +1,6 @@
 #include "CDActivitiesTable.h"
 
+
 void CDActivitiesTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
 	uint32_t size = 0;
@@ -55,13 +56,3 @@ std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActiviti
 
 	return data;
 }
-
-std::optional<const CDActivities> CDActivitiesTable::GetActivity(const uint32_t activityID) {
-	auto& entries = GetEntries();
-	for (const auto& entry : entries) {
-		if (entry.ActivityID == activityID) {
-			return entry;
-		}
-	}
-	return std::nullopt;
-}

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h

@@ -2,7 +2,6 @@
 
 // Custom Classes
 #include "CDTable.h"
-#include <optional>
 
 struct CDActivities {
 	uint32_t ActivityID;
@@ -32,5 +31,4 @@ public:
 
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
-	std::optional<const CDActivities> GetActivity(const uint32_t activityID);
 };

dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.cpp

@@ -154,8 +154,8 @@ std::map<LOT, uint32_t> CDItemComponentTable::ParseCraftingCurrencies(const CDIt
 			// Checking for 2 here, not sure what to do when there's more stuff than expected
 			if (amountSplit.size() == 2) {
 				currencies.insert({
-					GeneralUtils::TryParse<LOT>(amountSplit[0], LOT_NULL),
-					GeneralUtils::TryParse<uint32_t>(amountSplit[1], 0)
+					std::stoull(amountSplit[0]),
+					std::stoi(amountSplit[1])
 					});
 			}
 		}

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.cpp

@@ -93,14 +93,13 @@ std::vector<CDMissions> CDMissionsTable::Query(std::function<bool(CDMissions)> p
 }
 
 const CDMissions* CDMissionsTable::GetPtrByMissionID(uint32_t missionID) const {
-	const CDMissions* toReturn = &Default;
 	for (const auto& entry : GetEntries()) {
 		if (entry.id == missionID) {
-			toReturn = &entry;
+			return const_cast<CDMissions*>(&entry);
 		}
 	}
 
-	return toReturn;
+	return &Default;
 }
 
 const CDMissions& CDMissionsTable::GetByMissionID(uint32_t missionID, bool& found) const {

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.h

@@ -66,7 +66,6 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissions> Query(std::function<bool(CDMissions)> predicate);
 
-	// Cannot be null.
 	const CDMissions* GetPtrByMissionID(uint32_t missionID) const;
 
 	const CDMissions& GetByMissionID(uint32_t missionID, bool& found) const;

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.cpp

@@ -38,11 +38,3 @@ std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObje
 
 	return data;
 }
-
-std::vector<CDObjectSkills> CDObjectSkillsTable::Get(const LOT lot) const {
-	std::vector<CDObjectSkills> toReturn;
-	for (const auto& entry : GetEntries()) {
-		if (entry.objectTemplate == lot) toReturn.push_back(entry);
-	}
-	return toReturn;
-}

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.h

@@ -4,13 +4,12 @@
 #include "CDTable.h"
 
 #include <cstdint>
-#include <vector>
 
 struct CDObjectSkills {
 	uint32_t objectTemplate;        //!< The LOT of the item
 	uint32_t skillID;               //!< The Skill ID of the object
 	uint32_t castOnType;            //!< ???
-	int32_t AICombatWeight;        //!< ???
+	uint32_t AICombatWeight;        //!< ???
 };
 
 class CDObjectSkillsTable : public CDTable<CDObjectSkillsTable, std::vector<CDObjectSkills>> {
@@ -18,6 +17,5 @@ public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDObjectSkills> Query(std::function<bool(CDObjectSkills)> predicate);
-	std::vector<CDObjectSkills> Get(const LOT lot) const;
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.cpp

@@ -69,7 +69,7 @@ const CDObjects& CDObjectsTable::GetByID(const uint32_t lot) {
 		entry.name = tableData.getStringField("name", "");
 		UNUSED(entry.placeable = tableData.getIntField("placeable", -1));
 		entry.type = tableData.getStringField("type", "");
-		UNUSED(entry.description = tableData.getStringField(4, ""));
+		UNUSED(ntry.description = tableData.getStringField(4, ""));
 		UNUSED(entry.localize = tableData.getIntField("localize", -1));
 		UNUSED(entry.npcTemplateID = tableData.getIntField("npcTemplateID", -1));
 		UNUSED(entry.displayName = tableData.getStringField("displayName", ""));

dDatabase/CDClientDatabase/CDClientTables/CDRailActivatorComponent.cpp

@@ -56,7 +56,7 @@ CDRailActivatorComponent CDRailActivatorComponentTable::GetEntryByID(int32_t id)
 std::pair<uint32_t, std::u16string> CDRailActivatorComponentTable::EffectPairFromString(std::string& str) {
 	const auto split = GeneralUtils::SplitString(str, ':');
 	if (split.size() == 2) {
-		return { GeneralUtils::TryParse(split.at(0), 0), GeneralUtils::ASCIIToUTF16(split.at(1)) };
+		return { std::stoi(split.at(0)), GeneralUtils::ASCIIToUTF16(split.at(1)) };
 	}
 
 	return {};

dDatabase/GameDatabase/ITables/IProperty.h

@@ -34,7 +34,6 @@ public:
 	};
 
 	struct PropertyEntranceResult {
-		// This is the number of entries that are in the query IF it were ran without a limit.
 		int32_t totalEntriesMatchingQuery{};
 		// The entries that match the query. This should only contain up to 12 entries.
 		std::vector<IProperty::Info> entries;
@@ -49,7 +48,7 @@ public:
 	// Get the properties for the given property lookup params.
 	// This is expected to return a result set of up to 12 properties
 	// so as not to transfer too much data at once.
-	virtual IProperty::PropertyEntranceResult GetProperties(const PropertyLookup& params) = 0;
+	virtual std::optional<IProperty::PropertyEntranceResult> GetProperties(const PropertyLookup& params) = 0;
 
 	// Update the property moderation info for the given property id.
 	virtual void UpdatePropertyModerationInfo(const IProperty::Info& info) = 0;

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -9,20 +9,6 @@
 typedef std::unique_ptr<sql::PreparedStatement>& UniquePreppedStmtRef;
 typedef std::unique_ptr<sql::ResultSet> UniqueResultSet;
 
-// This struct is used to keep the PreparedStatement alive alongside the ResultSet, since the ResultSet will be invalidated if the PreparedStatement is destroyed.
-// Declaring the members in reverse order of usage to ensure the PreparedStatement is destroyed after the ResultSet. This is guaranteed by the C++ standard.
-struct PreparedStmtResultSet {
-	std::unique_ptr<sql::PreparedStatement> m_stmt;
-	std::unique_ptr<sql::ResultSet> m_resultSet;
-
-	PreparedStmtResultSet(sql::PreparedStatement* stmt = nullptr, sql::ResultSet* resultSet = nullptr)
-		: m_stmt(stmt), m_resultSet(resultSet) {}
-
-	sql::ResultSet* operator->() const {
-		return m_resultSet.get();
-	}
-};
-
 // Purposefully no definition for this to provide linker errors in the case someone tries to
 // bind a parameter to a type that isn't defined.
 template<typename ParamType>
@@ -127,7 +113,7 @@ public:
 	std::string GetBehavior(const LWOOBJID behaviorId) override;
 	void RemoveBehavior(const LWOOBJID characterId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
-	IProperty::PropertyEntranceResult GetProperties(const IProperty::PropertyLookup& params) 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;
@@ -150,15 +136,12 @@ private:
 	// Generic query functions that can be used for any query.
 	// Return type may be different depending on the query, so it is up to the caller to check the return type.
 	// The first argument is the query string, and the rest are the parameters to bind to the query.
-	// The return type is a PreparedStmtResultSet which keeps the PreparedStatement alive alongside the ResultSet.
+	// The return type is a unique_ptr to the result set, which is deleted automatically when it goes out of scope
 	template<typename... Args>
-	inline PreparedStmtResultSet ExecuteSelect(const std::string& query, Args&&... args) {
-		PreparedStmtResultSet toReturn;
-		toReturn.m_stmt.reset(CreatePreppedStmt(query));
-		SetParams(toReturn.m_stmt, std::forward<Args>(args)...);
-		DLU_SQL_TRY_CATCH_RETHROW(toReturn.m_resultSet.reset(toReturn.m_stmt->executeQuery()));
-		// Return the PreparedStmtResultSet, which now owns both the PreparedStatement and ResultSet via unique_ptr and will ensure they are properly cleaned up.
-		return toReturn;
+	inline std::unique_ptr<sql::ResultSet> ExecuteSelect(const std::string& query, Args&&... args) {
+		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return std::unique_ptr<sql::ResultSet>(preppedStmt->executeQuery()));
 	}
 
 	template<typename... Args>

dDatabase/GameDatabase/MySQL/Tables/CharInfo.cpp

@@ -12,7 +12,7 @@ std::vector<std::string> MySQLDatabase::GetApprovedCharacterNames() {
 	return toReturn;
 }
 
-std::optional<ICharInfo::Info> CharInfoFromQueryResult(PreparedStmtResultSet& stmt) {
+std::optional<ICharInfo::Info> CharInfoFromQueryResult(std::unique_ptr<sql::ResultSet> stmt) {
 	if (!stmt->next()) {
 		return std::nullopt;
 	}
@@ -31,13 +31,15 @@ std::optional<ICharInfo::Info> CharInfoFromQueryResult(PreparedStmtResultSet& st
 }
 
 std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const LWOOBJID charId) {
-	auto result = ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId);
-	return CharInfoFromQueryResult(result);
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId)
+	);
 }
 
 std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const std::string_view name) {
-	auto result = ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE name = ? LIMIT 1;", name);
-	return CharInfoFromQueryResult(result);
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE name = ? LIMIT 1;", name)
+	);
 }
 
 std::vector<LWOOBJID> MySQLDatabase::GetAccountCharacterIds(const LWOOBJID accountId) {

dDatabase/GameDatabase/MySQL/Tables/Leaderboard.cpp

@@ -14,7 +14,7 @@ std::optional<uint32_t> MySQLDatabase::GetDonationTotal(const uint32_t activityI
 	return donation_total->getUInt("donation_total");
 }
 
-std::vector<ILeaderboard::Entry> ProcessQuery(PreparedStmtResultSet& rows) {
+std::vector<ILeaderboard::Entry> ProcessQuery(UniqueResultSet& rows) {
 	std::vector<ILeaderboard::Entry> entries;
 	entries.reserve(rows->rowsCount());
 

dDatabase/GameDatabase/MySQL/Tables/Mail.cpp

@@ -48,7 +48,7 @@ std::vector<MailInfo> MySQLDatabase::GetMailForPlayer(const LWOOBJID characterId
 }
 
 std::optional<MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
-	auto res = ExecuteSelect("SELECT attachment_lot, attachment_count, receiver_id FROM mail WHERE id=? LIMIT 1;", mailId);
+	auto res = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
 
 	if (!res->next()) {
 		return std::nullopt;
@@ -57,7 +57,6 @@ std::optional<MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
 	MailInfo toReturn;
 	toReturn.itemLOT = res->getInt("attachment_lot");
 	toReturn.itemCount = res->getInt("attachment_count");
-	toReturn.receiverId = res->getUInt64("receiver_id");
 
 	return toReturn;
 }

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -1,7 +1,7 @@
 #include "MySQLDatabase.h"
 #include "ePropertySortType.h"
 
-IProperty::Info ReadPropertyInfo(PreparedStmtResultSet& result) {
+IProperty::Info ReadPropertyInfo(UniqueResultSet& result) {
 	IProperty::Info info;
 	info.id = result->getUInt64("id");
 	info.ownerId = result->getInt64("owner_id");
@@ -18,10 +18,10 @@ IProperty::Info ReadPropertyInfo(PreparedStmtResultSet& result) {
 	return info;
 }
 
-IProperty::PropertyEntranceResult MySQLDatabase::GetProperties(const IProperty::PropertyLookup& params) {
-	IProperty::PropertyEntranceResult result;
+std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(const IProperty::PropertyLookup& params) {
+	std::optional<IProperty::PropertyEntranceResult> result;
 	std::string query;
-	PreparedStmtResultSet properties;
+	std::unique_ptr<sql::ResultSet> properties;
 
 	if (params.sortChoice == SORT_TYPE_FEATURED || params.sortChoice == SORT_TYPE_FRIENDS) {
 		query = R"QUERY(
@@ -73,7 +73,8 @@ IProperty::PropertyEntranceResult MySQLDatabase::GetProperties(const IProperty::
 			params.playerId
 		);
 		if (count->next()) {
-			result.totalEntriesMatchingQuery = count->getUInt("count");
+			if (!result) result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count->getUInt("count");
 		}
 	} else {
 		if (params.sortChoice == SORT_TYPE_REPUTATION) {
@@ -126,12 +127,14 @@ IProperty::PropertyEntranceResult MySQLDatabase::GetProperties(const IProperty::
 			params.playerSort
 		);
 		if (count->next()) {
-			result.totalEntriesMatchingQuery = count->getUInt("count");
+			if (!result) result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count->getUInt("count");
 		}
 	}
 
 	while (properties->next()) {
-		result.entries.push_back(ReadPropertyInfo(properties));
+		if (!result) result = IProperty::PropertyEntranceResult();
+		result->entries.push_back(ReadPropertyInfo(properties));
 	}
 
 	return result;

dDatabase/GameDatabase/MySQL/Tables/Ugc.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-IUgc::Model ReadModel(PreparedStmtResultSet& result) {
+IUgc::Model ReadModel(UniqueResultSet& result) {
 	IUgc::Model model;
 
 	// blob is owned by the query, so we need to do a deep copy :/

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -111,7 +111,7 @@ public:
 	std::string GetBehavior(const LWOOBJID behaviorId) override;
 	void RemoveBehavior(const LWOOBJID characterId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
-	IProperty::PropertyEntranceResult GetProperties(const IProperty::PropertyLookup& params) 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;
@@ -170,91 +170,91 @@ private:
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const std::string_view param) {
-	LOG_DEBUG("%s", param.data());
+	LOG("%s", param.data());
 	stmt.bind(index, param.data());
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const char* param) {
-	LOG_DEBUG("%s", param);
+	LOG("%s", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const std::string param) {
-	LOG_DEBUG("%s", param.c_str());
+	LOG("%s", param.c_str());
 	stmt.bind(index, param.c_str());
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const int8_t param) {
-	LOG_DEBUG("%u", param);
+	LOG("%u", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const uint8_t param) {
-	LOG_DEBUG("%d", param);
+	LOG("%d", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const int16_t param) {
-	LOG_DEBUG("%u", param);
+	LOG("%u", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const uint16_t param) {
-	LOG_DEBUG("%d", param);
+	LOG("%d", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const uint32_t param) {
-	LOG_DEBUG("%u", param);
+	LOG("%u", param);
 	stmt.bind(index, static_cast<int32_t>(param));
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const int32_t param) {
-	LOG_DEBUG("%d", param);
+	LOG("%d", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const int64_t param) {
-	LOG_DEBUG("%llu", param);
+	LOG("%llu", param);
 	stmt.bind(index, static_cast<sqlite_int64>(param));
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const uint64_t param) {
-	LOG_DEBUG("%llu", param);
+	LOG("%llu", param);
 	stmt.bind(index, static_cast<sqlite_int64>(param));
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const float param) {
-	LOG_DEBUG("%f", param);
+	LOG("%f", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const double param) {
-	LOG_DEBUG("%f", param);
+	LOG("%f", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const bool param) {
-	LOG_DEBUG("%d", param);
+	LOG("%d", param);
 	stmt.bind(index, param);
 }
 
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const std::istream* param) {
-	LOG_DEBUG("Blob");
+	LOG("Blob");
 	// This is the one time you will ever see me use const_cast.
 	std::stringstream stream;
 	stream << param->rdbuf();
@@ -264,10 +264,10 @@ inline void SetParam(PreppedStmtRef stmt, const int index, const std::istream* p
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
 	if (param) {
-		LOG_DEBUG("%d", param.value());
+		LOG("%d", param.value());
 		stmt.bind(index, static_cast<int>(param.value()));
 	} else {
-		LOG_DEBUG("Null");
+		LOG("Null");
 		stmt.bindNull(index);
 	}
 }
@@ -275,10 +275,10 @@ inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<u
 template<>
 inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<LWOOBJID> param) {
 	if (param) {
-		LOG_DEBUG("%d", param.value());
+		LOG("%d", param.value());
 		stmt.bind(index, static_cast<sqlite_int64>(param.value()));
 	} else {
-		LOG_DEBUG("Null");
+		LOG("Null");
 		stmt.bindNull(index);
 	}
 }

dDatabase/GameDatabase/SQLite/Tables/Mail.cpp

@@ -47,7 +47,7 @@ std::vector<MailInfo> SQLiteDatabase::GetMailForPlayer(const LWOOBJID characterI
 }
 
 std::optional<MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
-	auto [_, res] = ExecuteSelect("SELECT attachment_lot, attachment_count, receiver_id FROM mail WHERE id=? LIMIT 1;", mailId);
+	auto [_, res] = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
 
 	if (res.eof()) {
 		return std::nullopt;
@@ -56,7 +56,6 @@ std::optional<MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
 	MailInfo toReturn;
 	toReturn.itemLOT = res.getIntField("attachment_lot");
 	toReturn.itemCount = res.getIntField("attachment_count");
-	toReturn.receiverId = res.getInt64Field("receiver_id");
 
 	return toReturn;
 }

dDatabase/GameDatabase/SQLite/Tables/Property.cpp

@@ -18,8 +18,8 @@ IProperty::Info ReadPropertyInfo(CppSQLite3Query& propertyEntry) {
 	return toReturn;
 }
 
-IProperty::PropertyEntranceResult SQLiteDatabase::GetProperties(const IProperty::PropertyLookup& params) {
-	IProperty::PropertyEntranceResult result;
+std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(const IProperty::PropertyLookup& params) {
+	std::optional<IProperty::PropertyEntranceResult> result;
 	std::string query;
 	std::pair<CppSQLite3Statement, CppSQLite3Query> propertiesRes;
 
@@ -73,7 +73,8 @@ IProperty::PropertyEntranceResult SQLiteDatabase::GetProperties(const IProperty:
 			params.playerId
 		);
 		if (!count.eof()) {
-			result.totalEntriesMatchingQuery = count.getIntField("count");
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
 		}
 	} else {
 		if (params.sortChoice == SORT_TYPE_REPUTATION) {
@@ -126,13 +127,15 @@ IProperty::PropertyEntranceResult SQLiteDatabase::GetProperties(const IProperty:
 			params.playerSort
 		);
 		if (!count.eof()) {
-			result.totalEntriesMatchingQuery = count.getIntField("count");
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
 		}
 	}
 
 	auto& [_, properties] = propertiesRes;
+	if (!properties.eof() && !result.has_value()) result = IProperty::PropertyEntranceResult();
 	while (!properties.eof()) {
-		result.entries.push_back(ReadPropertyInfo(properties));
+		result->entries.push_back(ReadPropertyInfo(properties));
 		properties.nextRow();
 	}
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -90,7 +90,7 @@ class TestSQLDatabase : public GameDatabase {
 	std::string GetBehavior(const LWOOBJID behaviorId) override;
 	void RemoveBehavior(const LWOOBJID behaviorId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
-	IProperty::PropertyEntranceResult GetProperties(const IProperty::PropertyLookup& params) override { return {}; };
+	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 {}; };

dGame/Entity.cpp

@@ -84,8 +84,6 @@
 #include "GhostComponent.h"
 #include "AchievementVendorComponent.h"
 #include "VanityUtilities.h"
-#include "ObjectIDManager.h"
-#include "ePlayerFlag.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -189,21 +187,12 @@ Entity::~Entity() {
 	}
 
 	if (m_ParentEntity) {
-		GameMessages::ChildRemoved removedMsg{};
-		removedMsg.childID = m_ObjectID;
-		removedMsg.target = m_ParentEntity->GetObjectID();
-		removedMsg.Send();
 		m_ParentEntity->RemoveChild(this);
 	}
 }
 
 void Entity::Initialize() {
-	RegisterMsg(&Entity::MsgRequestServerObjectInfo);
-	RegisterMsg(&Entity::MsgDropClientLoot);
-	RegisterMsg(&Entity::MsgGetFactionTokenType);
-	RegisterMsg(&Entity::MsgPickupItem);
-	RegisterMsg(&Entity::MsgChildRemoved);
-	RegisterMsg(&Entity::MsgGetFlag);
+	RegisterMsg(MessageType::Game::REQUEST_SERVER_OBJECT_INFO, this, &Entity::MsgRequestServerObjectInfo);
 	/**
 	 * Setup trigger
 	 */
@@ -298,7 +287,7 @@ void Entity::Initialize() {
 		AddComponent<LUPExhibitComponent>(lupExhibitID);
 	}
 
-	const auto racingControlID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL);
+	const auto racingControlID =compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL);
 	if (racingControlID > 0) {
 		AddComponent<RacingControlComponent>(racingControlID);
 	}
@@ -316,16 +305,15 @@ void Entity::Initialize() {
 			controllablePhysics->LoadFromXml(m_Character->GetXMLDoc());
 
 			const auto mapID = Game::server->GetZoneID();
-			const auto& targetSceneName = m_Character->GetTargetScene();
 
 			//If we came from another zone, put us in the starting loc
-			// Exception for Moon Base as you tend to spawn on the roof.
-			// second exception if we have a specified targetScene since that would only be possible in a test map
-			if (m_Character->GetZoneID() != Game::server->GetZoneID() || mapID == 1603 || !targetSceneName.empty()) {
+			if (m_Character->GetZoneID() != Game::server->GetZoneID() || mapID == 1603) { // Exception for Moon Base as you tend to spawn on the roof.
 				NiPoint3 pos;
 				NiQuaternion rot = QuatUtils::IDENTITY;
 
+				const auto& targetSceneName = m_Character->GetTargetScene();
 				auto* targetScene = Game::entityManager->GetSpawnPointEntity(targetSceneName);
+
 				if (m_Character->HasBeenToWorld(mapID) && targetSceneName.empty()) {
 					pos = m_Character->GetRespawnPoint(mapID);
 					rot = Game::zoneManager->GetZone()->GetSpawnRot();
@@ -428,10 +416,9 @@ void Entity::Initialize() {
 					comp->SetMaxArmor(destCompData[0].armor);
 					comp->SetDeathBehavior(destCompData[0].death_behavior);
 
-					comp->SetIsSmashable(comp->GetIsSmashable() || destCompData[0].isSmashable);
+					comp->SetIsSmashable(destCompData[0].isSmashable);
 
 					comp->SetLootMatrixID(destCompData[0].LootMatrixIndex);
-					comp->SetCurrencyIndex(destCompData[0].CurrencyIndex);
 					Loot::CacheMatrix(destCompData[0].LootMatrixIndex);
 
 					// Now get currency information
@@ -506,7 +493,7 @@ void Entity::Initialize() {
 		auto& systemAddress = m_Character->GetParentUser() ? m_Character->GetParentUser()->GetSystemAddress() : UNASSIGNED_SYSTEM_ADDRESS;
 		AddComponent<CharacterComponent>(characterID, m_Character, systemAddress)->LoadFromXml(m_Character->GetXMLDoc());
 
-		AddComponent<GhostComponent>(characterID)->LoadFromXml(m_Character->GetXMLDoc());
+		AddComponent<GhostComponent>(characterID);
 	}
 
 	const auto inventoryID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY);
@@ -613,14 +600,13 @@ void Entity::Initialize() {
 
 			if (rebuildResetTime != 0.0f) {
 				quickBuildComponent->SetResetTime(rebuildResetTime);
-			}
 
-			const auto objectID = GetObjectID();
-			// FV tree handler for when built so it sets the state to moving at the correct time
-			if (GetLOT() == 9483) quickBuildComponent->AddQuickBuildCompleteCallback([objectID](Entity* user) {
-				auto* const entity = Game::entityManager->GetEntity(objectID);
-				if (entity) GameMessages::SendPlatformResync(entity, UNASSIGNED_SYSTEM_ADDRESS, false, 0, 1, 1, eMovementPlatformState::Moving, true);
-				});
+				// Known bug with moving platform in FV that casues it to build at the end instead of the start.
+				// This extends the smash time so players can ride up the lift.
+				if (m_TemplateID == 9483) {
+					quickBuildComponent->SetResetTime(quickBuildComponent->GetResetTime() + 25);
+				}
+			}
 
 			const auto activityID = GetVar<int32_t>(u"activityID");
 
@@ -951,13 +937,13 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
 	}
 }
 
-void Entity::WriteLDFData(const LwoNameValue& ldf, RakNet::BitStream& outBitStream) const {
+void Entity::WriteLDFData(const std::vector<LDFBaseData*>& ldf, RakNet::BitStream& outBitStream) const {
 	RakNet::BitStream settingStream;
-	int32_t numberOfValidKeys = ldf.values.size();
+	int32_t numberOfValidKeys = ldf.size();
 
 	// Writing keys value pairs the client does not expect to receive or interpret will result in undefined behavior,
 	// so we need to filter out any keys that are not valid and fix the number of valid keys to be correct.
-	for (const auto& data : ldf.values | std::views::values) {
+	for (LDFBaseData* data : ldf) {
 		if (data && data->GetValueType() != eLDFType::LDF_TYPE_UNKNOWN) {
 			data->WriteToPacket(settingStream);
 		} else {
@@ -989,16 +975,16 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream& outBitStream, eReplicaPacke
 		const auto& syncLDF = GetVar<std::vector<std::u16string>>(u"syncLDF");
 
 		// Only sync for models.
-		if (!m_Settings.values.empty() && (GetComponent<ModelComponent>() && !GetComponent<PetComponent>())) {
+		if (!m_Settings.empty() && (GetComponent<ModelComponent>() && !GetComponent<PetComponent>())) {
 			outBitStream.Write1(); // Has ldf data
 			WriteLDFData(m_Settings, outBitStream);
 		} else if (!syncLDF.empty()) {
 			// Find all the ldf data we need to write
-			LwoNameValue ldfData;
+			std::vector<LDFBaseData*> ldfData;
+			ldfData.reserve(m_Settings.size());
 
 			for (const auto& data : syncLDF) {
-				const auto* toInsert = GetVarData(data);
-				if (toInsert) ldfData.values.insert_or_assign(data, toInsert->Copy());
+				ldfData.push_back(GetVarData(data));
 			}
 
 			outBitStream.Write1(); // Has ldf data
@@ -1615,10 +1601,26 @@ void Entity::Kill(Entity* murderer, const eKillType killType) {
 		else Game::entityManager->DestroyEntity(this);
 	}
 
-	const auto& grpNameQBShowBricks = GetVarAsString(u"grpNameQBShowBricks");
+	const auto& grpNameQBShowBricks = GetVar<std::string>(u"grpNameQBShowBricks");
+
 	if (!grpNameQBShowBricks.empty()) {
-		for (auto* const spawner : Game::zoneManager->GetSpawnersByName(grpNameQBShowBricks)) if (spawner) spawner->Spawn();
-		for (auto* const spawner : Game::zoneManager->GetSpawnersInGroup(grpNameQBShowBricks)) if (spawner) spawner->Spawn();
+		auto spawners = Game::zoneManager->GetSpawnersByName(grpNameQBShowBricks);
+
+		Spawner* spawner = nullptr;
+
+		if (!spawners.empty()) {
+			spawner = spawners[0];
+		} else {
+			spawners = Game::zoneManager->GetSpawnersInGroup(grpNameQBShowBricks);
+
+			if (!spawners.empty()) {
+				spawner = spawners[0];
+			}
+		}
+
+		if (spawner != nullptr) {
+			spawner->Spawn();
+		}
 	}
 
 	// Track a player being smashed
@@ -1661,7 +1663,7 @@ void Entity::AddLootItem(const Loot::Info& info) const {
 
 	auto* const characterComponent = GetComponent<CharacterComponent>();
 	if (!characterComponent) return;
-	LOG("Player %llu has been allowed to pickup %i with id %llu", m_ObjectID, info.lot, info.id);
+
 	auto& droppedLoot = characterComponent->GetDroppedLoot();
 	droppedLoot[info.id] = info;
 }
@@ -2032,7 +2034,13 @@ void Entity::SetI64(const std::u16string& name, const int64_t value) {
 }
 
 bool Entity::HasVar(const std::u16string& name) const {
-	return m_Settings.values.contains(name);
+	for (auto* data : m_Settings) {
+		if (data->GetKey() == name) {
+			return true;
+		}
+	}
+
+	return false;
 }
 
 uint16_t Entity::GetNetworkId() const {
@@ -2064,13 +2072,24 @@ void Entity::SendNetworkVar(const std::string& data, const SystemAddress& sysAdd
 	GameMessages::SendSetNetworkScriptVar(this, sysAddr, data);
 }
 
-const LDFBaseData* const Entity::GetVarData(const std::u16string& name) const {
-	const auto itr = m_Settings.values.find(name);
-	return itr != m_Settings.values.cend() ? itr->second.get() : nullptr;
+LDFBaseData* Entity::GetVarData(const std::u16string& name) const {
+	for (auto* data : m_Settings) {
+		if (data == nullptr) {
+			continue;
+		}
+
+		if (data->GetKey() != name) {
+			continue;
+		}
+
+		return data;
+	}
+
+	return nullptr;
 }
 
 std::string Entity::GetVarAsString(const std::u16string& name) const {
-	const auto* const data = GetVarData(name);
+	auto* data = GetVarData(name);
 	return data ? data->GetValueAsString() : "";
 }
 
@@ -2221,14 +2240,13 @@ void Entity::RegisterMsg(const MessageType::Game msgId, std::function<bool(GameM
 	m_MsgHandlers.emplace(msgId, handler);
 }
 
-bool Entity::MsgRequestServerObjectInfo(GameMessages::RequestServerObjectInfo& requestInfo) {
+bool Entity::MsgRequestServerObjectInfo(GameMessages::GameMsg& msg) {
+	auto& requestInfo = static_cast<GameMessages::RequestServerObjectInfo&>(msg);
 	AMFArrayValue response;
 	response.Insert("visible", true);
 	response.Insert("objectID", std::to_string(m_ObjectID));
 	response.Insert("serverInfo", true);
 	GameMessages::GetObjectReportInfo info{};
-	info.clientID = requestInfo.clientId;
-	info.bVerbose = requestInfo.bVerbose;
 	info.info = response.InsertArray("data");
 	auto& objectInfo = info.info->PushDebug("Object Details");
 	auto* table = CDClientManager::GetTable<CDObjectsTable>();
@@ -2239,91 +2257,20 @@ bool Entity::MsgRequestServerObjectInfo(GameMessages::RequestServerObjectInfo& r
 	objectInfo.PushDebug<AMFIntValue>("Template ID(LOT)") = GetLOT();
 	objectInfo.PushDebug<AMFStringValue>("Object ID") = std::to_string(GetObjectID());
 	objectInfo.PushDebug<AMFStringValue>("Spawner's Object ID") = std::to_string(GetSpawnerID());
-	objectInfo.PushDebug<AMFStringValue>("Owner override") = std::to_string(m_OwnerOverride);
 
 	auto& componentDetails = objectInfo.PushDebug("Component Information");
 	for (const auto [id, component] : m_Components) {
-		componentDetails.PushDebug(StringifiedEnum::ToString(id));
+		componentDetails.PushDebug<AMFStringValue>(StringifiedEnum::ToString(id)) = "";
 	}
 
 	auto& configData = objectInfo.PushDebug("Config Data");
-	for (const auto& config : m_Settings.values | std::views::values) {
+	for (const auto config : m_Settings) {
 		configData.PushDebug<AMFStringValue>(GeneralUtils::UTF16ToWTF8(config->GetKey())) = config->GetValueAsString();
-	}
 
+	}
 	HandleMsg(info);
 
 	auto* client = Game::entityManager->GetEntity(requestInfo.clientId);
 	if (client) GameMessages::SendUIMessageServerToSingleClient("ToggleObjectDebugger", response, client->GetSystemAddress());
 	return true;
 }
-
-bool Entity::MsgDropClientLoot(GameMessages::DropClientLoot& dropLootMsg) {
-	if (dropLootMsg.item != LOT_NULL && dropLootMsg.item != 0) {
-		Loot::Info info{
-			.id = dropLootMsg.lootID,
-			.lot = dropLootMsg.item,
-			.count = dropLootMsg.count,
-		};
-		AddLootItem(info);
-	}
-
-	if (dropLootMsg.item == LOT_NULL && dropLootMsg.currency != 0) {
-		RegisterCoinDrop(dropLootMsg.currency);
-	}
-
-	return true;
-}
-
-bool Entity::MsgGetFlag(GameMessages::GetFlag& flagMsg) {
-	if (m_Character) flagMsg.flag = m_Character->GetPlayerFlag(flagMsg.flagID);
-	return true;
-}
-bool Entity::MsgGetFactionTokenType(GameMessages::GetFactionTokenType& tokenMsg) {
-	GameMessages::GetFlag getFlagMsg{};
-
-	getFlagMsg.flagID = ePlayerFlag::ASSEMBLY_FACTION;
-	MsgGetFlag(getFlagMsg);
-	if (getFlagMsg.flag) tokenMsg.tokenType = 8318;
-
-	getFlagMsg.flagID = ePlayerFlag::SENTINEL_FACTION;
-	MsgGetFlag(getFlagMsg);
-	if (getFlagMsg.flag) tokenMsg.tokenType = 8319;
-
-	getFlagMsg.flagID = ePlayerFlag::PARADOX_FACTION;
-	MsgGetFlag(getFlagMsg);
-	if (getFlagMsg.flag) tokenMsg.tokenType = 8320;
-
-	getFlagMsg.flagID = ePlayerFlag::VENTURE_FACTION;
-	MsgGetFlag(getFlagMsg);
-	if (getFlagMsg.flag) tokenMsg.tokenType = 8321;
-
-	LOG("Returning token type %i", tokenMsg.tokenType);
-	return tokenMsg.tokenType != LOT_NULL;
-}
-
-bool Entity::MsgPickupItem(GameMessages::PickupItem& pickupItemMsg) {
-	if (GetObjectID() == pickupItemMsg.lootOwnerID) {
-		PickupItem(pickupItemMsg.lootID);
-	} else {
-		auto* const characterComponent = GetComponent<CharacterComponent>();
-		if (!characterComponent) return false;
-		auto& droppedLoot = characterComponent->GetDroppedLoot();
-		const auto it = droppedLoot.find(pickupItemMsg.lootID);
-		if (it != droppedLoot.end()) {
-			CDObjectsTable* objectsTable = CDClientManager::GetTable<CDObjectsTable>();
-			const CDObjects& object = objectsTable->GetByID(it->second.lot);
-			if (object.id != 0 && object.type == "Powerup") {
-				return false; // Let powerups be duplicated
-			}
-		}
-		droppedLoot.erase(pickupItemMsg.lootID);
-	}
-
-	return true;
-}
-
-bool Entity::MsgChildRemoved(GameMessages::ChildRemoved& msg) {
-	GetScript()->OnChildRemoved(*this, msg);
-	return true;
-}

dGame/Entity.h

@@ -20,12 +20,6 @@ namespace GameMessages {
 	struct ShootingGalleryFire;
 	struct ChildLoaded;
 	struct PlayerResurrectionFinished;
-	struct RequestServerObjectInfo;
-	struct DropClientLoot;
-	struct GetFlag;
-	struct GetFactionTokenType;
-	struct PickupItem;
-	struct ChildRemoved;
 };
 
 namespace MessageType {
@@ -97,9 +91,9 @@ public:
 
 	LWOOBJID GetSpawnerID() const { return m_SpawnerID; }
 
-	const LwoNameValue& GetSettings() const { return m_Settings; }
+	const std::vector<LDFBaseData*>& GetSettings() const { return m_Settings; }
 
-	const LwoNameValue& GetNetworkSettings() const { return m_NetworkSettings; }
+	const std::vector<LDFBaseData*>& GetNetworkSettings() const { return m_NetworkSettings; }
 
 	bool GetIsDead() const;
 
@@ -112,7 +106,6 @@ public:
 
 	uint16_t GetNetworkId() const;
 
-	// Cannot return nullptr.
 	Entity* GetOwner() const;
 
 	const NiPoint3& GetDefaultPosition() const;
@@ -182,12 +175,7 @@ public:
 
 	void AddComponent(eReplicaComponentType componentId, Component* component);
 
-	bool MsgRequestServerObjectInfo(GameMessages::RequestServerObjectInfo& msg);
-	bool MsgDropClientLoot(GameMessages::DropClientLoot& msg);
-	bool MsgGetFlag(GameMessages::GetFlag& msg);
-	bool MsgGetFactionTokenType(GameMessages::GetFactionTokenType& msg);
-	bool MsgPickupItem(GameMessages::PickupItem& msg);
-	bool MsgChildRemoved(GameMessages::ChildRemoved& msg);
+	bool MsgRequestServerObjectInfo(GameMessages::GameMsg& msg);
 
 	// This is expceted to never return nullptr, an assert checks this.
 	CppScripts::Script* const GetScript() const;
@@ -312,12 +300,6 @@ public:
 	template<typename T>
 	void SetNetworkVar(const std::u16string& name, std::vector<T> value, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 
-	template<typename T>
-	void SetNetworkVar(const std::string& name, T value, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
-
-	template<typename T>
-	LwoNameValue::ValueType::iterator InsertNetworkVar(const std::u16string& name, T value);
-
 	template<typename T>
 	T GetNetworkVar(const std::u16string& name);
 
@@ -330,6 +312,11 @@ public:
 	template<typename ComponentType, typename... VaArgs>
 	ComponentType* AddComponent(VaArgs... args);
 
+	/**
+	 * Get the LDF data.
+	 */
+	LDFBaseData* GetVarData(const std::u16string& name) const;
+
 	/**
 	 * Get the LDF value and convert it to a string.
 	 */
@@ -351,19 +338,8 @@ public:
 
 	bool HandleMsg(GameMessages::GameMsg& msg) const;
 
-	// Provided a function that has a derived GameMessage as its only argument and returns a boolean,
-	// this will register it as a handler for that message type. Casting is done automatically to the type 
-	// of the message in the first argument. This object is expected to exist as long as the handler can be called.
-	template<typename DerivedGameMsg>
-	inline void RegisterMsg(bool (Entity::* handler)(DerivedGameMsg&)) {
-		static_assert(std::is_base_of_v<GameMessages::GameMsg, DerivedGameMsg>, "DerivedGameMsg must inherit from GameMsg");
-		const auto boundFunction = std::bind(handler, this, std::placeholders::_1);
-		// This is the actual function that will be registered, which casts the base GameMsg to the derived type
-		const auto castWrapper = [boundFunction](GameMessages::GameMsg& msg) {
-			return boundFunction(static_cast<DerivedGameMsg&>(msg));
-			};
-		DerivedGameMsg msg;
-		RegisterMsg(msg.msgId, castWrapper);
+	void RegisterMsg(const MessageType::Game msgId, auto* self, const auto handler) {
+		RegisterMsg(msgId, std::bind(handler, self, std::placeholders::_1));
 	}
 
 	/**
@@ -372,20 +348,13 @@ public:
 	static Observable<Entity*, const PositionUpdate&> OnPlayerPositionUpdate;
 
 private:
-
-	/**
-	 * Get the LDF data.
-	 */
-	const LDFBaseData* const GetVarData(const std::u16string& name) const;
-	template<typename T>
-	LwoNameValue::ValueType::iterator InsertLnvData(LwoNameValue& lnv, const std::u16string& key, T value);
-	void WriteLDFData(const LwoNameValue& ldf, RakNet::BitStream& outBitStream) const;
+	void WriteLDFData(const std::vector<LDFBaseData*>& ldf, RakNet::BitStream& outBitStream) const;
 	LWOOBJID m_ObjectID;
 
 	LOT m_TemplateID;
 
-	LwoNameValue m_Settings;
-	LwoNameValue m_NetworkSettings;
+	std::vector<LDFBaseData*> m_Settings;
+	std::vector<LDFBaseData*> m_NetworkSettings;
 
 	NiPoint3 m_DefaultPosition;
 	NiQuaternion m_DefaultRotation = QuatUtils::IDENTITY;
@@ -467,13 +436,13 @@ T* Entity::GetComponent() const {
 
 template<typename T>
 const T& Entity::GetVar(const std::u16string& name) const {
-	const auto* const data = GetVarData(name);
+	auto* data = GetVarData(name);
 
 	if (data == nullptr) {
 		return LDFData<T>::Default;
 	}
 
-	auto* typed = dynamic_cast<const LDFData<T>* const>(data);
+	auto* typed = dynamic_cast<LDFData<T>*>(data);
 
 	if (typed == nullptr) {
 		return LDFData<T>::Default;
@@ -491,44 +460,52 @@ T Entity::GetVarAs(const std::u16string& name) const {
 
 template<typename T>
 void Entity::SetVar(const std::u16string& name, T value) {
-	InsertLnvData<T>(m_Settings, name, value);
-}
+	auto* data = GetVarData(name);
 
-template<typename T>
-LwoNameValue::ValueType::iterator Entity::InsertLnvData(LwoNameValue& lnv, const std::u16string& key, T value) {
-	auto itr = lnv.values.find(key);
-	if (itr != lnv.values.end()) {
-		auto* lnvCast = dynamic_cast<LDFData<T>*>(itr->second.get());
-		if (!lnvCast) {
-			// Is of different type
-			itr->second = std::make_unique<LDFData<T>>(key, value);
-		} else {
-			// Is the same type and exists
-			lnvCast->SetValue(value);
-		}
-	} else {
-		// Doesn't exist
-		itr = lnv.values.insert_or_assign(key, std::make_unique<LDFData<T>>(key, value)).first;
+	if (data == nullptr) {
+		auto* data = new LDFData<T>(name, value);
+
+		m_Settings.push_back(data);
+
+		return;
 	}
 
-	return itr;
-}
+	auto* typed = dynamic_cast<LDFData<T>*>(data);
 
-template<typename T>
-LwoNameValue::ValueType::iterator Entity::InsertNetworkVar(const std::u16string& name, T value) {
-	return InsertLnvData<T>(m_NetworkSettings, name, value);
+	if (typed == nullptr) {
+		return;
+	}
+
+	typed->SetValue(value);
 }
 
 template<typename T>
 void Entity::SetNetworkVar(const std::u16string& name, T value, const SystemAddress& sysAddr) {
-	const auto itr = InsertNetworkVar<T>(name, value);
+	LDFData<T>* newData = nullptr;
 
-	SendNetworkVar(itr->second->GetString(), sysAddr);
-}
+	for (auto* data : m_NetworkSettings) {
+		if (data->GetKey() != name)
+			continue;
 
-template<typename T>
-void Entity::SetNetworkVar(const std::string& name, T value, const SystemAddress& sysAddr) {
-	SetNetworkVar(GeneralUtils::UTF8ToUTF16(name), value, sysAddr);
+		newData = dynamic_cast<LDFData<T>*>(data);
+		if (newData != nullptr) {
+			newData->SetValue(value);
+		} else {  // If we're changing types
+			m_NetworkSettings.erase(
+				std::remove(m_NetworkSettings.begin(), m_NetworkSettings.end(), data), m_NetworkSettings.end()
+			);
+			delete data;
+		}
+
+		break;
+	}
+
+	if (newData == nullptr) {
+		newData = new LDFData<T>(name, value);
+	}
+
+	m_NetworkSettings.push_back(newData);
+	SendNetworkVar(newData->GetString(true), sysAddr);
 }
 
 template<typename T>
@@ -537,11 +514,28 @@ void Entity::SetNetworkVar(const std::u16string& name, std::vector<T> values, co
 	auto index = 1;
 
 	for (const auto& value : values) {
+		LDFData<T>* newData = nullptr;
 		const auto& indexedName = name + u"." + GeneralUtils::to_u16string(index);
-		const auto itr = InsertNetworkVar<T>(indexedName, value);
-		updates << itr->second->GetString();
-		if (index != values.size()) {
-			updates << "\n";
+
+		for (auto* data : m_NetworkSettings) {
+			if (data->GetKey() != indexedName)
+				continue;
+
+			newData = dynamic_cast<LDFData<T>*>(data);
+			newData->SetValue(value);
+			break;
+		}
+
+		if (newData == nullptr) {
+			newData = new LDFData<T>(indexedName, value);
+		}
+
+		m_NetworkSettings.push_back(newData);
+
+		if (index == values.size()) {
+			updates << newData->GetString(true);
+		} else {
+			updates << newData->GetString(true) << "\n";
 		}
 
 		index++;
@@ -552,15 +546,18 @@ void Entity::SetNetworkVar(const std::u16string& name, std::vector<T> values, co
 
 template<typename T>
 T Entity::GetNetworkVar(const std::u16string& name) {
-	T toReturn = LDFData<T>::Default;
+	for (auto* data : m_NetworkSettings) {
+		if (data == nullptr || data->GetKey() != name)
+			continue;
 
-	const auto itr = m_NetworkSettings.values.find(name);
-	if (itr != m_NetworkSettings.values.cend()) {
-		auto* cast = dynamic_cast<LDFData<T>*>(itr->second.get());
-		if (cast) toReturn = cast->GetValue();
+		auto* typed = dynamic_cast<LDFData<T>*>(data);
+		if (typed == nullptr)
+			continue;
+
+		return typed->GetValue();
 	}
 
-	return toReturn;
+	return LDFData<T>::Default;
 }
 
 /**
@@ -603,5 +600,5 @@ auto Entity::GetComponents() const {
 
 template<typename... T>
 auto Entity::GetComponentsMut() const {
-	return std::tuple{ GetComponent<T>()... };
+	return std::tuple{GetComponent<T>()...};
 }

dGame/EntityManager.cpp

@@ -10,6 +10,7 @@
 #include "SkillComponent.h"
 #include "SwitchComponent.h"
 #include "UserManager.h"
+#include "Metrics.hpp"
 #include "dZoneManager.h"
 #include "MissionComponent.h"
 #include "Game.h"
@@ -86,8 +87,6 @@ void EntityManager::ReloadConfig() {
 	auto hcXpReduction = Game::config->GetValue("hardcore_uscore_reduction");
 	m_HardcoreUscoreReduction = hcXpReduction.empty() ? 1.0f : GeneralUtils::TryParse<float>(hcXpReduction).value_or(1.0f);
 	m_HardcoreMode = GetHardcoreDisabledWorlds().contains(Game::zoneManager->GetZoneID().GetMapID()) ? false : m_HardcoreMode;
-	auto hcCoinKeep = Game::config->GetValue("hardcore_coin_keep");
-	m_HardcoreCoinKeep = hcCoinKeep.empty() ? false : GeneralUtils::TryParse<float>(hcCoinKeep).value_or(0.0f);
 }
 
 void EntityManager::Initialize() {
@@ -360,24 +359,16 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		LOG("Attempted to construct null entity");
 		return;
 	}
-	// Don't construct GM invisible entities unless it's for the GM themselves
-	// GMs can see other GMs if they are the same or lower level
-	GameMessages::GetGMInvis getGMInvisMsg;
-	getGMInvisMsg.Send(entity->GetObjectID());
-	if (getGMInvisMsg.bGMInvis && sysAddr != entity->GetSystemAddress()) {
-		auto* toUser = UserManager::Instance()->GetUser(sysAddr);
-		if (!toUser) return;
-		auto* constructedUser = UserManager::Instance()->GetUser(entity->GetSystemAddress());
-		if (!constructedUser) return;
-		if (toUser->GetMaxGMLevel() < constructedUser->GetMaxGMLevel()) return;
-	}
 
 	if (entity->GetNetworkId() == 0) {
 		uint16_t networkId;
+
 		if (!m_LostNetworkIds.empty()) {
 			networkId = m_LostNetworkIds.top();
 			m_LostNetworkIds.pop();
-		} else networkId = ++m_NetworkIdCounter;
+		} else {
+			networkId = ++m_NetworkIdCounter;
+		}
 
 		entity->SetNetworkId(networkId);
 	}
@@ -386,8 +377,10 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		if (std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entity) == m_EntitiesToGhost.end()) {
 			m_EntitiesToGhost.push_back(entity);
 		}
+
 		if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 			CheckGhosting(entity);
+
 			return;
 		}
 	}
@@ -418,9 +411,14 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		Game::server->Send(stream, sysAddr, false);
 	}
 
+	if (entity->IsPlayer()) {
+		if (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) {
+			GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, sysAddr);
+		}
+	}
 }
 
-void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {	
+void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {
 	//ZoneControl is special:
 	ConstructEntity(m_ZoneControlEntity, sysAddr);
 
@@ -488,7 +486,11 @@ void EntityManager::QueueGhostUpdate(LWOOBJID playerID) {
 void EntityManager::UpdateGhosting() {
 	for (const auto playerID : m_PlayersToUpdateGhosting) {
 		auto* player = PlayerManager::GetPlayer(playerID);
-		if (!player) continue;
+
+		if (player == nullptr) {
+			continue;
+		}
+
 		UpdateGhosting(player);
 	}
 
@@ -515,7 +517,6 @@ void EntityManager::UpdateGhosting(Entity* player) {
 
 		const auto distance = NiPoint3::DistanceSquared(referencePoint, entityPoint);
 
-
 		auto ghostingDistanceMax = m_GhostDistanceMaxSquared;
 		auto ghostingDistanceMin = m_GhostDistanceMinSqaured;
 
@@ -552,25 +553,35 @@ void EntityManager::UpdateGhosting(Entity* player) {
 }
 
 void EntityManager::CheckGhosting(Entity* entity) {
-	if (!entity) return;
+	if (entity == nullptr) {
+		return;
+	}
 
 	const auto& referencePoint = entity->GetPosition();
+
 	for (auto* player : PlayerManager::GetAllPlayers()) {
 		auto* ghostComponent = player->GetComponent<GhostComponent>();
 		if (!ghostComponent) continue;
 
 		const auto& entityPoint = ghostComponent->GetGhostReferencePoint();
+
 		const auto id = entity->GetObjectID();
+
 		const auto observed = ghostComponent->IsObserved(id);
+
 		const auto distance = NiPoint3::DistanceSquared(referencePoint, entityPoint);
 
 		if (observed && distance > m_GhostDistanceMaxSquared) {
 			ghostComponent->GhostEntity(id);
+
 			DestructEntity(entity, player->GetSystemAddress());
+
 			entity->SetObservers(entity->GetObservers() - 1);
 		} else if (!observed && m_GhostDistanceMinSqaured > distance) {
 			ghostComponent->ObserveEntity(id);
+
 			ConstructEntity(entity, player->GetSystemAddress());
+
 			entity->SetObservers(entity->GetObservers() + 1);
 		}
 	}

dGame/EntityManager.h

@@ -81,7 +81,6 @@ public:
 	const std::set<LOT>& GetHardcoreUscoreReducedLots() const { return m_HardcoreUscoreReducedLots; };
 	const std::set<LOT>& GetHardcoreUscoreExcludedEnemies() const { return m_HardcoreUscoreExcludedEnemies; };
 	const std::set<LWOMAPID>& GetHardcoreDisabledWorlds() const { return m_HardcoreDisabledWorlds; };
-	float GetHardcoreCoinKeep() const { return m_HardcoreCoinKeep; }
 
 	// Messaging
 	bool SendMessage(GameMessages::GameMsg& msg) const;
@@ -126,7 +125,6 @@ private:
 	std::set<LOT> m_HardcoreUscoreReducedLots{};
 	std::set<LOT> m_HardcoreUscoreExcludedEnemies{};
 	std::set<LWOMAPID> m_HardcoreDisabledWorlds{};
-	float m_HardcoreCoinKeep{};
 };
 
 #endif // ENTITYMANAGER_H

dGame/LeaderboardManager.cpp

@@ -18,8 +18,7 @@
 #include "DluAssert.h"
 
 #include "CDActivitiesTable.h"
-
-#include <chrono>
+#include "Metrics.hpp"
 
 namespace LeaderboardManager {
 	std::map<GameID, Leaderboard::Type> leaderboardCache;
@@ -39,10 +38,10 @@ Leaderboard::~Leaderboard() {
 }
 
 void Leaderboard::Clear() {
-	entries.clear();
+	for (auto& entry : entries) for (auto ldfData : entry) delete ldfData;
 }
 
-inline void WriteLeaderboardRow(std::ostringstream& leaderboard, const uint32_t& index, const std::unique_ptr<LDFBaseData>& data) {
+inline void WriteLeaderboardRow(std::ostringstream& leaderboard, const uint32_t& index, LDFBaseData* data) {
 	leaderboard << "\nResult[0].Row[" << index << "]." << data->GetString();
 }
 
@@ -59,8 +58,8 @@ void Leaderboard::Serialize(RakNet::BitStream& bitStream) const {
 
 	int32_t rowNumber = 0;
 	for (auto& entry : entries) {
-		for (const auto& data : entry.values | std::views::values) {
-			if (data) WriteLeaderboardRow(leaderboard, rowNumber, data);
+		for (auto* data : entry) {
+			WriteLeaderboardRow(leaderboard, rowNumber, data);
 		}
 		rowNumber++;
 	}
@@ -85,56 +84,57 @@ void QueryToLdf(Leaderboard& leaderboard, const std::vector<ILeaderboard::Entry>
 	for (const auto& leaderboardEntry : leaderboardEntries) {
 		constexpr int32_t MAX_NUM_DATA_PER_ROW = 9;
 		auto& entry = leaderboard.PushBackEntry();
-		entry.Insert<uint64_t>(u"CharacterID", leaderboardEntry.charId);
-		entry.Insert<uint64_t>(u"LastPlayed", leaderboardEntry.lastPlayedTimestamp);
-		entry.Insert<int32_t>(u"NumPlayed", leaderboardEntry.numTimesPlayed);
-		entry.Insert<std::u16string>(u"name", GeneralUtils::ASCIIToUTF16(leaderboardEntry.name));
-		entry.Insert<uint64_t>(u"RowNumber", leaderboardEntry.ranking);
+		entry.reserve(MAX_NUM_DATA_PER_ROW);
+		entry.push_back(new LDFData<uint64_t>(u"CharacterID", leaderboardEntry.charId));
+		entry.push_back(new LDFData<uint64_t>(u"LastPlayed", leaderboardEntry.lastPlayedTimestamp));
+		entry.push_back(new LDFData<int32_t>(u"NumPlayed", leaderboardEntry.numTimesPlayed));
+		entry.push_back(new LDFData<std::u16string>(u"name", GeneralUtils::ASCIIToUTF16(leaderboardEntry.name)));
+		entry.push_back(new LDFData<uint64_t>(u"RowNumber", leaderboardEntry.ranking));
 		switch (leaderboard.GetLeaderboardType()) {
 		case ShootingGallery:
-			entry.Insert<int32_t>(u"Score", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Score", leaderboardEntry.primaryScore));
 			// Score:1
-			entry.Insert<int32_t>(u"Streak", leaderboardEntry.secondaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Streak", leaderboardEntry.secondaryScore));
 			// Streak:1
-			entry.Insert<float>(u"HitPercentage", leaderboardEntry.tertiaryScore);
+			entry.push_back(new LDFData<float>(u"HitPercentage", leaderboardEntry.tertiaryScore));
 			// HitPercentage:3 between 0 and 1
 			break;
 		case Racing:
-			entry.Insert<float>(u"BestTime", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<float>(u"BestTime", leaderboardEntry.primaryScore));
 			// BestLapTime:3
-			entry.Insert<float>(u"BestLapTime", leaderboardEntry.secondaryScore);
+			entry.push_back(new LDFData<float>(u"BestLapTime", leaderboardEntry.secondaryScore));
 			// BestTime:3
-			entry.Insert<int32_t>(u"License", 1);
+			entry.push_back(new LDFData<int32_t>(u"License", 1));
 			// License:1 - 1 if player has completed mission 637 and 0 otherwise
-			entry.Insert<int32_t>(u"NumWins", leaderboardEntry.numWins);
+			entry.push_back(new LDFData<int32_t>(u"NumWins", leaderboardEntry.numWins));
 			// NumWins:1
 			break;
 		case UnusedLeaderboard4:
-			entry.Insert<int32_t>(u"Points", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Points", leaderboardEntry.primaryScore));
 			// Points:1
 			break;
 		case MonumentRace:
-			entry.Insert<int32_t>(u"Time", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.primaryScore));
 			// Time:1(?)
 			break;
 		case FootRace:
-			entry.Insert<int32_t>(u"Time", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.primaryScore));
 			// Time:1
 			break;
 		case Survival:
-			entry.Insert<int32_t>(u"Points", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Points", leaderboardEntry.primaryScore));
 			// Points:1
-			entry.Insert<int32_t>(u"Time", leaderboardEntry.secondaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.secondaryScore));
 			// Time:1
 			break;
 		case SurvivalNS:
-			entry.Insert<int32_t>(u"Wave", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Wave", leaderboardEntry.primaryScore));
 			// Wave:1
-			entry.Insert<int32_t>(u"Time", leaderboardEntry.secondaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Time", leaderboardEntry.secondaryScore));
 			// Time:1
 			break;
 		case Donations:
-			entry.Insert<int32_t>(u"Score", leaderboardEntry.primaryScore);
+			entry.push_back(new LDFData<int32_t>(u"Score", leaderboardEntry.primaryScore));
 			// Score:1
 			break;
 		case None:
@@ -289,10 +289,6 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 			ILeaderboard::Score oldScoreFlipped{oldScore->secondaryScore, oldScore->primaryScore, oldScore->tertiaryScore};
 			ILeaderboard::Score newScoreFlipped{newScore.secondaryScore, newScore.primaryScore, newScore.tertiaryScore};
 			newHighScore = newScoreFlipped > oldScoreFlipped;
-		} else if (leaderboardType == Leaderboard::Type::Donations) {
-			// Donations just need to go up if updated
-			newHighScore = true;
-			newScore.primaryScore += oldScore->primaryScore;
 		}
 
 		if (newHighScore) {

dGame/LeaderboardManager.h

@@ -70,7 +70,8 @@ public:
 	
 
 private:
-	using LeaderboardEntries = std::vector<LwoNameValue>;
+	using LeaderboardEntry = std::vector<LDFBaseData*>;
+	using LeaderboardEntries = std::vector<LeaderboardEntry>;
 
 	LeaderboardEntries entries;
 	LWOOBJID relatedPlayer;
@@ -80,7 +81,7 @@ private:
 	bool weekly;
 	uint32_t numResults;
 public:
-	LwoNameValue& PushBackEntry() {
+	LeaderboardEntry& PushBackEntry() {
 		return entries.emplace_back();
 	}
 

dGame/TeamManager.cpp

@@ -9,16 +9,6 @@ Team::Team() {
 	lootOption = Game::config->GetValue("default_team_loot") == "0" ? 0 : 1;
 }
 
-LWOOBJID Team::GetNextLootOwner() {
-	lootRound++;
-
-	if (lootRound >= members.size()) {
-		lootRound = 0;
-	}
-
-	return members[lootRound];
-}
-
 TeamManager::TeamManager() {
 }
 

dGame/TeamManager.h

@@ -4,8 +4,6 @@
 
 struct Team {
 	Team();
-
-	LWOOBJID GetNextLootOwner();
 	LWOOBJID teamID = LWOOBJID_EMPTY;
 	char lootOption = 0;
 	std::vector<LWOOBJID> members{};

dGame/TradingManager.cpp

@@ -10,11 +10,6 @@
 #include "CharacterComponent.h"
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
-#include <ranges>
-
-namespace {
-	std::unique_ptr<Trade> g_EmptyTrade;
-}
 
 TradingManager* TradingManager::m_Address = nullptr;
 
@@ -238,38 +233,55 @@ void Trade::SendUpdateToOther(LWOOBJID participant) {
 	GameMessages::SendServerTradeUpdate(other->GetObjectID(), coins, items, other->GetSystemAddress());
 }
 
-const std::unique_ptr<Trade>& TradingManager::GetTrade(LWOOBJID tradeId) const {
+TradingManager::TradingManager() {
+}
+
+TradingManager::~TradingManager() {
+	for (const auto& pair : trades) {
+		delete pair.second;
+	}
+
+	trades.clear();
+}
+
+Trade* TradingManager::GetTrade(LWOOBJID tradeId) const {
 	const auto& pair = trades.find(tradeId);
 
-	if (pair == trades.end()) return g_EmptyTrade;
+	if (pair == trades.end()) return nullptr;
 
 	return pair->second;
 }
 
-const std::unique_ptr<Trade>& TradingManager::GetPlayerTrade(LWOOBJID playerId) const {
-	for (const auto& trade : trades | std::views::values) {
-		if (trade->IsParticipant(playerId)) {
-			return trade;
+Trade* TradingManager::GetPlayerTrade(LWOOBJID playerId) const {
+	for (const auto& pair : trades) {
+		if (pair.second->IsParticipant(playerId)) {
+			return pair.second;
 		}
 	}
 
-	return g_EmptyTrade;
+	return nullptr;
 }
 
 void TradingManager::CancelTrade(const LWOOBJID canceller, LWOOBJID tradeId, const bool sendCancelMessage) {
-	const auto& trade = GetTrade(tradeId);
+	auto* trade = GetTrade(tradeId);
 
 	if (trade == nullptr) return;
 
 	if (sendCancelMessage) trade->Cancel(canceller);
 
+	delete trade;
+
 	trades.erase(tradeId);
 }
 
-void TradingManager::NewTrade(LWOOBJID participantA, LWOOBJID participantB) {
+Trade* TradingManager::NewTrade(LWOOBJID participantA, LWOOBJID participantB) {
 	const LWOOBJID tradeId = ObjectIDManager::GenerateObjectID();
 
-	trades.insert_or_assign(tradeId, std::make_unique<Trade>(tradeId, participantA, participantB));
+	auto* trade = new Trade(tradeId, participantA, participantB);
+
+	trades[tradeId] = trade;
 
 	LOG("Created new trade between (%llu) <-> (%llu)", participantA, participantB);
+
+	return trade;
 }

dGame/TradingManager.h

@@ -2,16 +2,15 @@
 
 #include "Entity.h"
 
-#include <map>
-#include <memory>
-
-struct TradeItem {
+struct TradeItem
+{
 	LWOOBJID itemId;
 	LOT itemLot;
 	uint32_t itemCount;
 };
 
-class Trade {
+class Trade
+{
 public:
 	explicit Trade(LWOOBJID tradeId, LWOOBJID participantA, LWOOBJID participantB);
 	~Trade();
@@ -51,7 +50,8 @@ private:
 };
 
 
-class TradingManager {
+class TradingManager
+{
 public:
 	static TradingManager* Instance() {
 		if (!m_Address) {
@@ -61,13 +61,16 @@ public:
 		return m_Address;
 	}
 
-	const std::unique_ptr<Trade>& GetTrade(LWOOBJID tradeId) const;
-	const std::unique_ptr<Trade>& GetPlayerTrade(LWOOBJID playerId) const;
+	explicit TradingManager();
+	~TradingManager();
+
+	Trade* GetTrade(LWOOBJID tradeId) const;
+	Trade* GetPlayerTrade(LWOOBJID playerId) const;
 	void CancelTrade(const LWOOBJID canceller, LWOOBJID tradeId, const bool sendCancelMessage = true);
-	void NewTrade(LWOOBJID participantA, LWOOBJID participantB);
+	Trade* NewTrade(LWOOBJID participantA, LWOOBJID participantB);
 
 private:
 	static TradingManager* m_Address; //For singleton method
 
-	std::unordered_map<LWOOBJID, std::unique_ptr<Trade>> trades;
+	std::unordered_map<LWOOBJID, Trade*> trades;
 };

dGame/User.h

@@ -31,7 +31,7 @@ public:
 	std::string& GetSessionKey() { return m_SessionKey; }
 	SystemAddress& GetSystemAddress() { return m_SystemAddress; }
 
-	eGameMasterLevel GetMaxGMLevel() const { return m_MaxGMLevel; }
+	eGameMasterLevel GetMaxGMLevel() { return m_MaxGMLevel; }
 	uint32_t GetLastCharID() { return m_LastCharID; }
 	void SetLastCharID(uint32_t newCharID) { m_LastCharID = newCharID; }
 

dGame/UserManager.cpp

@@ -30,7 +30,6 @@
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
 #include "CharacterComponent.h"
-#include "dConfig.h"
 #include "eCharacterVersion.h"
 
 UserManager* UserManager::m_Address = nullptr;
@@ -93,23 +92,6 @@ void UserManager::Initialize() {
 		StripCR(line);
 		m_PreapprovedNames.push_back(line);
 	}
-
-	// Initialize cached config values and register a handler to update them on config reload
-	// This avoids repeated lookups into dConfig at runtime.
-	if (Game::config) {
-		m_MuteAutoRejectNames = (Game::config->GetValue("mute_auto_reject_names") == "1");
-		m_MuteRestrictTrade = (Game::config->GetValue("mute_restrict_trade") == "1");
-		m_MuteRestrictMail = (Game::config->GetValue("mute_restrict_mail") == "1");
-
-		Game::config->AddConfigHandler([this]() {
-			this->m_MuteAutoRejectNames = (Game::config->GetValue("mute_auto_reject_names") == "1");
-			this->m_MuteRestrictTrade = (Game::config->GetValue("mute_restrict_trade") == "1");
-			this->m_MuteRestrictMail = (Game::config->GetValue("mute_restrict_mail") == "1");
-		});
-	}
-	else {
-		LOG("Warning: dConfig not initialized before UserManager. Cached config values will not be available.");
-	}
 }
 
 UserManager::~UserManager() {
@@ -319,9 +301,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 	inStream.Read(eyes);
 	inStream.Read(mouth);
 
-	const bool autoRejectNames = this->GetMuteAutoRejectNames() && u->GetIsMuted();
-
-	const auto name = autoRejectNames ? "" : LUWStringName.GetAsString();
+	const auto name = LUWStringName.GetAsString();
 	std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex);
 
 	LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
@@ -339,10 +319,6 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 		return;
 	}
 
-	if (autoRejectNames) {
-		LOG("AccountID: %i is muted, forcing use of predefined name", u->GetAccountID());
-	}
-
 	if (name.empty()) {
 		LOG("AccountID: %i is creating a character with predefined name: %s", u->GetAccountID(), predefinedName.c_str());
 	} else {
@@ -393,7 +369,6 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	//Check to see if our name was pre-approved:
 	bool nameOk = IsNamePreapproved(name);
-
 	if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
 
 	// If predefined name is invalid, change it to be their object id
@@ -473,10 +448,9 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	LUWString LUWStringName;
 	inStream.Read(LUWStringName);
-	auto newName = LUWStringName.GetAsString();
+	const auto newName = LUWStringName.GetAsString();
 
 	Character* character = nullptr;
-	const bool autoRejectNames = this->GetMuteAutoRejectNames() && u->GetIsMuted();
 
 	//Check if this user has this character:
 	bool ownsCharacter = CheatDetection::VerifyLwoobjidIsSender(
@@ -497,30 +471,13 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	if (!ownsCharacter || !character) {
 		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
 	} else if (ownsCharacter && character) {
-		if (autoRejectNames) {
-			// Create a random preapproved name (fallback to default if none available)
-			if (!m_FirstNames.empty() && !m_MiddleNames.empty() && !m_LastNames.empty()) {
-				std::string firstName = GeneralUtils::GetRandomElement(m_FirstNames);
-				std::string middleName = GeneralUtils::GetRandomElement(m_MiddleNames);
-				std::string lastName = GeneralUtils::GetRandomElement(m_LastNames);
-				newName = firstName + middleName + lastName;
-			} else {
-				newName = "character" + std::to_string(objectID);
-			}
-		}
-
 		if (newName == character->GetName()) {
 			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
 			return;
 		}
 
-		if (!Database::Get()->IsNameInUse(newName)) {
-			if (autoRejectNames) {
-				Database::Get()->SetCharacterName(objectID, newName);
-				LOG("Character %s auto-renamed to preapproved name %s due to mute", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
-				UserManager::RequestCharacterList(sysAddr);
-			} else if (IsNamePreapproved(newName)) {
+		if (!Database::Get()->GetCharacterInfo(newName)) {
+			if (IsNamePreapproved(newName)) {
 				Database::Get()->SetCharacterName(objectID, newName);
 				LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
 				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);

dGame/UserManager.h

@@ -41,11 +41,6 @@ public:
 
 	size_t GetUserCount() const { return m_Users.size(); }
 
-	// Access cached config values
-	bool GetMuteAutoRejectNames() const { return m_MuteAutoRejectNames; }
-	bool GetMuteRestrictTrade() const { return m_MuteRestrictTrade; }
-	bool GetMuteRestrictMail() const { return m_MuteRestrictMail; }
-
 private:
 	static UserManager* m_Address; //Singleton
 	std::map<SystemAddress, User*> m_Users;
@@ -55,11 +50,6 @@ private:
 	std::vector<std::string> m_MiddleNames;
 	std::vector<std::string> m_LastNames;
 	std::vector<std::string> m_PreapprovedNames;
-
-	// Cached config values that can change on config reload
-	bool m_MuteAutoRejectNames = false;
-	bool m_MuteRestrictTrade = false;
-	bool m_MuteRestrictMail = false;
 };
 
 #endif // USERMANAGER_H

dGame/dBehaviors/AirMovementBehavior.cpp

@@ -30,21 +30,6 @@ void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream& bitS
 		return;
 	}
 
-	// So a player can't send an arbitrary behaviorID in a modified client and cast any behavior on any air behavior
-	Behavior* toSync = nullptr;
-	if (m_GroundAction->GetBehaviorID() == behaviorId) {
-		toSync = m_GroundAction;
-	} else if (m_HitAction->GetBehaviorID() == behaviorId) {
-		toSync = m_HitAction;
-	} else if (m_HitActionEnemy->GetBehaviorID() == behaviorId) {
-		toSync = m_HitActionEnemy;
-	} else if (m_TimeoutAction->GetBehaviorID() == behaviorId) {
-		toSync = m_TimeoutAction;
-	} else {
-		LOG("Invalid Air Movement Behavior sync for behaviorID %i on behavior %i", behaviorId, m_behaviorId);
-		return;
-	}
-
 	LWOOBJID target{};
 
 	if (!bitStream.Read(target)) {
@@ -52,17 +37,15 @@ void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream& bitS
 		return;
 	}
 
+	auto* behavior = CreateBehavior(behaviorId);
+
 	if (Game::entityManager->GetEntity(target) != nullptr) {
 		branch.target = target;
 	}
 
-	toSync->Handle(context, bitStream, branch);
+	behavior->Handle(context, bitStream, branch);
 }
 
 void AirMovementBehavior::Load() {
-	m_Timeout = (GetFloat("timeout_ms") / 1000.0f);
-	m_GroundAction = GetAction("ground_action");
-	m_HitAction = GetAction("hit_action");
-	m_HitActionEnemy = GetAction("hit_action_enemy");
-	m_TimeoutAction = GetAction("timeout_action");
+	this->m_Timeout = (GetFloat("timeout_ms") / 1000.0f);
 }

dGame/dBehaviors/AirMovementBehavior.h

@@ -15,9 +15,4 @@ public:
 	void Load() override;
 private:
 	float m_Timeout;
-	
-	Behavior* m_GroundAction{};
-	Behavior* m_HitAction{};
-	Behavior* m_HitActionEnemy{};
-	Behavior* m_TimeoutAction{};
 };

dGame/dBehaviors/AndBehavior.cpp

@@ -10,9 +10,7 @@ void AndBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream,
 }
 
 void AndBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
-	LOG_ENTRY;
 	for (auto* behavior : this->m_behaviors) {
-		LOG("%i calculating %i", m_behaviorId, behavior->GetBehaviorID());
 		behavior->Calculate(context, bitStream, branch);
 	}
 }

dGame/dBehaviors/AreaOfEffectBehavior.cpp

@@ -42,7 +42,6 @@ void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream& b
 		LWOOBJID target{};
 		if (!bitStream.Read(target)) {
 			LOG("failed to read in target %i from bitStream, aborting target Handle!", i);
-			continue;
 		};
 		targets.push_back(target);
 	}

dGame/dBehaviors/BasicAttackBehavior.cpp

@@ -68,7 +68,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	}
 
 	if (isBlocked) {
-		destroyableComponent->SetAttacksToBlock(std::max<int32_t>(static_cast<int32_t>(destroyableComponent->GetAttacksToBlock() - 1), 0));
+		destroyableComponent->SetAttacksToBlock(std::min(destroyableComponent->GetAttacksToBlock() - 1, 0U));
 		Game::entityManager->SerializeEntity(targetEntity);
 		this->m_OnFailBlocked->Handle(context, bitStream, branch);
 		return;
@@ -103,10 +103,9 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 			return;
 		}
 
-		uint64_t totalDamageDealt = armorDamageDealt + healthDamageDealt;
+		uint32_t totalDamageDealt = armorDamageDealt + healthDamageDealt;
 
 		// A value that's too large may be a cheating attempt, so we set it to MIN
-		// Can't overflow here either because should we somehow get to a 64 bit number it'll be clamped to a sane value.
 		if (totalDamageDealt > this->m_MaxDamage) {
 			totalDamageDealt = this->m_MinDamage;
 		}

dGame/dBehaviors/Behavior.h

@@ -95,6 +95,4 @@ public:
 
 	Behavior& operator=(const Behavior& other) = default;
 	Behavior& operator=(Behavior&& other) = default;
-
-	uint32_t GetBehaviorID() const { return m_behaviorId; }
 };

dGame/dBehaviors/BlockBehavior.cpp

@@ -48,13 +48,15 @@ void BlockBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branc
 		return;
 	}
 
-	auto* const destroyableComponent = entity->GetComponent<DestroyableComponent>();
+	auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
 
-	if (destroyableComponent) {
-		// ??? what is going on here?
-		destroyableComponent->SetAttacksToBlock(this->m_numAttacksCanBlock);
-		destroyableComponent->SetAttacksToBlock(0);
+	destroyableComponent->SetAttacksToBlock(this->m_numAttacksCanBlock);
+
+	if (destroyableComponent == nullptr) {
+		return;
 	}
+
+	destroyableComponent->SetAttacksToBlock(0);
 }
 
 void BlockBehavior::Timer(BehaviorContext* context, BehaviorBranchContext branch, LWOOBJID second) {

dGame/dBehaviors/ChainBehavior.cpp

@@ -11,11 +11,6 @@ void ChainBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStrea
 		return;
 	}
 
-	if (chainIndex == 0) {
-		LOG("Received invalid chain index of 0 for behavior %i.", m_behaviorId);
-		return;
-	}
-
 	chainIndex--;
 
 	if (chainIndex < this->m_behaviors.size()) {

dGame/dBehaviors/JetPackBehavior.cpp

@@ -7,7 +7,6 @@
 
 void JetPackBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bit_stream, const BehaviorBranchContext branch) {
 	auto* entity = Game::entityManager->GetEntity(branch.target);
-	if (!entity) return;
 
 	GameMessages::SendSetJetPackMode(entity, true, this->m_BypassChecks, this->m_EnableHover, this->m_effectId, this->m_Airspeed, this->m_MaxAirspeed, this->m_VerticalVelocity, this->m_WarningEffectID);
 
@@ -22,7 +21,6 @@ void JetPackBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bit_st
 
 void JetPackBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branch) {
 	auto* entity = Game::entityManager->GetEntity(branch.target);
-	if (!entity) return;
 
 	GameMessages::SendSetJetPackMode(entity, false);
 

dGame/dBehaviors/NpcCombatSkillBehavior.cpp

@@ -5,40 +5,20 @@
 
 void NpcCombatSkillBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bit_stream, BehaviorBranchContext branch) {
 	context->skillTime = this->m_npcSkillTime;
-	const auto* const targetEntity = Game::entityManager->GetEntity(branch.target);
-	const auto* const sourceEntity = Game::entityManager->GetEntity(context->caster);
 
-	bool cast = true;
-	// Check that the target is within the cast range
-	if (targetEntity && sourceEntity && this->m_maxRange != 0.0f) {
-		const auto targetPos = targetEntity->GetPosition();
-		const auto sourcePos = sourceEntity->GetPosition();
-		const auto distance = NiPoint3::DistanceSquared(targetPos, sourcePos);
-		cast = distance >= this->m_minRange && distance <= this->m_maxRange;
-	}
-
-	if (cast) {
-		for (auto* behavior : this->m_behaviors) {
-			behavior->Calculate(context, bit_stream, branch);
-		}
-	} else {
-		// We failed to find a valid target, do not continue the behavior
-		context->foundTarget = false;
+	for (auto* behavior : this->m_behaviors) {
+		behavior->Calculate(context, bit_stream, branch);
 	}
 }
 
 void NpcCombatSkillBehavior::Load() {
 	this->m_npcSkillTime = GetFloat("npc skill time");
-	this->m_minRange = GetFloat("min range") * 0.9f; // Make the min and max 10% smaller to account for server/client position disagreements
-	this->m_minRange *= this->m_minRange;
-	this->m_maxRange = GetFloat("max range") * 0.9f; // Make the min and max 10% smaller to account for server/client position disagreements
-	this->m_maxRange *= this->m_maxRange;
 
 	const auto parameters = GetParameterNames();
 
-	for (const auto& [parameter, value] : parameters) {
-		if (parameter.rfind("behavior", 0) == 0) {
-			auto* action = GetAction(value);
+	for (const auto& parameter : parameters) {
+		if (parameter.first.rfind("behavior", 0) == 0) {
+			auto* action = GetAction(parameter.second);
 
 			this->m_behaviors.push_back(action);
 		}

dGame/dBehaviors/NpcCombatSkillBehavior.h

@@ -8,9 +8,6 @@ public:
 
 	float m_npcSkillTime;
 
-	float m_maxRange{};
-	float m_minRange{};
-
 	/*
 	 * Inherited
 	 */

dGame/dBehaviors/SwitchMultipleBehavior.cpp

@@ -17,11 +17,6 @@ void SwitchMultipleBehavior::Handle(BehaviorContext* context, RakNet::BitStream&
 		return;
 	};
 
-	if (m_behaviors.empty()) {
-		LOG("No behaviors were loaded for %i, aborting call.", m_behaviorId);
-		return;
-	}
-
 	uint32_t trigger = 0;
 
 	for (unsigned int i = 0; i < this->m_behaviors.size(); i++) {

dGame/dBehaviors/TacArcBehavior.cpp

@@ -114,13 +114,15 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitS
 	context->FilterTargets(validTargets, this->m_ignoreFactionList, this->m_includeFactionList, this->m_targetSelf, this->m_targetEnemy, this->m_targetFriend, this->m_targetTeam);
 
 	for (auto validTarget : validTargets) {
+		if (targets.size() >= this->m_maxTargets) break;
 		if (std::find(targets.begin(), targets.end(), validTarget) != targets.end()) continue;
 		if (validTarget->GetIsDead()) continue;
 
 		const auto targetPos = validTarget->GetPosition();
 
-		// make sure we aren't too high or low in comparison to the target
-		if (targetPos.y > (reference.y + m_upperBound) || targetPos.y < (reference.y + m_lowerBound))
+		// make sure we aren't too high or low in comparison to the targer
+		const auto heightDifference = std::abs(reference.y - targetPos.y);
+		if (targetPos.y > reference.y && heightDifference > this->m_upperBound || targetPos.y < reference.y && heightDifference > this->m_lowerBound)
 			continue;
 
 		const auto forward = QuatUtils::Forward(self->GetRotation());
@@ -145,28 +147,13 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitS
 		}
 	}
 
-	std::sort(targets.begin(), targets.end(), [this, reference, combatAi](Entity* a, Entity* b) {
+	std::sort(targets.begin(), targets.end(), [reference](Entity* a, Entity* b) {
 		const auto aDistance = Vector3::DistanceSquared(reference, a->GetPosition());
 		const auto bDistance = Vector3::DistanceSquared(reference, b->GetPosition());
 
-		return aDistance < bDistance;
+		return aDistance > bDistance;
 		});
 
-
-	if (m_useAttackPriority) {
-		// this should be using the attack priority column on the destroyable component
-		// We want targets with no threat level to remain the same order as above
-		// std::stable_sort(targets.begin(), targets.end(), [combatAi](Entity* a, Entity* b) {
-		// 	const auto aThreat = combatAi->GetThreat(a->GetObjectID());
-		// 	const auto bThreat = combatAi->GetThreat(b->GetObjectID());
-
-		// 	If enabled for this behavior, prioritize threat over distance
-		// 	return aThreat > bThreat;
-		// 	});
-	}
-
-	// After we've sorted and found our closest targets, size the vector down in case there are too many
-	if (m_maxTargets > 0 && targets.size() > m_maxTargets) targets.resize(m_maxTargets);
 	const auto hit = !targets.empty();
 	bitStream.Write(hit);
 
@@ -207,13 +194,9 @@ void TacArcBehavior::Load() {
 		GetFloat("offset_y", 0.0f),
 		GetFloat("offset_z", 0.0f)
 	);
-	// https://explorer.lu/skills/behaviors/6212/6203 HACK: i cant figure out why the dragon fire wall doesnt work with the offset, probably has to be fixed with the near/far height parameters
-	if (m_behaviorId == 6203) {
-		this->m_offset = NiPoint3Constant::ZERO;
-	}
 	this->m_method = GetInt("method", 1);
-	this->m_upperBound = GetFloat("upper_bound", 4.4f);
-	this->m_lowerBound = GetFloat("lower_bound", 0.4f) - 5.0f; // Makes it so players and objects can still be targetted when slightly below the caster.  FIXME: use bounding spheres at some point
+	this->m_upperBound = std::abs(GetFloat("upper_bound", 4.4f));
+	this->m_lowerBound = std::abs(GetFloat("lower_bound", 0.4f));
 	this->m_usePickedTarget = GetBoolean("use_picked_target", false);
 	this->m_useTargetPostion = GetBoolean("use_target_position", false);
 	this->m_checkEnv = GetBoolean("check_env", false);

dGame/dBehaviors/VerifyBehavior.cpp

@@ -25,7 +25,7 @@ void VerifyBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitS
 
 		const auto distance = Vector3::DistanceSquared(self->GetPosition(), entity->GetPosition());
 
-		if (distance > this->m_range) {
+		if (distance > this->m_range * this->m_range) {
 			success = false;
 		}
 	} else if (this->m_blockCheck) {
@@ -57,5 +57,4 @@ void VerifyBehavior::Load() {
 	this->m_action = GetAction("action");
 
 	this->m_range = GetFloat("range");
-	this->m_range = this->m_range * this->m_range * 0.9f; // Range checks are slightly smaller than the actual range to account for client/server discrepancies
 }

dGame/dComponents/ActivityComponent.cpp

@@ -22,7 +22,6 @@
 #include "eMatchUpdate.h"
 #include "ServiceType.h"
 #include "MessageType/Chat.h"
-#include "ObjectIDManager.h"
 
 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@@ -30,14 +29,10 @@
 #include "LeaderboardManager.h"
 #include "CharacterComponent.h"
 #include "Amf3.h"
-#include <ranges>
-
-namespace {
-	const ActivityInstance g_EmptyInstance{ nullptr, CDActivities{} };
-}
 
 ActivityComponent::ActivityComponent(Entity* parent, int32_t componentID) : Component(parent, componentID) {
-	RegisterMsg(&ActivityComponent::OnGetObjectReportInfo);
+	using namespace GameMessages;
+	RegisterMsg<GetObjectReportInfo>(this, &ActivityComponent::OnGetObjectReportInfo);
 	/*
 	* This is precisely what the client does functionally
 	* Use the component id as the default activity id and load its data from the database
@@ -50,6 +45,33 @@ ActivityComponent::ActivityComponent(Entity* parent, int32_t componentID) : Comp
 		m_ActivityID = parent->GetVar<int32_t>(u"activityID");
 		LoadActivityData(m_ActivityID);
 	}
+
+	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
+
+	if (destroyableComponent) {
+		// First lookup the loot matrix id for this component id.
+		CDActivityRewardsTable* activityRewardsTable = CDClientManager::GetTable<CDActivityRewardsTable>();
+		std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) {return (entry.LootMatrixIndex == destroyableComponent->GetLootMatrixID()); });
+
+		uint32_t startingLMI = 0;
+
+		// If we have one, set the starting loot matrix id to that.
+		if (activityRewards.size() > 0) {
+			startingLMI = activityRewards[0].LootMatrixIndex;
+		}
+
+		if (startingLMI > 0) {
+			// We may have more than 1 loot matrix index to use depending ont the size of the team that is looting the activity.
+			// So this logic will get the rest of the loot matrix indices for this activity.
+
+			std::vector<CDActivityRewards> objectTemplateActivities = activityRewardsTable->Query([=](CDActivityRewards entry) {return (activityRewards[0].objectTemplate == entry.objectTemplate); });
+			for (const auto& item : objectTemplateActivities) {
+				if (item.activityRating > 0 && item.activityRating < 5) {
+					m_ActivityLootMatrices.insert({ item.activityRating, item.LootMatrixIndex });
+				}
+			}
+		}
+	}
 }
 void ActivityComponent::LoadActivityData(const int32_t activityId) {
 	CDActivitiesTable* activitiesTable = CDClientManager::GetTable<CDActivitiesTable>();
@@ -77,9 +99,9 @@ void ActivityComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsIniti
 	if (m_DirtyActivityInfo) {
 		outBitStream.Write<uint32_t>(m_ActivityPlayers.size());
 		if (!m_ActivityPlayers.empty()) {
-			for (const auto& [playerID, values] : m_ActivityPlayers) {
-				outBitStream.Write<LWOOBJID>(playerID);
-				for (const auto& activityValue : values) {
+			for (const auto& activityPlayer : m_ActivityPlayers) {
+				outBitStream.Write<LWOOBJID>(activityPlayer->playerID);
+				for (const auto& activityValue : activityPlayer->values) {
 					outBitStream.Write<float_t>(activityValue);
 				}
 			}
@@ -117,81 +139,78 @@ void ActivityComponent::PlayerJoin(Entity* player) {
 	if (HasLobby()) {
 		PlayerJoinLobby(player);
 	} else if (!IsPlayedBy(player)) {
-		NewInstance().AddParticipant(player);
+		auto* instance = NewInstance();
+		instance->AddParticipant(player);
 	}
 }
 
 void ActivityComponent::PlayerJoinLobby(Entity* player) {
 	if (!m_Parent->HasComponent(eReplicaComponentType::QUICK_BUILD))
 		GameMessages::SendMatchResponse(player, player->GetSystemAddress(), 0); // tell the client they joined a lobby
-	LobbyPlayer newLobbyPlayer{};
-	newLobbyPlayer.entityID = player->GetObjectID();
-	LWOOBJID playerLobbyID = LWOOBJID_EMPTY;
+	LobbyPlayer* newLobbyPlayer = new LobbyPlayer();
+	newLobbyPlayer->entityID = player->GetObjectID();
+	Lobby* playerLobby = nullptr;
 
 	auto* character = player->GetCharacter();
 	if (character != nullptr)
 		character->SetLastNonInstanceZoneID(Game::zoneManager->GetZone()->GetWorldID());
 
-	for (auto& [lobbyID, lobby] : m_Queue) {
-		if (lobby.players.size() < m_ActivityInfo.maxTeamSize || m_ActivityInfo.maxTeamSize == 1 && lobby.players.size() < m_ActivityInfo.maxTeams) {
+	for (Lobby* lobby : m_Queue) {
+		if (lobby->players.size() < m_ActivityInfo.maxTeamSize || m_ActivityInfo.maxTeamSize == 1 && lobby->players.size() < m_ActivityInfo.maxTeams) {
 			// If an empty slot in an existing lobby is found
-			lobby.players.push_back(newLobbyPlayer);
-			playerLobbyID = lobbyID;
+			lobby->players.push_back(newLobbyPlayer);
+			playerLobby = lobby;
 
 			// Update the joining player on players already in the lobby, and update players already in the lobby on the joining player
-			LDFData<LWOOBJID> playerLDF("player", player->GetObjectID());
-			LDFData<std::string> playerName("playerName", player->GetCharacter()->GetName());
-			std::string matchUpdateJoined = playerLDF.GetString() + "\n" + playerName.GetString();
-			for (const auto& joinedPlayer : lobby.players) {
-				auto* const entity = joinedPlayer.GetEntity();
+			std::string matchUpdateJoined = "player=9:" + std::to_string(player->GetObjectID()) + "\nplayerName=0:" + player->GetCharacter()->GetName();
+			for (LobbyPlayer* joinedPlayer : lobby->players) {
+				auto* entity = joinedPlayer->GetEntity();
 
 				if (entity == nullptr) {
 					continue;
 				}
 
-				LDFData<LWOOBJID> entityLDF("player", entity->GetObjectID());
-				LDFData<std::string> entityName("playerName", entity->GetCharacter()->GetName());
-				std::string matchUpdate = entityLDF.GetString() + "\n" + entityName.GetString();
+				std::string matchUpdate = "player=9:" + std::to_string(entity->GetObjectID()) + "\nplayerName=0:" + entity->GetCharacter()->GetName();
 				GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchUpdate, eMatchUpdate::PLAYER_ADDED);
-				PlayerReady(entity, joinedPlayer.ready);
+				PlayerReady(entity, joinedPlayer->ready);
 				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateJoined, eMatchUpdate::PLAYER_ADDED);
 			}
-			break;
 		}
 	}
 
-	if (playerLobbyID == LWOOBJID_EMPTY) {
+	if (!playerLobby) {
 		// If all lobbies are full
-		playerLobbyID = ObjectIDManager::GenerateObjectID();
-		auto& newLobby = m_Queue[playerLobbyID];
-		newLobby.players.push_back(newLobbyPlayer);
-		newLobby.timer = m_ActivityInfo.waitTime / 1000;
+		playerLobby = new Lobby();
+		playerLobby->players.push_back(newLobbyPlayer);
+		playerLobby->timer = m_ActivityInfo.waitTime / 1000;
+		m_Queue.push_back(playerLobby);
 	}
-	const auto& lobby = m_Queue[playerLobbyID];
 
-	if (m_ActivityInfo.maxTeamSize != 1 && lobby.players.size() >= m_ActivityInfo.minTeamSize || m_ActivityInfo.maxTeamSize == 1 && lobby.players.size() >= m_ActivityInfo.minTeams) {
+	if (m_ActivityInfo.maxTeamSize != 1 && playerLobby->players.size() >= m_ActivityInfo.minTeamSize || m_ActivityInfo.maxTeamSize == 1 && playerLobby->players.size() >= m_ActivityInfo.minTeams) {
 		// Update the joining player on the match timer
-		LDFData<float> matchTimer("time", lobby.timer);
-		GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimer.GetString(), eMatchUpdate::PHASE_WAIT_READY);
+		std::string matchTimerUpdate = "time=3:" + std::to_string(playerLobby->timer);
+		GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
 	}
 }
 
 void ActivityComponent::PlayerLeave(LWOOBJID playerID) {
+
 	// Removes the player from a lobby and notifies the others, not applicable for non-lobby instances
-	for (auto& lobby : m_Queue | std::views::values) {
-		for (int i = 0; i < lobby.players.size(); i++) {
-			const auto& player = lobby.players[i];
-			if (player.entityID == playerID) {
-				LDFData<LWOOBJID> matchUpdateLeft("player", playerID);
-				for (const auto& lobbyPlayer : lobby.players) {
-					auto* const entity = lobbyPlayer.GetEntity();
+	for (Lobby* lobby : m_Queue) {
+		for (int i = 0; i < lobby->players.size(); ++i) {
+			if (lobby->players[i]->entityID == playerID) {
+				std::string matchUpdateLeft = "player=9:" + std::to_string(playerID);
+				for (LobbyPlayer* lobbyPlayer : lobby->players) {
+					auto* entity = lobbyPlayer->GetEntity();
 					if (entity == nullptr)
 						continue;
 
-					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft.GetString(), eMatchUpdate::PLAYER_REMOVED);
+					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft, eMatchUpdate::PLAYER_REMOVED);
 				}
 
-				lobby.players.erase(lobby.players.begin() + i);
+				delete lobby->players[i];
+				lobby->players[i] = nullptr;
+				lobby->players.erase(lobby->players.begin() + i);
 
 				return;
 			}
@@ -200,79 +219,85 @@ void ActivityComponent::PlayerLeave(LWOOBJID playerID) {
 }
 
 void ActivityComponent::Update(float deltaTime) {
-	std::vector<LWOOBJID> lobbiesToRemove{};
+	std::vector<Lobby*> lobbiesToRemove{};
 	// Ticks all the lobbies, not applicable for non-instance activities
-	for (auto& [lobbyID, lobby] : m_Queue) {
-		for (const auto& player : lobby.players) {
-			const auto* const entity = player.GetEntity();
+	for (Lobby* lobby : m_Queue) {
+		for (LobbyPlayer* player : lobby->players) {
+			auto* entity = player->GetEntity();
 			if (entity == nullptr) {
-				PlayerLeave(player.entityID);
+				PlayerLeave(player->entityID);
 				return;
 			}
 		}
 
-		if (lobby.players.empty()) {
-			lobbiesToRemove.push_back(lobbyID);
+		if (lobby->players.empty()) {
+			lobbiesToRemove.push_back(lobby);
 			continue;
 		}
 
 		// Update the match time for all players
-		if (m_ActivityInfo.maxTeamSize != 1 && lobby.players.size() >= m_ActivityInfo.minTeamSize
-			|| m_ActivityInfo.maxTeamSize == 1 && lobby.players.size() >= m_ActivityInfo.minTeams) {
-			if (lobby.timer == m_ActivityInfo.waitTime / 1000) {
-				for (const auto& joinedPlayer : lobby.players) {
-					auto* const entity = joinedPlayer.GetEntity();
+		if (m_ActivityInfo.maxTeamSize != 1 && lobby->players.size() >= m_ActivityInfo.minTeamSize
+			|| m_ActivityInfo.maxTeamSize == 1 && lobby->players.size() >= m_ActivityInfo.minTeams) {
+			if (lobby->timer == m_ActivityInfo.waitTime / 1000) {
+				for (LobbyPlayer* joinedPlayer : lobby->players) {
+					auto* entity = joinedPlayer->GetEntity();
 
 					if (entity == nullptr)
 						continue;
 
-					LDFData<float> matchTimerUpdate("time", lobby.timer);
-					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate.GetString(), eMatchUpdate::PHASE_WAIT_READY);
+					std::string matchTimerUpdate = "time=3:" + std::to_string(lobby->timer);
+					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
 				}
 			}
 
-			lobby.timer -= deltaTime;
+			lobby->timer -= deltaTime;
 		}
 
 		bool lobbyReady = true;
-		for (const auto& player : lobby.players) {
-			if (player.ready) continue;
+		for (LobbyPlayer* player : lobby->players) {
+			if (player->ready) continue;
 			lobbyReady = false;
 		}
 
 		// If everyone's ready, jump the timer
-		if (lobbyReady && lobby.timer > m_ActivityInfo.startDelay / 1000) {
-			lobby.timer = m_ActivityInfo.startDelay / 1000;
+		if (lobbyReady && lobby->timer > m_ActivityInfo.startDelay / 1000) {
+			lobby->timer = m_ActivityInfo.startDelay / 1000;
 
 			// Update players in lobby on switch to start delay
-			LDFData<float> matchTimerUpdate("time", lobby.timer);
-			for (const auto& player : lobby.players) {
-				auto* const entity = player.GetEntity();
+			std::string matchTimerUpdate = "time=3:" + std::to_string(lobby->timer);
+			for (LobbyPlayer* player : lobby->players) {
+				auto* entity = player->GetEntity();
 
 				if (entity == nullptr)
 					continue;
 
-				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate.GetString(), eMatchUpdate::PHASE_WAIT_START);
+				GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_START);
 			}
 		}
 
 		// The timer has elapsed, start the instance
-		if (lobby.timer <= 0.0f) {
+		if (lobby->timer <= 0.0f) {
 			LOG("Setting up instance.");
-			auto& instance = NewInstance();
-			LoadPlayersIntoInstance(instance, lobby.players);
-			instance.StartZone();
-			lobbiesToRemove.push_back(lobbyID);
+			ActivityInstance* instance = NewInstance();
+			LoadPlayersIntoInstance(instance, lobby->players);
+			instance->StartZone();
+			lobbiesToRemove.push_back(lobby);
 		}
 	}
 
-	for (const auto id : lobbiesToRemove) {
-		RemoveLobby(id);
+	while (!lobbiesToRemove.empty()) {
+		RemoveLobby(lobbiesToRemove.front());
+		lobbiesToRemove.erase(lobbiesToRemove.begin());
 	}
 }
 
-void ActivityComponent::RemoveLobby(const LWOOBJID lobbyID) {
-	if (m_Queue.contains(lobbyID)) m_Queue.erase(lobbyID);
+void ActivityComponent::RemoveLobby(Lobby* lobby) {
+	for (int i = 0; i < m_Queue.size(); ++i) {
+		if (m_Queue[i] == lobby) {
+			m_Queue.erase(m_Queue.begin() + i);
+			return;
+		}
+	}
 }
 
 bool ActivityComponent::HasLobby() const {
@@ -281,9 +306,9 @@ bool ActivityComponent::HasLobby() const {
 }
 
 bool ActivityComponent::PlayerIsInQueue(Entity* player) {
-	for (const auto& lobby : m_Queue | std::views::values) {
-		for (const auto& lobbyPlayer : lobby.players) {
-			if (player->GetObjectID() == lobbyPlayer.entityID) return true;
+	for (Lobby* lobby : m_Queue) {
+		for (LobbyPlayer* lobbyPlayer : lobby->players) {
+			if (player->GetObjectID() == lobbyPlayer->entityID) return true;
 		}
 	}
 
@@ -291,8 +316,8 @@ bool ActivityComponent::PlayerIsInQueue(Entity* player) {
 }
 
 bool ActivityComponent::IsPlayedBy(Entity* player) const {
-	for (const auto& instance : m_Instances) {
-		for (const auto* instancePlayer : instance.GetParticipants()) {
+	for (const auto* instance : this->m_Instances) {
+		for (const auto* instancePlayer : instance->GetParticipants()) {
 			if (instancePlayer != nullptr && instancePlayer->GetObjectID() == player->GetObjectID())
 				return true;
 		}
@@ -302,8 +327,8 @@ bool ActivityComponent::IsPlayedBy(Entity* player) const {
 }
 
 bool ActivityComponent::IsPlayedBy(LWOOBJID playerID) const {
-	for (const auto& instance : m_Instances) {
-		for (const auto* instancePlayer : instance.GetParticipants()) {
+	for (const auto* instance : this->m_Instances) {
+		for (const auto* instancePlayer : instance->GetParticipants()) {
 			if (instancePlayer != nullptr && instancePlayer->GetObjectID() == playerID)
 				return true;
 		}
@@ -327,100 +352,142 @@ bool ActivityComponent::CheckCost(Entity* player) const {
 }
 
 bool ActivityComponent::TakeCost(Entity* player) const {
+
 	auto* inventoryComponent = player->GetComponent<InventoryComponent>();
-	return CheckCost(player) && inventoryComponent && inventoryComponent->RemoveItem(m_ActivityInfo.optionalCostLOT, m_ActivityInfo.optionalCostCount, eInventoryType::ALL);
+	return CheckCost(player) && inventoryComponent->RemoveItem(m_ActivityInfo.optionalCostLOT, m_ActivityInfo.optionalCostCount, eInventoryType::ALL);
 }
 
 void ActivityComponent::PlayerReady(Entity* player, bool bReady) {
-	for (auto& lobby : m_Queue | std::views::values) {
-		for (auto& lobbyPlayer : lobby.players) {
-			if (lobbyPlayer.entityID == player->GetObjectID()) {
+	for (Lobby* lobby : m_Queue) {
+		for (LobbyPlayer* lobbyPlayer : lobby->players) {
+			if (lobbyPlayer->entityID == player->GetObjectID()) {
 
-				lobbyPlayer.ready = bReady;
+				lobbyPlayer->ready = bReady;
 
 				// Update players in lobby on player being ready
-				LDFData<LWOOBJID> matchReadyUpdate("player", player->GetObjectID());
+				std::string matchReadyUpdate = "player=9:" + std::to_string(player->GetObjectID());
 				eMatchUpdate readyStatus = eMatchUpdate::PLAYER_READY;
 				if (!bReady) readyStatus = eMatchUpdate::PLAYER_NOT_READY;
-				for (const auto& otherPlayer : lobby.players) {
-					auto* const entity = otherPlayer.GetEntity();
+				for (LobbyPlayer* otherPlayer : lobby->players) {
+					auto* entity = otherPlayer->GetEntity();
 					if (entity == nullptr)
 						continue;
 
-					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchReadyUpdate.GetString(), readyStatus);
+					GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchReadyUpdate, readyStatus);
 				}
 			}
 		}
 	}
 }
 
-ActivityInstance& ActivityComponent::NewInstance() {
-	m_Instances.push_back(ActivityInstance(m_Parent, m_ActivityInfo));
-	return m_Instances.back();
+ActivityInstance* ActivityComponent::NewInstance() {
+	auto* instance = new ActivityInstance(m_Parent, m_ActivityInfo);
+	m_Instances.push_back(instance);
+	return instance;
 }
 
-void ActivityComponent::LoadPlayersIntoInstance(ActivityInstance& instance, const std::vector<LobbyPlayer>& lobby) const {
-	for (const auto& player : lobby) {
-		auto* const entity = player.GetEntity();
+void ActivityComponent::LoadPlayersIntoInstance(ActivityInstance* instance, const std::vector<LobbyPlayer*>& lobby) const {
+	for (LobbyPlayer* player : lobby) {
+		auto* entity = player->GetEntity();
 		if (entity == nullptr || !CheckCost(entity)) {
 			continue;
 		}
 
-		instance.AddParticipant(entity);
+		instance->AddParticipant(entity);
 	}
 }
 
-const ActivityInstance& ActivityComponent::GetInstance(const LWOOBJID playerID) const {
-	for (const auto& instance : m_Instances) {
-		for (const auto* participant : instance.GetParticipants()) {
+const std::vector<ActivityInstance*>& ActivityComponent::GetInstances() const {
+	return m_Instances;
+}
+
+ActivityInstance* ActivityComponent::GetInstance(const LWOOBJID playerID) {
+	for (const auto* instance : GetInstances()) {
+		for (const auto* participant : instance->GetParticipants()) {
 			if (participant->GetObjectID() == playerID)
-				return instance;
+				return const_cast<ActivityInstance*>(instance);
 		}
 	}
 
-	return g_EmptyInstance;
+	return nullptr;
 }
 
-bool ActivityComponent::PlayerHasActivityData(LWOOBJID playerID) const {
-	return m_ActivityPlayers.contains(playerID);
+void ActivityComponent::ClearInstances() {
+	for (ActivityInstance* instance : m_Instances) {
+		delete instance;
+	}
+	m_Instances.clear();
+}
+
+ActivityPlayer* ActivityComponent::GetActivityPlayerData(LWOOBJID playerID) {
+	for (auto* activityData : m_ActivityPlayers) {
+		if (activityData->playerID == playerID) {
+			return activityData;
+		}
+	}
+
+	return nullptr;
 }
 
 void ActivityComponent::RemoveActivityPlayerData(LWOOBJID playerID) {
-	m_ActivityPlayers.erase(playerID);
-	m_DirtyActivityInfo = true;
+	for (size_t i = 0; i < m_ActivityPlayers.size(); i++) {
+		if (m_ActivityPlayers[i]->playerID == playerID) {
+			delete m_ActivityPlayers[i];
+			m_ActivityPlayers[i] = nullptr;
+
+			m_ActivityPlayers.erase(m_ActivityPlayers.begin() + i);
+			m_DirtyActivityInfo = true;
+			Game::entityManager->SerializeEntity(m_Parent);
+
+			return;
+		}
+	}
 }
 
-float_t ActivityComponent::GetActivityValue(LWOOBJID playerID, uint32_t index) const {
-	float value = -1.0f;
+ActivityPlayer* ActivityComponent::AddActivityPlayerData(LWOOBJID playerID) {
+	auto* data = GetActivityPlayerData(playerID);
+	if (data != nullptr)
+		return data;
 
-	const auto& data = m_ActivityPlayers.find(playerID);
-	if (data != m_ActivityPlayers.cend()) {
-		value = data->second[std::min(index, static_cast<uint32_t>(9))];
+	m_ActivityPlayers.push_back(new ActivityPlayer{ playerID, {} });
+	m_DirtyActivityInfo = true;
+	Game::entityManager->SerializeEntity(m_Parent);
+
+	return GetActivityPlayerData(playerID);
+}
+
+float_t ActivityComponent::GetActivityValue(LWOOBJID playerID, uint32_t index) {
+	auto value = -1.0f;
+
+	auto* data = GetActivityPlayerData(playerID);
+	if (data != nullptr) {
+		value = data->values[std::min(index, static_cast<uint32_t>(9))];
 	}
-	LOG_DEBUG("Player %llu has score %f at index %i", playerID, value, index);
+
 	return value;
 }
 
 void ActivityComponent::SetActivityValue(LWOOBJID playerID, uint32_t index, float_t value) {
-	auto& data = m_ActivityPlayers[playerID];
-	data[std::min(index, static_cast<uint32_t>(9))] = value;
-	LOG_DEBUG("%llu index %i has score of %f", playerID, index, value);
+	auto* data = AddActivityPlayerData(playerID);
+	if (data != nullptr) {
+		data->values[std::min(index, static_cast<uint32_t>(9))] = value;
+	}
 	m_DirtyActivityInfo = true;
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
 void ActivityComponent::PlayerRemove(LWOOBJID playerID) {
-	for (int i = 0; i < m_Instances.size(); i++) {
-		auto& instance = m_Instances[i];
-		auto participants = instance.GetParticipants();
+	for (auto* instance : GetInstances()) {
+		auto participants = instance->GetParticipants();
 		for (const auto* participant : participants) {
 			if (participant != nullptr && participant->GetObjectID() == playerID) {
-				instance.RemoveParticipant(participant);
+				instance->RemoveParticipant(participant);
 				RemoveActivityPlayerData(playerID);
 
 				// If the instance is empty after the delete of the participant, delete the instance too
-				if (instance.GetParticipants().empty()) {
-					m_Instances.erase(m_Instances.begin() + i);
+				if (instance->GetParticipants().empty()) {
+					m_Instances.erase(std::find(m_Instances.begin(), m_Instances.end(), instance));
+					delete instance;
 				}
 				return;
 			}
@@ -551,19 +618,22 @@ Entity* LobbyPlayer::GetEntity() const {
 	return Game::entityManager->GetEntity(entityID);
 }
 
-bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GetObjectReportInfo& reportInfo) {
+bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& reportInfo = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+
 	auto& activityInfo = reportInfo.info->PushDebug("Activity");
 
 	auto& instances = activityInfo.PushDebug("Instances: " + std::to_string(m_Instances.size()));
 	size_t i = 0;
 	for (const auto& activityInstance : m_Instances) {
+		if (!activityInstance) continue;
 		auto& instance = instances.PushDebug("Instance " + std::to_string(i++));
-		instance.PushDebug<AMFIntValue>("Score") = activityInstance.GetScore();
-		instance.PushDebug<AMFIntValue>("Next Zone Clone ID") = activityInstance.GetNextZoneCloneID();
+		instance.PushDebug<AMFIntValue>("Score") = activityInstance->GetScore();
+		instance.PushDebug<AMFIntValue>("Next Zone Clone ID") = activityInstance->GetNextZoneCloneID();
 
 		{
 			auto& activityInfo = instance.PushDebug("Activity Info");
-			const auto& instanceActInfo = activityInstance.GetActivityInfo();
+			const auto& instanceActInfo = activityInstance->GetActivityInfo();
 			activityInfo.PushDebug<AMFIntValue>("ActivityID") = instanceActInfo.ActivityID;
 			activityInfo.PushDebug<AMFIntValue>("locStatus") = instanceActInfo.locStatus;
 			activityInfo.PushDebug<AMFIntValue>("instanceMapID") = instanceActInfo.instanceMapID;
@@ -586,7 +656,7 @@ bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GetObjectReportInfo&
 		}
 
 		auto& participants = instance.PushDebug("Participants");
-		for (const auto* participant : activityInstance.GetParticipants()) {
+		for (const auto* participant : activityInstance->GetParticipants()) {
 			if (!participant) continue;
 			auto* character = participant->GetCharacter();
 			if (!character) continue;
@@ -596,36 +666,42 @@ bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GetObjectReportInfo&
 
 	auto& queue = activityInfo.PushDebug("Queue");
 	i = 0;
-	for (const auto& lobbyQueue : m_Queue | std::views::values) {
+	for (const auto& lobbyQueue : m_Queue) {
 		auto& lobby = queue.PushDebug("Lobby " + std::to_string(i++));
-		lobby.PushDebug<AMFDoubleValue>("Timer") = lobbyQueue.timer;
+		lobby.PushDebug<AMFDoubleValue>("Timer") = lobbyQueue->timer;
 
 		auto& players = lobby.PushDebug("Players");
-		for (const auto& player : lobbyQueue.players) {
-			const auto* const playerEntity = player.GetEntity();
+		for (const auto* player : lobbyQueue->players) {
+			if (!player) continue;
+			auto* playerEntity = player->GetEntity();
 			if (!playerEntity) continue;
 			auto* character = playerEntity->GetCharacter();
 			if (!character) continue;
 
-			players.PushDebug<AMFStringValue>(std::to_string(playerEntity->GetObjectID()) + ": " + character->GetName()) = player.ready ? "Ready" : "Not Ready";
+			players.PushDebug<AMFStringValue>(std::to_string(playerEntity->GetObjectID()) + ": " + character->GetName()) = player->ready ? "Ready" : "Not Ready";
 		}
 	}
 
 	auto& activityPlayers = activityInfo.PushDebug("Activity Players");
-	for (const auto& [playerID, playerScores] : m_ActivityPlayers) {
-		auto* const activityPlayerEntity = Game::entityManager->GetEntity(playerID);
+	for (const auto* activityPlayer : m_ActivityPlayers) {
+		if (!activityPlayer) continue;
+		auto* const activityPlayerEntity = Game::entityManager->GetEntity(activityPlayer->playerID);
 		if (!activityPlayerEntity) continue;
 		auto* character = activityPlayerEntity->GetCharacter();
 		if (!character) continue;
 
-		auto& playerData = activityPlayers.PushDebug(std::to_string(playerID) + " " + character->GetName());
+		auto& playerData = activityPlayers.PushDebug(std::to_string(activityPlayer->playerID) + " " + character->GetName());
 
 		auto& scores = playerData.PushDebug("Scores");
 		for (size_t i = 0; i < 10; ++i) {
-			scores.PushDebug<AMFDoubleValue>(std::to_string(i)) = playerScores[i];
+			scores.PushDebug<AMFDoubleValue>(std::to_string(i)) = activityPlayer->values[i];
 		}
 	}
-
+	
+	auto& lootMatrices = activityInfo.PushDebug("Loot Matrices");
+	for (const auto& [activityRating, lootMatrixID] : m_ActivityLootMatrices) {
+		lootMatrices.PushDebug<AMFIntValue>("Loot Matrix " + std::to_string(activityRating)) = lootMatrixID;
+	}
 	activityInfo.PushDebug<AMFIntValue>("ActivityID") = m_ActivityID;
 	return true;
 }

dGame/dComponents/ActivityComponent.h

@@ -8,15 +8,14 @@
 #include "eReplicaComponentType.h"
 
 #include "CDActivitiesTable.h"
-#include <array>
 
 namespace GameMessages {
 	class GameMsg;
 };
 
-/**
- * Represents an instance of an activity, having participants and score
- */
+ /**
+  * Represents an instance of an activity, having participants and score
+  */
 class ActivityInstance {
 public:
 	ActivityInstance(Entity* parent, CDActivities activityInfo) { m_Parent = parent; m_ActivityInfo = activityInfo; };
@@ -105,7 +104,7 @@ struct LobbyPlayer {
 	/**
 	 * The ID of the entity that is in the lobby
 	 */
-	LWOOBJID entityID = LWOOBJID_EMPTY;
+	LWOOBJID entityID;
 
 	/**
 	 * Whether or not the entity is ready
@@ -127,12 +126,12 @@ struct Lobby {
 	/**
 	 * The lobby of players
 	 */
-	std::vector<LobbyPlayer> players;
+	std::vector<LobbyPlayer*> players;
 
 	/**
 	 * The timer that determines when the activity should start
 	 */
-	float timer{};
+	float timer;
 };
 
 /**
@@ -143,12 +142,12 @@ struct ActivityPlayer {
 	/**
 	 * The entity that the score is tracked for
 	 */
-	LWOOBJID playerID{};
+	LWOOBJID playerID;
 
 	/**
 	 * The list of score for this entity
 	 */
-	float values[10]{};
+	float values[10];
 };
 
 /**
@@ -195,13 +194,13 @@ public:
 	 * @param instance the instance to load the players into
 	 * @param lobby the players to load into the instance
 	 */
-	void LoadPlayersIntoInstance(ActivityInstance& instance, const std::vector<LobbyPlayer>& lobby) const;
+	void LoadPlayersIntoInstance(ActivityInstance* instance, const std::vector<LobbyPlayer*>& lobby) const;
 
 	/**
 	 * Removes a lobby from the activity manager
 	 * @param lobby the lobby to remove
 	 */
-	void RemoveLobby(const LWOOBJID lobbyID);
+	void RemoveLobby(Lobby* lobby);
 
 	/**
 	 * Marks a player as (un)ready in a lobby
@@ -216,10 +215,6 @@ public:
 	 */
 	int GetActivityID() { return m_ActivityInfo.ActivityID; }
 
-	// Whether or not team loot should be dropped on death for this activity
-	// if true, and a player is supposed to get loot, they are skipped
-	bool GetNoTeamLootOnDeath() const { return m_ActivityInfo.noTeamLootOnDeath; }
-
 	/**
 	 * Returns if this activity has a lobby, e.g. if it needs to instance players to some other map
 	 * @return true if this activity has a lobby, false otherwise
@@ -247,7 +242,7 @@ public:
 	 */
 	bool IsPlayedBy(LWOOBJID playerID) const;
 
-	/**
+	/** 
 	 * Checks if the entity has enough cost to play this activity
 	 * @param player the entity to check
 	 * @return true if the entity has enough cost to play this activity, false otherwise
@@ -272,14 +267,20 @@ public:
 	 * Creates a new instance for this activity
 	 * @return a new instance for this activity
 	 */
-	ActivityInstance& NewInstance();
+	ActivityInstance* NewInstance();
+
+	/**
+	 * Returns all the currently active instances of this activity
+	 * @return all the currently active instances of this activity
+	 */
+	const std::vector<ActivityInstance*>& GetInstances() const;
 
 	/**
 	 * Returns the instance that some entity is currently playing in
 	 * @param playerID the entity to check for
 	 * @return if any, the instance that the entity is currently in
 	 */
-	const ActivityInstance& GetInstance(const LWOOBJID playerID) const;
+	ActivityInstance* GetInstance(const LWOOBJID playerID);
 
 	/**
 	 * @brief Reloads the config settings for this component
@@ -287,12 +288,23 @@ public:
 	 */
 	void ReloadConfig();
 
+	/**
+	 * Removes all the instances
+	 */
+	void ClearInstances();
+
+	/**
+	 * Returns all the score for the players that are currently playing this activity
+	 * @return
+	 */
+	std::vector<ActivityPlayer*> GetActivityPlayers() { return m_ActivityPlayers; };
+
 	/**
 	 * Returns activity data for a specific entity (e.g. score and such).
 	 * @param playerID the entity to get data for
 	 * @return the activity data (score) for the passed player in this activity, if it exists
 	 */
-	bool PlayerHasActivityData(LWOOBJID playerID) const;
+	ActivityPlayer* GetActivityPlayerData(LWOOBJID playerID);
 
 	/**
 	 * Sets some score value for an entity
@@ -308,7 +320,7 @@ public:
 	 * @param index the index to get score for
 	 * @return activity score for the passed parameters
 	 */
-	float_t GetActivityValue(LWOOBJID playerID, uint32_t index) const;
+	float_t GetActivityValue(LWOOBJID playerID, uint32_t index);
 
 	/**
 	 * Removes activity score tracking for some entity
@@ -316,14 +328,28 @@ public:
 	 */
 	void RemoveActivityPlayerData(LWOOBJID playerID);
 
+	/**
+	 * Adds activity score tracking for some entity
+	 * @param playerID the entity to add the activity score for
+	 * @return the created entry
+	 */
+	ActivityPlayer* AddActivityPlayerData(LWOOBJID playerID);
+
 	/**
 	 * Sets the mapID that this activity points to
 	 * @param mapID the map ID to set
 	 */
 	void SetInstanceMapID(uint32_t mapID) { m_ActivityInfo.instanceMapID = mapID; };
 
+	/**
+	 * Returns the LMI that this activity points to for a team size
+	 * @param teamSize the team size to get the LMI for
+	 * @return the LMI that this activity points to for a team size
+	 */
+	uint32_t GetLootMatrixForTeamSize(uint32_t teamSize) { return m_ActivityLootMatrices[teamSize]; }
 private:
-	bool OnGetObjectReportInfo(GameMessages::GetObjectReportInfo& msg);
+
+	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
 	/**
 	 * The database information for this activity
 	 */
@@ -332,17 +358,22 @@ private:
 	/**
 	 * All the active instances of this activity
 	 */
-	std::vector<ActivityInstance> m_Instances;
+	std::vector<ActivityInstance*> m_Instances;
 
 	/**
 	 * The current lobbies for this activity
 	 */
-	std::map<LWOOBJID, Lobby> m_Queue;
+	std::vector<Lobby*> m_Queue;
 
 	/**
 	 * All the activity score for the players in this activity
 	 */
-	std::map<LWOOBJID, std::array<float, 10>> m_ActivityPlayers;
+	std::vector<ActivityPlayer*> m_ActivityPlayers;
+
+	/**
+	 * LMIs for team sizes
+	 */
+	std::unordered_map<uint32_t, uint32_t> m_ActivityLootMatrices;
 
 	/**
 	 * The activity id

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -13,8 +13,6 @@
 
 #include "CDClientDatabase.h"
 #include "CDClientManager.h"
-#include "CDObjectSkillsTable.h"
-#include "CDSkillBehaviorTable.h"
 #include "DestroyableComponent.h"
 
 #include <algorithm>
@@ -25,13 +23,12 @@
 #include "SkillComponent.h"
 #include "QuickBuildComponent.h"
 #include "DestroyableComponent.h"
+#include "Metrics.hpp"
 #include "CDComponentsRegistryTable.h"
 #include "CDPhysicsComponentTable.h"
 #include "dNavMesh.h"
-#include "Amf3.h"
 
 BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
-	RegisterMsg(&BaseCombatAIComponent::MsgGetObjectReportInfo);
 	m_Target = LWOOBJID_EMPTY;
 	m_DirtyStateOrTarget = true;
 	m_State = AiState::spawn;
@@ -45,7 +42,7 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const int32_t compo
 
 	//Grab the aggro information from BaseCombatAI:
 	auto componentQuery = CDClientDatabase::CreatePreppedStmt(
-		"SELECT aggroRadius, tetherSpeed, pursuitSpeed, softTetherRadius, hardTetherRadius, minRoundLength, maxRoundLength, combatRoundLength FROM BaseCombatAIComponent WHERE id = ?;");
+		"SELECT aggroRadius, tetherSpeed, pursuitSpeed, softTetherRadius, hardTetherRadius FROM BaseCombatAIComponent WHERE id = ?;");
 	componentQuery.bind(1, static_cast<int>(componentID));
 
 	auto componentResult = componentQuery.execQuery();
@@ -65,37 +62,44 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const int32_t compo
 
 		if (!componentResult.fieldIsNull("hardTetherRadius"))
 			m_HardTetherRadius = componentResult.getFloatField("hardTetherRadius");
-		
-		m_MinRoundLength = componentResult.getFloatField("minRoundLength");
-		m_MaxRoundLength = componentResult.getFloatField("maxRoundLength");
-		m_CombatRoundLength = componentResult.getFloatField("combatRoundLength");
 	}
 
+	componentResult.finalize();
+
 	// Get aggro and tether radius from settings and use this if it is present.  Only overwrite the
 	// radii if it is greater than the one in the database.
-	m_AggroRadius = m_Parent->HasVar(u"aggroRadius") ? m_Parent->GetVar<float>(u"aggroRadius") : m_AggroRadius;
-	m_HardTetherRadius = m_Parent->HasVar(u"tetherRadius") ? m_Parent->GetVar<float>(u"tetherRadius") : m_HardTetherRadius;
+	if (m_Parent) {
+		auto aggroRadius = m_Parent->GetVar<float>(u"aggroRadius");
+		m_AggroRadius = aggroRadius != 0 ? aggroRadius : m_AggroRadius;
+		auto tetherRadius = m_Parent->GetVar<float>(u"tetherRadius");
+		m_HardTetherRadius = tetherRadius != 0 ? tetherRadius : m_HardTetherRadius;
+	}
 
 	/*
 	 * Find skills
 	 */
-	for (const auto objectSkill : CDClientManager::GetTable<CDObjectSkillsTable>()->Get(parent->GetLOT())) {
-		const auto skillBehavior = CDClientManager::GetTable<CDSkillBehaviorTable>()->GetSkillByID(objectSkill.skillID);
-		if (skillBehavior.skillID == objectSkill.skillID) {
-			const auto skillId = skillBehavior.skillID;
+	auto skillQuery = CDClientDatabase::CreatePreppedStmt(
+		"SELECT skillID, cooldown, behaviorID FROM SkillBehavior WHERE skillID IN (SELECT skillID FROM ObjectSkills WHERE objectTemplate = ?);");
+	skillQuery.bind(1, static_cast<int>(parent->GetLOT()));
 
-			const auto abilityCooldown = skillBehavior.cooldown;
+	auto result = skillQuery.execQuery();
 
-			const auto behaviorId = skillBehavior.behaviorID;
+	while (!result.eof()) {
+		const auto skillId = static_cast<uint32_t>(result.getIntField("skillID"));
 
-			const auto combatWeight = objectSkill.AICombatWeight;
+		const auto abilityCooldown = static_cast<float>(result.getFloatField("cooldown"));
 
-			auto* behavior = Behavior::CreateBehavior(behaviorId);
+		const auto behaviorId = static_cast<uint32_t>(result.getIntField("behaviorID"));
 
-			AiSkillEntry entry = { .skillId = skillId, .cooldown = 0.0f, .abilityCooldown = abilityCooldown, .behavior = behavior, .combatWeight = combatWeight };
+		auto* behavior = Behavior::CreateBehavior(behaviorId);
 
-			m_SkillEntries.push_back(entry);
-		}
+		std::stringstream behaviorQuery;
+
+		AiSkillEntry entry = { skillId, 0, abilityCooldown, behavior };
+
+		m_SkillEntries.push_back(entry);
+
+		result.nextRow();
 	}
 
 	Stun(1.0f);
@@ -205,10 +209,8 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 	}
 
 	if (stunnedThisFrame) {
-		if (!m_MovementAI->IsPaused()) m_MovementAI->Pause();
+		m_MovementAI->Stop();
 
-		// in this case we just become unstunned so check if we paused and resume if we did
-		if (!m_Stunned && m_MovementAI->IsPaused()) m_MovementAI->Resume();
 		return;
 	}
 
@@ -243,12 +245,10 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 
 void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 	bool hasSkillToCast = false;
-	int32_t maxSkillWeights = 0;
 	for (auto& entry : m_SkillEntries) {
 		if (entry.cooldown > 0.0f) {
 			entry.cooldown -= deltaTime;
 		} else {
-			maxSkillWeights += entry.combatWeight;
 			hasSkillToCast = true;
 		}
 	}
@@ -316,14 +316,12 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 		SetAiState(AiState::aggro);
 	} else {
 		SetAiState(AiState::idle);
-		if (m_MovementAI) m_MovementAI->SetMaxSpeed(1.0f);
 	}
 
 	if (!hasSkillToCast) return;
 
 	if (m_Target == LWOOBJID_EMPTY) {
 		SetAiState(AiState::idle);
-		if (m_MovementAI) m_MovementAI->SetMaxSpeed(1.0f);
 
 		return;
 	}
@@ -334,23 +332,14 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 		LookAt(target->GetPosition());
 	}
 
-	// Roll to find which skill we'll try to cast
-	auto randomizedWeight = GeneralUtils::GenerateRandomNumber<int32_t>(0, maxSkillWeights);
+	for (auto i = 0; i < m_SkillEntries.size(); ++i) {
+		auto entry = m_SkillEntries.at(i);
 
-	for (auto& entry : m_SkillEntries) {
-		// Skill isn't cooled off yet
-		if (entry.cooldown > 0.0f) {
+		if (entry.cooldown > 0) {
 			continue;
 		}
 
-		randomizedWeight -= entry.combatWeight;
-
-		// if the weight is still greater than 0 continue to the next rolled skill
-		if (randomizedWeight > 0) {
-			continue;
-		}
-
-		const auto result = skillComponent->CalculateBehavior(entry.skillId, entry.behavior->m_behaviorId, GetTarget());
+		const auto result = skillComponent->CalculateBehavior(entry.skillId, entry.behavior->m_behaviorId, LWOOBJID_EMPTY);
 
 		if (result.success) {
 			if (m_MovementAI != nullptr) {
@@ -365,6 +354,8 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 
 			entry.cooldown = entry.abilityCooldown + m_SkillTime;
 
+			m_SkillEntries[i] = entry;
+
 			break;
 		}
 	}
@@ -485,7 +476,6 @@ std::vector<LWOOBJID> BaseCombatAIComponent::GetTargetWithinAggroRange() const {
 
 	for (auto id : m_Parent->GetTargetsInPhantom()) {
 		auto* other = Game::entityManager->GetEntity(id);
-		if (!other) continue;
 
 		const auto distance = Vector3::DistanceSquared(m_Parent->GetPosition(), other->GetPosition());
 
@@ -521,10 +511,6 @@ void BaseCombatAIComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsI
 
 void BaseCombatAIComponent::SetAiState(AiState newState) {
 	if (newState == this->m_State) return;
-	GameMessages::NotifyCombatAIStateChange stateMsg;
-	stateMsg.prevState = this->m_State;
-	stateMsg.newState = newState;
-	m_Parent->HandleMsg(stateMsg);
 	this->m_State = newState;
 	m_DirtyStateOrTarget = true;
 	Game::entityManager->SerializeEntity(m_Parent);
@@ -630,11 +616,6 @@ void BaseCombatAIComponent::Wander() {
 		return;
 	}
 
-	// If we have a path to follow we should almost certainly do that instead of wandering.
-	if (m_MovementAI->HasPath()) {
-		return;
-	}
-
 	m_MovementAI->SetHaltDistance(0);
 
 	const auto& info = m_MovementAI->GetInfo();
@@ -763,8 +744,8 @@ void BaseCombatAIComponent::SetTetherSpeed(float value) {
 	m_TetherSpeed = value;
 }
 
-void BaseCombatAIComponent::Stun(const float time, const bool force) {
-	if (!force && (m_StunImmune || m_StunTime > time)) {
+void BaseCombatAIComponent::Stun(const float time) {
+	if (m_StunImmune || m_StunTime > time) {
 		return;
 	}
 
@@ -858,80 +839,3 @@ void BaseCombatAIComponent::IgnoreThreat(const LWOOBJID threat, const float valu
 	SetThreat(threat, 0.0f);
 	m_Target = LWOOBJID_EMPTY;
 }
-
-bool BaseCombatAIComponent::MsgGetObjectReportInfo(GameMessages::GetObjectReportInfo& reportInfo) {
-	using enum AiState;
-	auto& cmptType = reportInfo.info->PushDebug("Base Combat AI");
-	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
-	auto& targetInfo = cmptType.PushDebug("Current Target Info");
-	targetInfo.PushDebug<AMFStringValue>("Current Target ID") = std::to_string(m_Target);
-	// if (m_Target != LWOOBJID_EMPTY) {
-		// LWOGameMessages::ObjGetName nameMsg(m_CurrentTarget);
-		// SEND_GAMEOBJ_MSG(nameMsg);
-		// if (!nameMsg.msg.name.empty()) targetInfo.PushDebug("Name") = nameMsg.msg.name;
-	// }
-
-	auto& roundInfo = cmptType.PushDebug("Round Info");
-	// roundInfo.PushDebug<AMFDoubleValue>("Combat Round Time") = m_CombatRoundLength;
-	// roundInfo.PushDebug<AMFDoubleValue>("Minimum Time") = m_MinRoundLength;
-	// roundInfo.PushDebug<AMFDoubleValue>("Maximum Time") = m_MaxRoundLength;
-	// roundInfo.PushDebug<AMFDoubleValue>("Selected Time") = m_SelectedTime;
-	// roundInfo.PushDebug<AMFDoubleValue>("Combat Start Delay") = m_CombatStartDelay;
-	std::string curState;
-	switch (m_State) {
-	case idle: curState = "Idling"; break;
-	case aggro: curState = "Aggroed"; break;
-	case tether: curState = "Returning to Tether"; break;
-	case spawn: curState = "Spawn"; break;
-	case dead: curState = "Dead"; break;
-	default: curState = "Unknown or Undefined"; break;
-	}
-	cmptType.PushDebug<AMFStringValue>("Current Combat State") = curState;
-
-	//switch (m_CombatBehaviorType) {
-	//	case 0: curState = "Passive"; break;
-	//	case 1: curState = "Aggressive"; break;
-	//	case 2: curState = "Passive (Turret)"; break;
-	//	case 3: curState = "Aggressive (Turret)"; break;
-	//	default: curState = "Unknown or Undefined"; break;
-	//}
-	//cmptType.PushDebug("Current Combat Behavior State") = curState;
-
-	//switch (m_CombatRole) {
-	//	case 0: curState = "Melee"; break;
-	//	case 1: curState = "Ranged"; break;
-	//	case 2: curState = "Support"; break;
-	//	default: curState = "Unknown or Undefined"; break;
-	//}
-	//cmptType.PushDebug("Current Combat Role") = curState;
-
-	auto& tetherPoint = cmptType.PushDebug("Tether Point");
-	tetherPoint.PushDebug<AMFDoubleValue>("X") = m_StartPosition.x;
-	tetherPoint.PushDebug<AMFDoubleValue>("Y") = m_StartPosition.y;
-	tetherPoint.PushDebug<AMFDoubleValue>("Z") = m_StartPosition.z;
-	cmptType.PushDebug<AMFDoubleValue>("Hard Tether Radius") = m_HardTetherRadius;
-	cmptType.PushDebug<AMFDoubleValue>("Soft Tether Radius") = m_SoftTetherRadius;
-	cmptType.PushDebug<AMFDoubleValue>("Aggro Radius") = m_AggroRadius;
-	cmptType.PushDebug<AMFDoubleValue>("Tether Speed") = m_TetherSpeed;
-	cmptType.PushDebug<AMFDoubleValue>("Aggro Speed") = m_TetherSpeed;
-	// cmptType.PushDebug<AMFDoubleValue>("Specified Min Range") = m_SpecificMinRange;
-	// cmptType.PushDebug<AMFDoubleValue>("Specified Max Range") = m_SpecificMaxRange;
-	auto& threats = cmptType.PushDebug("Target Threats");
-	for (const auto& [id, threat] : m_ThreatEntries) {
-		threats.PushDebug<AMFDoubleValue>(std::to_string(id)) = threat;
-	}
-
-	auto& ignoredThreats = cmptType.PushDebug("Temp Ignored Threats");
-	for (const auto& [id, threat] : m_RemovedThreatList) {
-		ignoredThreats.PushDebug<AMFDoubleValue>(std::to_string(id) + " - Time") = threat;
-	}
-	auto& skillInfo = cmptType.PushDebug("Skill Info");
-	for (const auto& skill : m_SkillEntries) {
-		auto& skillDebug = skillInfo.PushDebug("Skill ID " + std::to_string(skill.skillId));
-		skillDebug.PushDebug<AMFDoubleValue>("Cooldown") = skill.cooldown;
-		skillDebug.PushDebug<AMFDoubleValue>("Ability Cooldown") = skill.abilityCooldown;
-		skillDebug.PushDebug<AMFIntValue>("AI Combat Weight") = skill.combatWeight;
-	}
-
-	return true;
-}

dGame/dComponents/BaseCombatAIComponent.h

@@ -33,15 +33,13 @@ enum class AiState : uint32_t {
  */
 struct AiSkillEntry
 {
-	uint32_t skillId{};
+	uint32_t skillId;
 
-	float cooldown{};
+	float cooldown;
 
-	float abilityCooldown{};
+	float abilityCooldown;
 
-	Behavior* behavior{};
-
-	int32_t combatWeight{};
+	Behavior* behavior;
 };
 
 /**
@@ -183,9 +181,8 @@ public:
 	/**
 	 * Stuns the entity for a certain amount of time, will not work if the entity is stun immune
 	 * @param time the time to stun the entity, if stunnable
-	 * @param force whether or not to force the stun and ignore checks
 	 */
-	void Stun(float time, const bool force = false);
+	void Stun(float time);
 
 	/**
 	 * Gets the radius that will cause this entity to get aggro'd, causing a target chase
@@ -237,10 +234,6 @@ public:
 	// Ignore a threat for a certain amount of time
 	void IgnoreThreat(const LWOOBJID target, const float time);
 
-	bool MsgGetObjectReportInfo(GameMessages::GetObjectReportInfo& reportInfo);
-
-	void SetStartingPosition(const NiPoint3& pos) { m_StartPosition = pos; }
-
 private:
 	/**
 	 * Returns the current target or the target that currently is the largest threat to this entity
@@ -399,17 +392,9 @@ private:
 	 */
 	bool m_DirtyStateOrTarget = false;
 
-	// Min amount of time to remain as in combat after casting a skill
-	float m_MinRoundLength = 0.0f;
-	
-	// max amount of time to remain as in combat after casting a skill
-	float m_MaxRoundLength = 0.0f;
-
 	// The amount of time the entity will be forced to tether for
 	float m_ForcedTetherTime = 0.0f;
 
-	float m_CombatRoundLength = 0.0f;
-
 	// The amount of time a removed threat will be ignored for. 
 	std::map<LWOOBJID, float> m_RemovedThreatList;
 

dGame/dComponents/BouncerComponent.cpp

@@ -8,30 +8,15 @@
 #include "GameMessages.h"
 #include "BitStream.h"
 #include "eTriggerEventType.h"
-#include "Amf3.h"
 
 BouncerComponent::BouncerComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
 	m_PetEnabled = false;
 	m_PetBouncerEnabled = false;
 	m_PetSwitchLoaded = false;
-	m_Destination = GeneralUtils::TryParse<NiPoint3>(
-		GeneralUtils::SplitString(m_Parent->GetVarAsString(u"bouncer_destination"), '\x1f'))
-		.value_or(NiPoint3Constant::ZERO);
-	m_Speed = GeneralUtils::TryParse<float>(m_Parent->GetVarAsString(u"bouncer_speed")).value_or(-1.0f);
-	m_UsesHighArc = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"bouncer_uses_high_arc")).value_or(false);
-	m_LockControls = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"lock_controls")).value_or(false);
-	m_IgnoreCollision = !GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"ignore_collision")).value_or(true);
-	m_StickLanding = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"stickLanding")).value_or(false);
-	m_UsesGroupName = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"uses_group_name")).value_or(false);
-	m_GroupName = m_Parent->GetVarAsString(u"grp_name");
-	m_MinNumTargets = GeneralUtils::TryParse<int32_t>(m_Parent->GetVarAsString(u"num_targets_to_activate")).value_or(1);
-	m_CinematicPath = m_Parent->GetVarAsString(u"attached_cinematic_path");
 
 	if (parent->GetLOT() == 7625) {
 		LookupPetSwitch();
 	}
-
-	RegisterMsg(&BouncerComponent::MsgGetObjectReportInfo);
 }
 
 BouncerComponent::~BouncerComponent() {
@@ -109,53 +94,3 @@ void BouncerComponent::LookupPetSwitch() {
 			});
 	}
 }
-
-bool BouncerComponent::MsgGetObjectReportInfo(GameMessages::GetObjectReportInfo& reportInfo) {
-	auto& cmptType = reportInfo.info->PushDebug("Bouncer");
-	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
-	auto& destPos = cmptType.PushDebug("Destination Position");
-	if (m_Destination != NiPoint3Constant::ZERO) {
-		destPos.PushDebug(m_Destination);
-	} else {
-		destPos.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has no target position, is likely missing config data");
-	}
-
-
-	if (m_Speed == -1.0f) {
-		cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has no speed value, is likely missing config data");
-	} else {
-		cmptType.PushDebug<AMFDoubleValue>("Bounce Speed") = m_Speed;
-	}
-	cmptType.PushDebug<AMFStringValue>("Bounce trajectory arc") = m_UsesHighArc ? "High Arc" : "Low Arc";
-	cmptType.PushDebug<AMFBoolValue>("Collision Enabled") = m_IgnoreCollision;
-	cmptType.PushDebug<AMFBoolValue>("Stick Landing") = m_StickLanding;
-	cmptType.PushDebug<AMFBoolValue>("Locks character's controls") = m_LockControls;
-	if (!m_CinematicPath.empty()) cmptType.PushDebug<AMFStringValue>("Cinematic Camera Path (plays during bounce)") = m_CinematicPath;
-
-	auto* switchComponent = m_Parent->GetComponent<SwitchComponent>();
-	auto& respondsToFactions = cmptType.PushDebug("Responds to Factions");
-	if (!switchComponent || switchComponent->GetFactionsToRespondTo().empty()) respondsToFactions.PushDebug("Faction 1");
-	else {
-		for (const auto faction : switchComponent->GetFactionsToRespondTo()) {
-			respondsToFactions.PushDebug(("Faction " + std::to_string(faction)));
-		}
-	}
-
-	cmptType.PushDebug<AMFBoolValue>("Uses a group name for interactions") = m_UsesGroupName;
-	if (!m_UsesGroupName) {
-		if (m_MinNumTargets > 1) {
-			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has a required number of objects to activate, but no group for interactions.");
-		}
-
-		if (!m_GroupName.empty()) {
-			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Has a group name for interactions , but is marked to not use that name.");
-		}
-	} else {
-		if (m_GroupName.empty()) {
-			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Set to use a group name for inter actions, but no group name is assigned");
-		}
-		cmptType.PushDebug<AMFIntValue>("Number of interactions to activate bouncer") = m_MinNumTargets;
-	}
-
-	return true;
-}

dGame/dComponents/BouncerComponent.h

@@ -51,8 +51,6 @@ public:
 	 */
 	void LookupPetSwitch();
 
-	bool MsgGetObjectReportInfo(GameMessages::GetObjectReportInfo& reportInfo);
-
 private:
 	/**
 	 * Whether this bouncer needs to be activated by a pet
@@ -68,36 +66,6 @@ private:
 	 * Whether the pet switch for this bouncer has been located
 	 */
 	bool m_PetSwitchLoaded;
-
-	// The bouncer destination
-	NiPoint3 m_Destination;
-
-	// The speed at which the player is bounced
-	float m_Speed{};
-
-	// Whether to use a high arc for the bounce trajectory
-	bool m_UsesHighArc{};
-
-	// Lock controls when bouncing
-	bool m_LockControls{};
-	
-	// Ignore collision when bouncing
-	bool m_IgnoreCollision{};
-
-	// Stick the landing afterwards or let the player slide
-	bool m_StickLanding{};
-	
-	// Whether or not there is a group name
-	bool m_UsesGroupName{};
-
-	// The group name for targets
-	std::string m_GroupName{};
-
-	// The number of targets to activate the bouncer
-	int32_t m_MinNumTargets{};
-
-	// The cinematic path to play during the bounce
-	std::string m_CinematicPath{};
 };
 
 #endif // BOUNCERCOMPONENT_H

dGame/dComponents/BuffComponent.cpp

@@ -450,10 +450,19 @@ const std::vector<BuffParameter>& BuffComponent::GetBuffParameters(int32_t buffI
 		param.value = result.getFloatField("NumberValue");
 		param.effectId = result.getIntField("EffectID");
 
-		for (const auto& str : GeneralUtils::SplitString(result.getStringField("StringValue"), ',')) {
-			if (str.empty()) continue;
-			const auto value = GeneralUtils::TryParse<float>(str);
-			if (value) param.values.push_back(value.value());
+		if (!result.fieldIsNull("StringValue")) {
+			std::istringstream stream(result.getStringField("StringValue"));
+			std::string token;
+
+			while (std::getline(stream, token, ',')) {
+				try {
+					const auto value = std::stof(token);
+
+					param.values.push_back(value);
+				} catch (std::invalid_argument& exception) {
+					LOG("Failed to parse value (%s): (%s)!", token.c_str(), exception.what());
+				}
+			}
 		}
 
 		parameters.push_back(param);