Remove what's Working documentation as everything is implemented

This checks if the sentient being hit is dead, and skip it when moving the vehicle so the vehicle doesn't get stuck for when a sentient is dying

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots (OPTIONAL)**
+If applicable, add screenshots to help explain your problem.
+
+**Logs**
+- Paste the output of the console window in a text file, and attach the text file.
+- If applicable (`logfile` set to 2), attach the `qconsole.log` file. On Windows, it can be found in **%APPDATA%\...\qconsole.log** and on Linux, it can be found on the home directory **~/.openmohaa/.../qconsole.log**.
+
+**Version information (please complete the following information):**
+ - OS: [e.g. `Debian`]
+ - OS Version [e.g `12`]
+ - OpenMoHAA Version: [e.g `0.70.0-alpha+0.0b1a20dcf win_msvc64-x86_64-debug`, can be found below **Common Initialization** in the console, or by typing `version`]
+
+**Dump (OPTIONAL)**
+You can include a core dump generated by the OS (`.dmp` file). If you compiled OpenMoHAA yourself, also add all output openmohaa binaries (except libopenal and libSDL).
+
+**Additional context (OPTIONAL)**
+Add any other context about the problem here.

.github/workflows/branches-build.yml

@@ -0,0 +1,17 @@
+name: Build branch
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-all:
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: "testing"

.github/workflows/build-cmake.yml

@@ -1,192 +0,0 @@
-name: Build
-
-on:
-  push:
-  pull_request:
-  workflow_call:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: RelWithDebInfo
-
-jobs:
-  build-platform-linux:
-    strategy:
-      matrix:
-        architecture: [
-          {name: 'amd64',   triple: 'x86_64-linux-gnu'},
-          {name: 'i686',    triple: 'i686-linux-gnu'},
-          {name: 'aarch64', triple: 'aarch64-linux-gnu'},
-          {name: 'armhf',   triple: 'arm-linux-gnueabihf'}
-        ]
-
-    name: "Building for platform linux-${{matrix.architecture.name}}"
-    runs-on: ubuntu-22.04
-
-    steps:
-    - name: Settings
-      working-directory: ${{github.workspace}}
-      run: |
-        echo "CMAKE_BUILD_PARALLEL_LEVEL=$(($(nproc) * 16))" >> $GITHUB_ENV
-#       echo "CMAKE_GENERATOR=Ninja" >> $GITHUB_ENV
-
-    - name: Install required packages
-      run: |
-        sudo apt update && sudo apt install -y flex bison
-  
-    - name: Install required cross-platform packages (${{ matrix.architecture.triple }})
-      if: matrix.architecture.name != 'amd64'
-      run: sudo apt install -y gcc-12-${{ matrix.architecture.triple }} g++-12-${{ matrix.architecture.triple }}
-
-    # Setup SDL
-    - name: Set up SDL
-      id: sdl
-      uses: libsdl-org/setup-sdl@main
-      with:
-        version: sdl2-latest
-        build-type: Release
-        cmake-arguments: "-DCMAKE_C_COMPILER=clang
-          -DCMAKE_CXX_COMPILER=clang++
-          -DCMAKE_C_FLAGS=--target=${{ matrix.architecture.triple }}
-          -DCMAKE_CXX_FLAGS=--target=${{ matrix.architecture.triple }}"
-
-    - uses: actions/checkout@v3
-      with:
-        path: 'source'
-
-    - name: CMake Settings
-      run: |
-        echo "CMAKE_PARAM=--log-level=VERBOSE \
-        -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
-        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
-        -DCMAKE_C_COMPILER=clang \
-        -DCMAKE_CXX_COMPILER=clang++ \
-        -DCMAKE_C_FLAGS=--target=${{ matrix.architecture.triple }} \
-        -DCMAKE_CXX_FLAGS=--target=${{ matrix.architecture.triple }} \
-        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }}" >> $GITHUB_ENV
-
-    - name: Configure CMake
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
-
-    - name: Build
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-
-    - name: Test
-      working-directory: ${{github.workspace}}
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: |
-        cd "${{github.workspace}}/build"
-        ctest -C ${{env.BUILD_TYPE}}
-
-    - name: Install
-      working-directory: ${{github.workspace}}
-      # Install to the directory defined in CMAKE_INSTALL_PREFIX
-      run: |
-        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-        cp '${{steps.sdl.outputs.prefix}}/lib/libSDL2.so' '${{github.workspace}}/install'
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-linux-${{matrix.architecture.name}}
-        if-no-files-found: error
-        path:
-          ${{github.workspace}}/install
-
-  build-platform-windows:
-    strategy:
-      matrix:
-        architecture: [
-          {name: 'x64',   config: 'x64' },
-          {name: 'x86',   config: 'Win32' },
-          {name: 'arm64', config: 'ARM64' }
-        ]
-
-    name: "Building for platform windows-${{matrix.architecture.name}}"
-    runs-on: windows-2022
-
-    steps:
-    - name: Settings
-      working-directory: ${{github.workspace}}
-      run: |
-        echo "CMAKE_BUILD_PARALLEL_LEVEL=$((Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors * 16)" >> $GITHUB_ENV
-
-        # Setup SDL
-    - name: Set up SDL
-      id: sdl
-      uses: libsdl-org/setup-sdl@main
-      with:
-        version: sdl2-latest
-        build-type: Release
-        cmake-arguments: "-A ${{ matrix.architecture.config }}"
-
-    - name: Install Flex/Bison
-      working-directory: ${{github.workspace}}
-      run: |
-        mkdir thirdparties && cd thirdparties
-        git clone --depth 1 --single-branch --branch v2.5.25 https://github.com/lexxmark/winflexbison.git
-        cmake -B winflexbison-build -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/winflexbison-install' ./winflexbison
-        cmake --build winflexbison-build --config Release --parallel
-        cmake --install winflexbison-build
-
-    - uses: actions/checkout@v3
-      with:
-        path: 'source'
-
-    - name: CMake Settings
-      run: |
-        echo "CMAKE_PARAM=-A ${{ matrix.architecture.config }} `
-        --log-level=VERBOSE `
-        -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} `
-        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' `
-        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} `
-        -DBISON_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_bison.exe' `
-        -DFLEX_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_flex.exe'".Replace("`r", "").Replace("`n", "") >> $env:GITHUB_ENV
-
-    - name: Configure CMake
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
-
-    - name: Build
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-
-    - name: Test
-      working-directory: ${{github.workspace}}
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: |
-        cd "${{github.workspace}}/build"
-        ctest -C ${{env.BUILD_TYPE}}
-
-    - name: Install
-      working-directory: ${{github.workspace}}
-      # Install to the directory defined in CMAKE_INSTALL_PREFIX
-      run: |
-        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-        Copy-Item '${{steps.sdl.outputs.prefix}}/bin/*.dll' -Destination '${{github.workspace}}/install'
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-windows-${{matrix.architecture.name}}
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install
-          !${{github.workspace}}/install/**/*.pdb
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-windows-${{matrix.architecture.name}}-pdb
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install

.github/workflows/main-codeql.yml

@@ -20,6 +20,10 @@ on:
   schedule:
     - cron: '42 8 * * 1'
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   analyze:
     name: Analyze
@@ -41,7 +45,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     # Setup SDL
     - name: Set up SDL
@@ -52,7 +56,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -66,7 +70,7 @@ jobs:
     # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -79,6 +83,6 @@ jobs:
     #     ./location_of_script_within_repo/buildscript.sh
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/shared-build.yml

@@ -0,0 +1,477 @@
+name: Shared build workflow
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: RelWithDebInfo
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+
+jobs:
+  ##########################
+  #
+  # Linux
+  # Ubuntu 22.04
+  #
+  # Using this version instead of 24.04 to use a lower GLIBC version (2.34)
+  ##########################
+  build-platform-linux:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'amd64',    triple: 'x86_64-linux-gnu'},
+          {name: 'i686',     triple: 'i686-linux-gnu'},
+          {name: 'arm64',    triple: 'aarch64-linux-gnu'},
+          {name: 'armhf',    triple: 'arm-linux-gnueabihf'},
+          {name: 'powerpc',  triple: 'powerpc-linux-gnu'},
+          {name: 'ppc64',    triple: 'powerpc64-linux-gnu'},
+          {name: 'ppc64el',  triple: 'powerpc64le-linux-gnu'}
+        ]
+
+    name: "Building for platform linux-${{matrix.architecture.name}}"
+    runs-on: "ubuntu-22.04"
+    environment: ${{ inputs.environment }}
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: flex bison ninja-build cmake clang libpulse-dev portaudio19-dev libasound2-dev libjack-dev libpipewire-0.3-dev qtbase5-dev libdbus-1-dev
+        version: "0.1"
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required cross-platform packages (${{ matrix.architecture.triple }})
+      if: matrix.architecture.name != 'amd64'
+      with:
+        packages: gcc-12-${{ matrix.architecture.triple }} g++-12-${{ matrix.architecture.triple }}
+        version: "0.1"
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $GITHUB_ENV
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+        echo "CFLAGS='--target=${{ matrix.architecture.triple }}'" >> $GITHUB_ENV
+        echo "CXXFLAGS='--target=${{ matrix.architecture.triple }}'" >> $GITHUB_ENV
+        # Temporary workaround for PowerPC as the 1.24.0 version doesn't check for altivec
+        # Will use older versions until a new tag is created with this issue resolved
+        if [ ${{ matrix.architecture.name }} != 'powerpc' ] && [ ${{ matrix.architecture.name }} != 'ppc64' ] &&  [ ${{ matrix.architecture.name }} != 'ppc64el' ]; then
+            echo "OPENAL_REF=1.24.0" >> $GITHUB_ENV
+        else
+            echo "OPENAL_REF=1.23.1" >> $GITHUB_ENV
+        fi
+
+    ###
+    # SDL
+    ###
+
+    # Setup SDL
+    - name: Set up SDL
+      id: sdl
+      uses: libsdl-org/setup-sdl@main
+      with:
+        version: 2-latest
+        build-type: Release
+        # Workaround for when changing the runner OS version
+        cmake-arguments: "-DCACHE_OS_VERSION=Ubuntu_22.04"
+
+    ###
+    # OpenAL
+    ###
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: ${{ env.OPENAL_REF }}
+
+    - name: Configure and install soft-oal
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal' \
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/include' \
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} \
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Test
+      working-directory: ${{github.workspace}}
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: |
+        cd "${{github.workspace}}/build"
+        ctest -C ${{env.BUILD_TYPE}}
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        # Copy libraries
+        mkdir ${{github.workspace}}/package
+        cp -l ${{steps.sdl.outputs.prefix}}/lib/libSDL2-2.0.so.0 '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/soft-oal/install/lib/libopenal.so.1 '${{github.workspace}}/package/'
+        if [ -d ${{github.workspace}}/install/bin ]; then cp -r ${{github.workspace}}/install/bin/openmohaa/. '${{github.workspace}}/package'; fi
+        if [ -d ${{github.workspace}}/install/lib ]; then cp -r ${{github.workspace}}/install/lib/openmohaa/. '${{github.workspace}}/package'; fi
+
+    ###
+    # Artifacts
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-linux-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path:
+          ${{github.workspace}}/package
+
+  ##########################
+  #
+  # Microsoft Windows
+  # Windows Server 2022
+  #
+  ##########################
+  build-platform-windows:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'x64',   config: 'x64',    toolset: 'x64' },
+          {name: 'x86',   config: 'Win32',  toolset: 'x64_x86' },
+          {name: 'arm64', config: 'ARM64',  toolset: 'x64_arm64' }
+        ]
+
+    name: "Building for platform windows-${{matrix.architecture.name}}"
+    runs-on: "windows-2022"
+    environment: ${{ inputs.environment }}
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    #
+    # Commented out for now, chocolatey servers started complaining about too many requests
+    #
+    #- name: Install required packages
+    #  run: |
+    #    choco install -y ninja
+
+    - name: Install required packages
+      run: |
+        $DownloadPath="$($env:USERPROFILE)\Downloads"
+        Invoke-WebRequest "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-win.zip" -OutFile "$DownloadPath\ninja-win.zip"
+        Expand-Archive -Path "$DownloadPath\ninja-win.zip" -DestinationPath "$($env:PROGRAMFILES)\ninja"
+        echo "$($env:PROGRAMFILES)\ninja" >> $GITHUB_PATH
+
+    - name: Install Flex/Bison
+      working-directory: ${{github.workspace}}
+      run: |
+        mkdir thirdparties && cd thirdparties
+        git clone --depth 1 --single-branch --branch v2.5.25 https://github.com/lexxmark/winflexbison.git
+        cmake -B winflexbison-build -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/winflexbison-install' ./winflexbison
+        cmake --build winflexbison-build --config Release --parallel
+        cmake --install winflexbison-build --config Release
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $env:GITHUB_ENV
+        echo "CC=cl.exe" >> $env:GITHUB_ENV
+        echo "CXX=cl.exe" >> $env:GITHUB_ENV
+        pushd "$($env:PROGRAMFILES)\Microsoft Visual Studio\*\*\VC\Auxiliary\Build"
+        cmd /c "vcvarsall.bat ${{ matrix.architecture.toolset }} & set" | ForEach-Object {
+          if ($_ -match "=") {
+            # Split into key=value
+            $var = $_.split("=", 2);
+            echo "$($var[0])=$($var[1])" >> $env:GITHUB_ENV
+          }
+        }
+        popd
+
+    ###
+    # SDL
+    ###
+
+    # Setup SDL
+    - name: Set up SDL
+      id: sdl
+      uses: libsdl-org/setup-sdl@main
+      with:
+        version: 2-latest
+        build-type: Release
+        cmake-arguments: ""
+
+    ###
+    # OpenAL
+    ###
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '1.24.0'
+
+    # soft-oal build
+    # Statically link the CRT runtime into OAL as a workaround to prevent crashes
+    - name: Configure and install soft-oal
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build `
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install' `
+        -DALSOFT_BUILD_ROUTER=OFF `
+        -DALSOFT_REQUIRE_WINMM=ON `
+        -DALSOFT_REQUIRE_DSOUND=ON `
+        -DALSOFT_REQUIRE_WASAPI=ON `
+        -DCMAKE_C_FLAGS_RELEASE="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_RELEASE="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_C_FLAGS_MINSIZEREL="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_MINSIZEREL="/MT /O1 /Ob1 /DNDEBUG" `
+        -DCMAKE_C_FLAGS_RELWITHDEBINFO="/MT /Zi /O2 /Ob1 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="/MT /Zi /O2 /Ob1 /DNDEBUG"
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+        # Unfortunately soft-oal produces a binary called OpenAL32 even in 64-bit
+        if (("x64", "ARM64") -icontains "${{ matrix.architecture.config }}") { Rename-Item -Path '.\install\bin\OpenAL32.dll' -NewName 'OpenAL64.dll' }
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM= `
+        --log-level=VERBOSE `
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' `
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} `
+        -DBISON_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_bison.exe' `
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal' `
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/include' `
+        -DFLEX_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_flex.exe' `
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'".Replace("`r", "").Replace("`n", "") >> $env:GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Test
+      working-directory: ${{github.workspace}}
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: |
+        cd "${{github.workspace}}/build"
+        ctest -C ${{env.BUILD_TYPE}}
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        New-Item -ItemType Directory '${{github.workspace}}/package'
+        Copy-Item '${{steps.sdl.outputs.prefix}}/bin/*.dll' -Destination '${{github.workspace}}/package'
+        Copy-Item '${{github.workspace}}/thirdparties/soft-oal/install/bin/*.dll' -Destination '${{github.workspace}}/package'
+        if (Test-Path ${{github.workspace}}/install/bin) { Copy-Item '${{github.workspace}}/install/bin/*' -Include '*.dll','*.exe','*.pdb' -Destination '${{github.workspace}}/package' }
+        if (Test-Path ${{github.workspace}}/install/lib) { Copy-Item '${{github.workspace}}/install/lib/*' -Include '*.dll','*.exe','*.pdb' -Destination '${{github.workspace}}/package' }
+
+    ###
+    # Artifact
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/package
+          !${{github.workspace}}/package/**/*.pdb
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}-pdb
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/package
+
+  ##########################
+  #
+  # Apple macOS
+  # macOS 14
+  #
+  # This version is used as the OS, as older versions are slower.
+  ##########################
+  build-platform-macos:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'x86_64',   triple: 'x86_64-apple-macos10.8'},
+          {name: 'arm64',    triple: 'arm64-apple-macos11'}
+        ]
+
+    name: "Building for platform macos-${{matrix.architecture.name}}"
+    runs-on: "macos-14"
+    environment: ${{inputs.environment}}
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    # Install required packages
+    # Paths on x86_64 and ARM64 are different for homebrew
+    - name: Install required packages
+      run: |
+        brew update && brew install git flex bison ninja cmake llvm ninja
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $GITHUB_ENV
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+        echo "MACOSX_DEPLOYMENT_TARGET=10.15" >> $GITHUB_ENV
+
+    ###
+    # SDL
+    ###
+
+    # Setup SDL
+    - name: Set up SDL
+      id: sdl
+      uses: libsdl-org/setup-sdl@main
+      with:
+        version: 2-latest
+        build-type: Release
+        cmake-arguments: "-DCMAKE_OSX_ARCHITECTURES=${{ matrix.architecture.name }}
+          -DCMAKE_VERBOSE_MAKEFILE=on"
+    ###
+    # OpenAL
+    ###
+
+    # soft-oal setup
+    # Use GCC instead of Clang because of missing SSE intrinsics
+    # It also doesn't enable altivec support on PowerPC by default
+    - name: Checkout soft-oal
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '1.24.0'
+
+    - name: Configure and install soft-oal
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install' \
+        -DCMAKE_OSX_ARCHITECTURES=${{ matrix.architecture.name }} \
+        -DCMAKE_VERBOSE_MAKEFILE=on
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
+        -DCMAKE_VERBOSE_MAKEFILE=on \
+        -DCMAKE_OSX_ARCHITECTURES=${{ matrix.architecture.name }} \
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal/install' \
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/install/include/AL' \
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} \
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Test
+      working-directory: ${{github.workspace}}
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: |
+        cd "${{github.workspace}}/build"
+        ctest -C ${{env.BUILD_TYPE}}
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        # Create hard-link and copy symbolic links
+        mkdir ${{github.workspace}}/package
+        cp -l ${{steps.sdl.outputs.prefix}}/lib/libSDL2-2.0.0.dylib '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/soft-oal/install/lib/libopenal.1.dylib '${{github.workspace}}/package/'
+        if [ -d ${{github.workspace}}/install/bin ]; then cp -r ${{github.workspace}}/install/bin/openmohaa/. '${{github.workspace}}/package'; fi
+        if [ -d ${{github.workspace}}/install/lib ]; then cp -r ${{github.workspace}}/install/lib/openmohaa/. '${{github.workspace}}/package'; fi
+
+    ###
+    # Artifacts
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-macos-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path:
+          ${{github.workspace}}/package

.github/workflows/tags-publish-release.yml

@@ -6,7 +6,7 @@ on:
         - "v*.*.*"
 
 env:
-  RELEASE_TYPE: ${{ vars.RELEASE_TYPE || 'test' }}
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
   RELEASE_IS_PRERELEASE: ${{ vars.RELEASE_IS_PRELEASE }}
 
 permissions:
@@ -14,7 +14,9 @@ permissions:
 
 jobs:
   build-all:
-   uses: ./.github/workflows/build-cmake.yml
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: "release"
 
   deploy_all:
     strategy:
@@ -25,25 +27,30 @@ jobs:
         target_os: [
           'linux-amd64',
           'linux-i686',
-          'linux-aarch64',
+          'linux-arm64',
           'linux-armhf',
+          'linux-powerpc',
+          'linux-ppc64',
+          'linux-ppc64el',
           'windows-x64',
-          'windows-x86',
           'windows-x64-pdb',
+          'windows-x86',
           'windows-x86-pdb',
           'windows-arm64',
-          'windows-arm64-pdb'
+          'windows-arm64-pdb',
+          'macos-x86_64',
+          'macos-arm64'
         ]
 
-    runs-on: ubuntu-22.04
-    environment: release
+    runs-on: ubuntu-24.04
+    environment: "release"
     needs: [build-all]
 
     env:
       RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
 
     steps:
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: 'out-${{matrix.target_os}}'
         path: ${{github.workspace}}/${{matrix.target_os}}
@@ -53,8 +60,8 @@ jobs:
       run: zip -r ../${{ env.RELEASE_NAME }}.zip ./
 
     - name: Release
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@v2
       with:
-        name: '${{github.ref_name}}-${{env.RELEASE_TYPE}}'
+        name: '${{github.ref_name}}-${{env.RELEASE_STAGE}}'
         prerelease: ${{env.RELEASE_IS_PRERELEASE}}
         files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.zip

.gitignore

@@ -5,6 +5,8 @@ Makefile.local
 *.swp
 *tags
 *~
+/.vscode/
+/baseq3
 
 # OS X
 ####################
@@ -44,5 +46,6 @@ profile
 *.suo
 
 .vs
-out
 code_unfinished/*
+thirdparties/
+code/parser/generated/*

CMakeLists.txt

@@ -5,6 +5,14 @@ include(TargetArch.cmake)
 
 target_architecture(TARGET_ARCH)
 
+set(USE_INTERNAL_LIBS ON)
+if(USE_SYSTEM_LIBS)
+	set(USE_INTERNAL_LIBS OFF)
+endif()
+
+option(USE_INTERNAL_JPEG "If set, use bundled libjpeg." ${USE_INTERNAL_LIBS})
+option(USE_INTERNAL_MAD  "If set, use bundled libmad."  ${USE_INTERNAL_LIBS})
+option(USE_INTERNAL_ZLIB "If set, use bundled zlib."    ${USE_INTERNAL_LIBS})
 
 if(TARGET_GAME_TYPE)
 	message(SEND_ERROR "TARGET_GAME_TYPE is now unsupported, it is now done at runtime.")
@@ -14,14 +22,35 @@ endif()
 set(TARGET_BASE_GAME "./")
 set(CMAKE_DEBUG_POSTFIX "-dbg")
 
+#
+# Microsoft compiler specific parameters
+#
 if(MSVC)
 	add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	# Treat no return type as error
+	add_compile_options(/we4715)
+endif()
+
+#
+# Clang and GCC specific parameters
+#
+if(CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	add_compile_options(-Wno-comment)
+	# Treat no return type as error
+	add_compile_options(-Werror=return-type)
+endif()
+
+#
+# Clang specific parameters
+#
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	# Ignore warnings for code like 'assert("Assert string")'
 	add_compile_options(-Wno-pointer-bool-conversion)
 endif()
 
+#
+# GCC specific parameters
+#
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	# Add this option on gcc to prevent functions from having the STB_GNU_UNIQUE binding
 	# Otherwise, it would prevent libraries from being unloaded
@@ -39,6 +68,8 @@ ELSE()
 	set(TARGET_ARCH_SUFFIX ${TARGET_ARCH})
 ENDIF()
 
+set(TARGET_BIN_SUFFIX ".${TARGET_ARCH}")
+
 message(STATUS "Architecture detected: ${TARGET_ARCH}, suffix set to ${TARGET_ARCH_SUFFIX}.")
 
 IF(WIN32)
@@ -52,7 +83,7 @@ ELSE()
 ENDIF()
 
 IF(CMAKE_BUILD_TYPE MATCHES Debug)
-	add_definitions(-D_DEBUG)
+	add_compile_definitions(_DEBUG)
 
 	# NOTE: The following may mess up function importation
 	#if(UNIX)
@@ -60,18 +91,60 @@ IF(CMAKE_BUILD_TYPE MATCHES Debug)
 	#	set(CMAKE_ENABLE_EXPORTS ON)
 	#	message(STATUS "Enabling exports on Unix for backtrace")
 	#endif()
+ELSE()
+	# Non-debug builds
+	add_compile_definitions(NDEBUG)
 ENDIF()
 
-# Common stuff
+if(APPLE)
+	# macOS doesn't search the executable path by default
+	# so, locate libraries like SDL in the executable path
+	set(CMAKE_INSTALL_RPATH "@executable_path")
+	set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
 
+	if(CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")
+		# Set the visibility to hidden on macOS to prevent shared libraries from
+		# using functions in the executable
+		# it's ok to hide them because the backtrace on macOS will still print the name of the functions
+		add_compile_options(-fvisibility=hidden)
+	endif()
+endif()
+
+#
+# Setup the installation directory
+#
+if(WIN32)
+	# By default, both DLLs and EXEs are in the same directory
+	set(CMAKE_DEFAULT_INSTALL_RUNTIME_DIR bin)
+	set(BIN_INSTALL_SUBDIR ".")
+	set(LIB_INSTALL_SUBDIR ".")
+else()
+	# Unix
+	set(CMAKE_DEFAULT_INSTALL_RUNTIME_DIR lib)
+	set(BIN_INSTALL_SUBDIR ${CMAKE_PROJECT_NAME})
+	set(LIB_INSTALL_SUBDIR ${CMAKE_PROJECT_NAME})
+endif()
+
+# By default, put both binaries and shared libraries in the same directory
+# the game uses internal shared libraries that must be in the same folder as the binaries
+set(CMAKE_INSTALL_BINDIR ${CMAKE_DEFAULT_INSTALL_RUNTIME_DIR} CACHE PATH "Binary dir")
+set(CMAKE_INSTALL_LIBDIR ${CMAKE_INSTALL_BINDIR} CACHE PATH "Library dir")
+include(GNUInstallDirs)
+
+#
+# Common stuff
+#
 add_subdirectory("code/qcommon")
 add_subdirectory("code/gamespy")
 
+#
 # Application
-
+#
 add_subdirectory("code/sys")
 
+##
 ## Server app
+##
 add_subdirectory("code/server")
 
 add_executable(omohaaded "code/null/null_client.c" "code/null/null_input.c" "code/null/null_snddma.c")
@@ -82,24 +155,26 @@ target_link_libraries(omohaaded PRIVATE omohserver)
 target_link_libraries(omohaaded PRIVATE syslib)
 target_link_libraries(omohaaded PRIVATE qcommon qcommon_standalone)
 
-# Gamespy dependency
+# Add the gamespy dependency
 target_include_directories(omohaaded PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server")
-set_target_properties(omohaaded PROPERTIES OUTPUT_NAME "omohaaded${TARGET_BASE_SUFFIX}${TARGET_ARCH_SUFFIX}")
+set_target_properties(omohaaded PROPERTIES OUTPUT_NAME "omohaaded${TARGET_BIN_SUFFIX}")
 set_target_properties(omohaaded PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
 
+INSTALL(TARGETS omohaaded DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})
+
 if (MSVC)
 	target_link_options(omohaaded PRIVATE "/MANIFEST:NO")
-	INSTALL(FILES $<TARGET_PDB_FILE:omohaaded> DESTINATION "./" OPTIONAL)
+	INSTALL(FILES $<TARGET_PDB_FILE:omohaaded> DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR} OPTIONAL)
 endif()
 
-INSTALL(TARGETS omohaaded DESTINATION "./")
-
 if (NOT BUILD_NO_CLIENT)
+	##
 	## Client app
+	##
 
+	add_subdirectory("code/client")
 	add_subdirectory("code/renderer")
 	add_subdirectory("code/sdl")
-	add_subdirectory("code/client")
 
 	#include("code/renderergl2/glsl/shaders.cmake")
 	#file(GLOB_RECURSE SOURCES_RENDERER "code/sdl/*.c" "code/renderercommon/*.c" "code/renderergl2/*.c" "code/renderergl2/*.cpp")
@@ -112,27 +187,77 @@ if (NOT BUILD_NO_CLIENT)
 	target_link_libraries(openmohaa PRIVATE omohclient)
 	target_link_libraries(openmohaa PRIVATE omohrenderer omohsdl)
 	target_link_libraries(openmohaa PRIVATE qcommon qcommon_standalone)
-
-	### Gamespy dependency
-	target_include_directories(openmohaa PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server" "code/client" "code/uilib" "code/jpeg-8c")
-	set_target_properties(openmohaa PROPERTIES OUTPUT_NAME "openmohaa${TARGET_BASE_SUFFIX}${TARGET_ARCH_SUFFIX}")
+	
+	# Add the gamespy dependency
+	target_include_directories(openmohaa PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server" "code/client" "code/uilib")
+	set_target_properties(openmohaa PROPERTIES OUTPUT_NAME "openmohaa${TARGET_BIN_SUFFIX}")
 	set_target_properties(openmohaa PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
 
-	target_link_libraries(openmohaa PRIVATE jpeg8)
-	if (USE_OPENAL)
-		# Try to use OpenAL
-		find_package(OpenAL)
-		if (OPENAL_FOUND)
-			target_compile_definitions(openmohaa PRIVATE USE_OPENAL=1)
-			target_include_directories(openmohaa PRIVATE ${OPENAL_INCLUDE_DIR})
-			target_link_libraries(openmohaa PRIVATE ${OPENAL_LIBRARY})
-		endif()
+	if(USE_INTERNAL_JPEG)
+		target_include_directories(openmohaa PUBLIC "code/jpeg-8c")
+		target_link_libraries(openmohaa PRIVATE jpeg8)
+	else()
+		find_package(JPEG REQUIRED)
+		target_include_directories(openmohaa PUBLIC ${JPEG_INCLUDE_DIRS})
+		target_link_libraries(openmohaa PRIVATE ${JPEG_LIBRARIES})
 	endif()
 
+	INSTALL(TARGETS openmohaa DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})
+
 	if (MSVC)
 		target_link_options(openmohaa PRIVATE "/MANIFEST:NO")
-		INSTALL(FILES $<TARGET_PDB_FILE:openmohaa> DESTINATION "./" OPTIONAL)
+		INSTALL(FILES $<TARGET_PDB_FILE:openmohaa> DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR} OPTIONAL)
 	endif()
 
-	INSTALL(TARGETS openmohaa DESTINATION "./")
+	if(UNIX AND NOT APPLE)
+		#
+		# Desktop entries installation on Unix
+		#
+		set(TARGET_ARCH ${TARGET_BIN_SUFFIX})
+
+		# Configure the .desktop entries with the arch suffix
+		configure_file(
+			misc/linux/org.openmoh.openmohaa.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaa.desktop
+			@ONLY
+		)
+		configure_file(
+			misc/linux/org.openmoh.openmohaab.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaab.desktop
+			@ONLY
+		)
+		configure_file(
+			misc/linux/org.openmoh.openmohaas.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaas.desktop
+			@ONLY
+		)
+
+		# Install .desktop entries
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaa.desktop  DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaab.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaas.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+
+		install(FILES misc/linux/org.openmoh.openmohaa.metainfo.xml DESTINATION ${CMAKE_INSTALL_DATADIR}/metainfo)
+
+		install(FILES misc/openmohaa.svg DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/symbolic/apps/ RENAME org.openmoh.openmohaa.svg)
+	endif()
 endif()
+
+#
+# Launcher
+#
+add_subdirectory(code/Launcher)
+
+#
+# uninstall target
+#
+if(NOT TARGET uninstall)
+  configure_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+    IMMEDIATE @ONLY)
+
+  add_custom_target(uninstall
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+endif()
+

README.md

@@ -1,153 +1,45 @@
 # OpenMoHAA
 
-![Build](https://github.com/openmoh/openmohaa/actions/workflows/build-cmake.yml/badge.svg?branch=main) [![Release](https://img.shields.io/github/v/release/openmoh/openmohaa)](https://github.com/openmoh/openmohaa/releases) [![Downloads](https://img.shields.io/github/downloads/openmoh/openmohaa/total)](https://github.com/openmoh/openmohaa/releases)
+[![Build](https://github.com/openmoh/openmohaa/actions/workflows/branches-build.yml/badge.svg?branch=main)](https://github.com/openmoh/openmohaa/actions/workflows/branches-build.yml) [![Release](https://img.shields.io/github/v/release/openmoh/openmohaa)](https://github.com/openmoh/openmohaa/releases) [![Downloads](https://img.shields.io/github/downloads/openmoh/openmohaa/total)](https://github.com/openmoh/openmohaa/releases)
 
 ![License](https://img.shields.io/github/license/openmoh/openmohaa) ![Commits](https://img.shields.io/github/commit-activity/t/openmoh/openmohaa)
 
 ![Discord](https://img.shields.io/discord/596049712579215361?logo=discord&logoColor=white&color=5865F2)
 
-
-```
-     / _ \ _ __   ___ _ __ |  \/  |/ _ \| | | |  / \      / \
-    | | | | '_ \ / _ \ '_ \| |\/| | | | | |_| | / _ \    / _ \
-    | |_| | |_) |  __/ | | | |  | | |_| |  _  |/ ___ \  / ___ \
-     \___/| .__/ \___|_| |_|_|  |_|\___/|_| |_/_/   \_\/_/   \_\
-          |_|
-```
-
-## Current State
-
-OpenMoHAA is still under development. The single-player campaign is not yet functional due to AI not being fully stable. But the `training` map can be played from start to end. The current focus is on multiplayer.
+![logo](misc/openmohaa-text-sm.png)
 
 ## Intro
 
-The main goal of OpenMoHAA is to ensure the future and continuity of **Medal of Honor: Allied Assault**. It has always been a dream in the community to provide patches and security fixes for the game. Thanks to the ioquake3 project, F.A.K.K SDK and other quality tools, OpenMoHAA has already reached more than half of its goal: to create an open-source version of MoH:AA (based on version 2.40) that is fully compatible with the original game (in terms of protocol, assets, and scripts).
+The main goal of OpenMoHAA is to ensure the future and continuity of **Medal of Honor: Allied Assault** on all platforms/architectures by providing new patches/features. Thanks to the ioquake3 project and the F.A.K.K SDK, OpenMoHAA has already reached more than half of its goal: an open-source version of MoH:AA (based on version 2.40) that is fully compatible with the original game (in terms of protocol, assets, and scripts).
 
-## Running
+## Getting started
 
-Ensure that you download the binaries compatible with your platform.
+- [Downloading and installing OpenMoHAA](docs/getting_started_installation.md)
+- [Running OpenMoHAA and using expansion assets](docs/getting_started_running.md)
+- [Dedicated server configuration](docs/configuration/server.md)
 
-### Requirements
+## Current state
 
-You may need to install Microsoft Visual C++ 2015/2017/2019/2022 Redistributable from https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170
+### Single-player
 
-### Client
+The entire single-player campaign should work (Allied Assault, Spearhead and Breakthrough). If you encounter any bug, please create a new [GitHub issue](https://github.com/openmoh/openmohaa/issues) describing them.
 
-a) extract archive to your MOHAA installation directory.
+### Multiplayer
 
--or-
+The Multiplayer part is almost fully stable.
 
-b) extract archive somewhere on your hard drive, create a shortcut to openmohaa (or omohaaded), and set the start directory to your MOHAA installation directory.
+Server admins can use OpenMoHAA to [host](docs/getting_started_installation.md#server) a mohaa/mohaas/mohaab server. Bugs must be reported by creating a new [issue](https://github.com/openmoh/openmohaa/issues) on the OpenMoHAA GitHub project. Players can use OpenMoHAA to [play](docs/getting_started_installation.md#client) on a mohaa/mohaas/mohaab server.
 
-### Server
+All game modes including `Tug-of-War` from Medal of Honor: Spearhead, and `Liberation` from Medal of Honor: Breakthrough are implemented and are working as intended. Mods like `Freeze-Tag` are working as well.
 
-Extract the archive to your MOHAA server installation directory. Then proceed like you would do with mohaa server:
+## Features
 
-- `.\omohaaded.exe +exec server.cfg` on Windows
-- `./omohaaded +exec server.cfg` on Linux
-
-Only `omohaaded*` and `game*` binaries are required for the server version, other binaries can be omitted.
-
-### Config file
-
-The config file can be found in different locations depending on the platform:
-
-- `%APPDATA%\openmohaa\<game_name>\configs\omconfig.cfg` on Windows
-- `~/.openmohaa/<game_name>/configs/omconfig.cfg` on Linux
-
-This has two advantages:
-- On a multi-user system, each user will have their own configuration file
-- It doesn't overwrite the existing MOHAA configuration in the MOHAA installation directory.
-
-### Game selection
-
-**Medal of Honor: Allied Assault Spearhead** and **Medal of Honor: Allied Assault Breakthrough** are supported in OpenMoHAA using the `com_target_game` variable. To play an expansion, append the following command-line arguments to the executable:
-
-- `+set com_target_game 1` for Spearhead (mohaas/mohta)
-- `+set com_target_game 2` for Breakthrough (mohaab/mohtt)
-
-On Windows, you can create a shortcut to OpenMoHAA with these command-line arguments.
-The default value of `com_target_game` is 0 for the base game (main).
-
-With `com_target_game`, OpenMoHAA will support the network protocol accordingly.
-
-You can now start a local OpenMOHAA server or play on a server.
-
-### Playing with bots
-
-OpenMoHAA has a basic bot system that emulates real players. The maximum number of bots is defined by the `sv_maxbots` variable, and the number of initial bots is defined by the `sv_numbots` variable. Bots can also be added or removed using the `addbot` and `removebot` commands.
-
-This feature is a great way to test the gameplay and mods.
-
-## Builds
-
-### Server
-
-The server version can be built successfully, but some features are not functional. For example, the Actor system is almost fully implemented, but it is not yet stable. This means that Actor may not work as expected and could cause crashes.
-
-Overall, the server and the fgame components are almost fully implemented, but they may not be completely stable. There could be some minor bugs (and rare crashes), but the game should be playable.
-
-### Client
-
-The client version of OpenMoHAA has undergone partial implementation, with the cgame module being nearly completed. Credits to the SDK of **Heavy Metal: F.A.K.K. 2** both the cgame and fgame modules.
-
-The current operational status for each component is as follow:
-
-| Component               | Full | Almost | Half | Early | Bad | Not working | Comment                                                           |
-|-------------------------|------|--------|------|-------|-----|-------------|-------------------------------------------------------------------|
-| Audio                   |      |        |      |       | x   |             | Very basic implementation from Quake III                          |
-| CG Module               |      | x      |      |       |     |             | Missing FX, Marks and decals                                      |
-| Client                  |      | x      |      |       |     |             | Missing GameSpy, server list, binds, map picker, ...              |
-| Collision               | x    |        |      |       |     |             |                                                                   |
-| Model/TIKI/Skeletor     | x    |        |      |       |     |             |                                                                   |
-| Renderer                |      | x      |      |       |     |             | Missing ghost, marks, sphere lights, sky portal, sun flare, swipe |
-| Server                  |      | x      |      |       |     |             | Probably a few bugs remaining                                     |
-| Server module (fgame)   |      | x      |      |       |     |             | Actor, and few gameplay bugs                                      |
-| UI                      |      |        | x    |       |     |             | Has core features only (menu, widgets, console, hud, urc loading) |
+- [List of new features](docs/features.md)
+- [Scripting commands](https://htmlpreview.github.io/?https://github.com/openmoh/openmohaa/blob/main/docs/features_g_allclasses.html)
 
 ## Compiling
 
-OpenMoHAA supports any architecture, thanks to the CMake build system and cross-platform code/libraries. While the most common little-Endian architectures (arm, aarch64, x86, x86_64) have been tested and confirmed to work, big-Endian architectures should be supported as well; however, they remain untested.
-
-The following tools are required for all platforms:
-- CMake >= 3.5
-- Flex (>= 2.6.4) and Bison (>= 3.5.1)
-- A C++11 compiler is also required.
-
-The installation directory can be set to the MOHAA directory.
-
-By default, the build will produce both the client and dedicated server versions. The client can be omitted from the build by appending `-DBUILD_NO_CLIENT=1` to the CMake command-line arguments. Using this parameter will result in only the server portion being built.
-
-### Linux
-
-These are the tools required on Linux :
-- Clang >= 3.3 or GCC >= 4.8.5
-- libsdl2-dev
-
-**clang-3.5** and **gcc-4.8.5** should work (tested on Ubuntu 16.04), but the latest version should be used.
-
-Ubuntu 20.04 is the minimum version required to fully compile the project successfully.
-
-1 line install command with clang:
-```sh
-sudo apt-get install -y cmake ninja-build clang lld flex bison libsdl2-dev
-```
-
-Example with **CMake** and **ninja-build** installed:
-```sh
-mkdir .cmake && cd .cmake
-cmake -G Ninja ../
-```
-
-Other compilers can be specified by appending `-DCMAKE_C_COMPILER=/path/to/compiler -DCMAKE_CXX_COMPILER=path/to/compiler` to the CMake command-line.
-
-### Windows
-
-Visual Studio (2019 or 2022) is generally preferred.
-
-Flex and Bison can be downloaded from here: https://github.com/lexxmark/winflexbison/releases/tag/v2.5.25
-
-Append `-DFLEX_EXECUTABLE=...\win_flex.exe -DBISON_EXECUTABLE=...\win_bison.exe` to the CMake command-line to use the package from the link above.
+- See [Compiling OpenMoHAA](docs/compiling.md)
 
 ## Screenshots
 
@@ -159,41 +51,6 @@ Append `-DFLEX_EXECUTABLE=...\win_flex.exe -DBISON_EXECUTABLE=...\win_bison.exe`
 
 *More screenshots [here](docs/images)*
 
-## Features
-
-### Features added and not present in MOH:AA
-
-#### Server-side
-
-- Bots
-- Spectate players in first-person
-- Demo recording
-- More script commands for mods
-- Non-PVS optimization
-
-##### Non-PVS optimization
-
-For each client, the server optimizes by only sending them information about other players that they can see. Clients won't see other players they can't see.
-
-Enable this feature with `set sv_netoptimize 2`.
-
-#### Client-side and server-side
-
-- Security fixes and features from ioquake3
-- IPv6 support (from ioquake3)
-
-### Objectives / planned features
-
-This is a non-exhaustive list of objectives and planned features.
-
-#### Server-side
-
-- 100% compatibility with mohaa content
-- More feature for mods
-- Anticheat
-- Stats system
-- Multiple roles/abilities for server admins to reduce password-stealing
-
 ## Third party
 
 ### SDL

TargetArch.cmake

@@ -3,8 +3,12 @@ set(archdetect_c_code "
 #  error cmake_ARCH x86
 #elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
 #  error cmake_ARCH x86_64
-#elif defined(__ppc64__) || defined(__powerpc64__)
-#  error cmake_ARCH ppc64
+#elif defined(__PPC64__) || defined(__ppc64__) || defined(__powerpc64__) || defined(_ARCH_PPC64)
+#  if __BIG_ENDIAN__
+#    error cmake_ARCH ppc64
+#  else
+#    error cmake_ARCH ppc64el
+#  endif
 #elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__)
 #  error cmake_ARCH ppc
 #elif defined __s390__
@@ -19,10 +23,14 @@ set(archdetect_c_code "
 #  error cmake_ARCH alpha
 #elif defined __sparc__
 #  error cmake_ARCH sparc
-#elif defined __arm__ || defined (_M_ARM)
-#  error cmake_ARCH arm
 #elif defined(__aarch64__) || defined(__ARM64__) || defined(_M_ARM64)
-#  error cmake_ARCH aarch64
+#  error cmake_ARCH arm64
+#elif defined __arm__ || defined (_M_ARM)
+#  if defined(__ARM_PCS_VFP) && (__ARM_PCS_VFP)
+#    error cmake_ARCH armhf
+#  else
+#    error cmake_ARCH armel
+#  endif
 #elif defined __cris__
 #  error cmake_ARCH cris
 #elif defined __hppa__
@@ -63,12 +71,14 @@ function(target_architecture output_var)
         foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
             if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
                 set(osx_arch_ppc TRUE)
+            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
+                set(osx_arch_ppc64 TRUE)
             elseif("${osx_arch}" STREQUAL "i386")
                 set(osx_arch_i386 TRUE)
             elseif("${osx_arch}" STREQUAL "x86_64")
                 set(osx_arch_x86_64 TRUE)
-            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
-                set(osx_arch_ppc64 TRUE)
+            elseif("${osx_arch}" STREQUAL "arm64")
+                set(osx_arch_arm64 TRUE)
             else()
                 message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
             endif()
@@ -79,6 +89,10 @@ function(target_architecture output_var)
             list(APPEND ARCH ppc)
         endif()
 
+        if(osx_arch_ppc64)
+            list(APPEND ARCH ppc64)
+        endif()
+
         if(osx_arch_i386)
             list(APPEND ARCH i386)
         endif()
@@ -87,8 +101,8 @@ function(target_architecture output_var)
             list(APPEND ARCH x86_64)
         endif()
 
-        if(osx_arch_ppc64)
-            list(APPEND ARCH ppc64)
+        if(osx_arch_arm64)
+            list(APPEND ARCH arm64)
         endif()
     else()
     	# figure out extension for the source file

cmake_uninstall.cmake.in

@@ -0,0 +1,21 @@
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif()
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    execute_process(
+      COMMAND "@CMAKE_COMMAND@" -E remove "$ENV{DESTDIR}${file}"
+      OUTPUT_VARIABLE rm_out
+      RESULT_VARIABLE rm_retval
+      )
+    if(NOT "${rm_retval}" STREQUAL 0)
+      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    endif()
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif()
+endforeach()

code/Launcher/CMakeLists.txt

@@ -0,0 +1,36 @@
+project(Launcher)
+
+set(LAUNCHER_SOURCES "${CMAKE_SOURCE_DIR}/code/Launcher/launch_main.cpp")
+
+if (WIN32)
+    set(LAUNCHER_SOURCES ${LAUNCHER_SOURCES}
+    "${CMAKE_SOURCE_DIR}/code/Launcher/launch_win32.cpp"
+    "${CMAKE_SOURCE_DIR}/code/sys/win_resource.rc")
+else()
+    set(LAUNCHER_SOURCES ${LAUNCHER_SOURCES}
+    "${CMAKE_SOURCE_DIR}/code/Launcher/launch_linux.cpp")
+endif()
+
+function (create_launcher name type)
+    if (NOT BUILD_NO_CLIENT)
+        add_executable(openmohaa_launcher_${name} ${LAUNCHER_SOURCES})
+        target_include_directories(openmohaa_launcher_${name} PUBLIC "../qcommon")
+        target_compile_definitions(openmohaa_launcher_${name} PRIVATE NO_RC_MANIFEST=1 TARGET_GAME=${type})
+        target_compile_features(openmohaa_launcher_${name} PRIVATE cxx_std_17)
+        set_target_properties(openmohaa_launcher_${name} PROPERTIES OUTPUT_NAME "launch_openmohaa_${name}${TARGET_BIN_SUFFIX}")
+
+        INSTALL(TARGETS openmohaa_launcher_${name} DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})
+    endif()
+
+    #add_executable(omohaaded_launcher_${name} ${LAUNCHER_SOURCES})
+    #target_include_directories(omohaaded_launcher_${name} PUBLIC "../qcommon")
+    #target_compile_definitions(omohaaded_launcher_${name} PRIVATE NO_RC_MANIFEST=1 TARGET_GAME=${type} DEDICATED=1)
+    #target_compile_features(omohaaded_launcher_${name} PRIVATE cxx_std_17)
+    #set_target_properties(omohaaded_launcher_${name} PROPERTIES OUTPUT_NAME "launch_omohaaded_${name}${TARGET_BIN_SUFFIX}")
+    #
+    #INSTALL(TARGETS omohaaded_launcher_${name} DESTINATION ${CMAKE_INSTALL_BINDIR}/${PROJECT_INSTALL_SUBDIR})
+endfunction()
+
+create_launcher(base 0)
+create_launcher(spearhead 1)
+create_launcher(breakthrough 2)

code/Launcher/launch.h

@@ -0,0 +1,32 @@
+/*
+===========================================================================
+Copyright (C) 2024 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// launch.h: Base interface for starting programs
+
+#include "q_platform.h"
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+std::filesystem::path GetProgramLocation();
+void LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList);

code/Launcher/launch_linux.cpp

@@ -0,0 +1,80 @@
+/*
+===========================================================================
+Copyright (C) 2024 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: Windows implementation of the launcher
+
+#include "launch.h"
+
+#include <unistd.h>
+#include <spawn.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+
+#include <string>
+#include <iostream>
+
+extern "C" char** environ;
+
+std::filesystem::path GetProgramLocation()
+{
+    char path[FILENAME_MAX];
+    ssize_t count = readlink("/proc/self/exe", path, FILENAME_MAX);
+
+    return std::filesystem::path(std::string(path, (count > 0) ? count : 0)).parent_path();
+}
+
+void LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList)
+{
+    pid_t pid;
+    std::string pathString = path.string();
+    size_t argCount = argumentList.size();
+    char** argv;
+    int status;
+
+    argv = new char*[argCount + 2];
+    argv[0] = (char*)pathString.c_str();
+
+    for (size_t i = 0; i < argCount; i++) {
+        argv[i + 1] = (char*)argumentList[i].c_str();
+    }
+    argv[argCount + 1] = NULL;
+
+    //status = posix_spawn(&pid, pathString.c_str(), NULL, NULL, argv, environ);
+    //delete[] argv;
+    //if (status != 0) {
+    //    std::cout << "posix_spawn returned error: " << status << std::endl;
+    //    return;
+    //}
+
+    //
+    // Using execve rather than posix_spawn
+    //  This replaces the current process that is not needed anyway
+    //
+    status = execve(pathString.c_str(), argv, environ);
+    delete[] argv;
+    if (status == -1) {
+        std::cout << "posix_spawn returned error: " << errno << std::endl;
+        return;
+    }
+
+    waitpid(pid, NULL, 0);
+}

code/Launcher/launch_main.cpp

@@ -0,0 +1,67 @@
+/*
+===========================================================================
+Copyright (C) 2024 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: The launcher
+
+#include "launch.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+const char* targetGameList[] =
+{
+    "Base",
+    "Spearhead",
+    "Breakthrough"
+};
+
+int main(int argc, const char* argv[]) {
+    std::vector<std::string> argumentList;
+#if !defined(DEDICATED) || !DEDICATED
+    const char* programName = "openmohaa" "." ARCH_STRING DLL_SUFFIX EXE_EXT;
+#else
+    const char* programName = "omohaaded" "." ARCH_STRING DLL_SUFFIX EXE_EXT;
+#endif
+
+    argumentList.push_back("+set");
+    argumentList.push_back("com_target_game");
+    argumentList.push_back(std::to_string(TARGET_GAME));
+
+    for (size_t i = 1; i < argc; i++) {
+        argumentList.push_back(argv[i]);
+    }
+
+    std::cout << "Using the target game: " << targetGameList[TARGET_GAME] << std::endl;
+    std::cout << std::endl;
+    std::cout << "Expected program name: " << programName << std::endl;
+
+    const std::filesystem::path programLocation = GetProgramLocation();
+    const std::filesystem::path programPath = programLocation / programName;
+
+    std::cout << "Program location: " << programLocation << std::endl;
+    std::cout << "Expected path: " << programPath << std::endl;
+
+    LaunchProgram(programPath, argumentList);
+
+    return 0;
+}

code/Launcher/launch_win32.cpp

@@ -0,0 +1,87 @@
+/*
+===========================================================================
+Copyright (C) 2024 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: Windows implementation of the launcher
+
+#include "launch.h"
+
+#include <Windows.h>
+#include <string>
+#include <iostream>
+
+std::filesystem::path GetProgramLocation()
+{
+    wchar_t path[FILENAME_MAX] = { 0 };
+    GetModuleFileNameW(nullptr, path, FILENAME_MAX);
+
+    return std::filesystem::path(path).parent_path();
+}
+
+void LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList)
+{
+    PROCESS_INFORMATION processInfo;
+    STARTUPINFOW startupInfo;
+    BOOL returnValue;
+    std::wstring osCommandLine;
+    std::wstring commandLine;
+    size_t argCount = argumentList.size();
+
+    memset(&processInfo, 0, sizeof(processInfo));
+    memset(&startupInfo, 0, sizeof(startupInfo));
+    startupInfo.cb = sizeof(startupInfo);
+
+    for (size_t i = 0; i < argCount; i++) {
+        commandLine += L"\"";
+        commandLine += std::wstring(argumentList[i].begin(), argumentList[i].end());
+        commandLine += L"\"";
+        if (i != argCount - 1) {
+            commandLine += L" ";
+        }
+    }
+
+    osCommandLine = path.wstring();
+    osCommandLine += L" ";
+    osCommandLine += commandLine;
+
+    returnValue = CreateProcessW(
+        path.wstring().c_str(),
+        (LPWSTR)osCommandLine.c_str(),
+        NULL,
+        NULL,
+        FALSE,
+        0,
+        NULL,
+        std::filesystem::current_path().wstring().c_str(),
+        &startupInfo,
+        &processInfo
+    );
+
+    if (!returnValue) {
+        std::cout << "Error in CreateProcess: " << GetLastError() << std::endl;
+        return;
+    }
+
+    WaitForSingleObject(processInfo.hProcess, INFINITE);
+
+    CloseHandle(processInfo.hProcess);
+    CloseHandle(processInfo.hThread);
+}

code/autoupdater/autoupdater.c

@@ -933,10 +933,13 @@ static void waitToApplyUpdates(void)
                OS forcibly closes the pipe), we will unblock. Then we can loop on
                kill() until the process is truly gone. */
             int x = 0;
+            struct timespec req;
+            req.tv_sec = 0;
+            req.tv_nsec = 100000000;
             read(3, &x, sizeof (x));
             info("Pipe has closed, waiting for process to fully go away now.");
             while (kill(options.waitforprocess, 0) == 0) {
-                usleep(100000);
+                nanosleep(&req, NULL);
             }
             #endif
         }

code/cgame/CMakeLists.txt

@@ -27,16 +27,11 @@ target_compile_features(cgame PUBLIC cxx_nullptr)
 target_compile_features(cgame PUBLIC c_variadic_macros)
 target_link_libraries(cgame PUBLIC qcommon)
 
-set_target_properties(cgame PROPERTIES PREFIX "${TARGET_PLATFORM_PREFIX}")
-set_target_properties(cgame PROPERTIES OUTPUT_NAME "cgame${TARGET_ARCH_SUFFIX}")
-set_target_properties(cgame PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TARGET_BASE_GAME}")
+set_target_properties(cgame PROPERTIES PREFIX "")
+set_target_properties(cgame PROPERTIES OUTPUT_NAME "cgame${TARGET_BIN_SUFFIX}")
 
-INSTALL(
-	TARGETS cgame
-	LIBRARY DESTINATION "${TARGET_BASE_GAME}"
-	RUNTIME DESTINATION "${TARGET_BASE_GAME}"
-)
+INSTALL(TARGETS cgame DESTINATION ${CMAKE_INSTALL_LIBDIR}/${LIB_INSTALL_SUBDIR})
 
 if(MSVC)
-	INSTALL(FILES $<TARGET_PDB_FILE:cgame> DESTINATION "${TARGET_BASE_GAME}" OPTIONAL)
+	INSTALL(FILES $<TARGET_PDB_FILE:cgame> DESTINATION ${CMAKE_INSTALL_LIBDIR}/${LIB_INSTALL_SUBDIR} OPTIONAL)
 endif()

code/cgame/cg_archive.cpp

@@ -113,7 +113,7 @@ void CG_ArchiveModelHandle(MemArchiver& archiver, qhandle_t* handle)
 		if (tmp.length()) {
 			*handle = cgi.R_RegisterModel(tmp.c_str());
 		} else {
-			*handle = NULL;
+			*handle = (qhandle_t)0;
 		}
 	} else {
 		if (*handle) {
@@ -135,7 +135,7 @@ void CG_ArchiveShaderHandle(MemArchiver& archiver, qhandle_t* handle)
 		if (tmp.length()) {
 			*handle = cgi.R_RegisterShader(tmp.c_str());
 		} else {
-			*handle = NULL;
+			*handle = (qhandle_t)0;
 		}
 	} else {
 		if (*handle) {
@@ -163,7 +163,7 @@ void CG_ArchiveRefEntity(MemArchiver& archiver, refEntity_t* ref)
     archiver.ArchiveVec3(ref->axis[2]);
     archiver.ArchiveBoolean(&ref->nonNormalizedAxes);
     archiver.ArchiveVec3(ref->origin);
-    archiver.ArchiveRaw(ref->frameInfo, 192);
+    archiver.ArchiveRaw(ref->frameInfo, sizeof(ref->frameInfo));
     archiver.ArchiveFloat(&ref->actionWeight);
     archiver.ArchiveShort(&ref->wasframe);
     archiver.ArchiveFloat(&ref->scale);
@@ -171,7 +171,7 @@ void CG_ArchiveRefEntity(MemArchiver& archiver, refEntity_t* ref)
     archiver.ArchiveInteger(&ref->skinNum);
 
     CG_ArchiveShaderHandle(archiver, &ref->customShader);
-    archiver.ArchiveRaw(ref->shaderRGBA, 4);
+    archiver.ArchiveRaw(ref->shaderRGBA, sizeof(ref->shaderRGBA));
     archiver.ArchiveFloat(ref->shaderTexCoord);
     archiver.ArchiveFloat(&ref->shaderTexCoord[1]);
     archiver.ArchiveFloat(&ref->shaderTime);

code/cgame/cg_commands.cpp

@@ -196,7 +196,8 @@ Event EV_Client_SetColorVelocity
     "rVel gVel bVel",
     "Set the color velocity of the spawned dlight tempmodel"
 );
-Event EV_Client_SetRandomVelocity(
+Event EV_Client_SetRandomVelocity
+(
     "randvel",
     EV_DEFAULT,
     "SfFSfFSfF",
@@ -210,7 +211,8 @@ Event EV_Client_SetRandomVelocity(
     "without randomness.\n"
     "This velocity is applied using the world axis"
 );
-Event EV_Client_SetRandomVelocityAlongAxis(
+Event EV_Client_SetRandomVelocityAlongAxis
+(
     "randvelaxis",
     EV_DEFAULT,
     "SfFSfFSfF",
@@ -225,6 +227,14 @@ Event EV_Client_SetRandomVelocityAlongAxis(
     "without randomness.\n"
     "This velocity is applied using the parent axis"
 );
+Event EV_Client_NoTagAxis
+(
+    "notagaxis",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Forces the effect to use the model's orientation for randvelaxis and offsetalongaxis"
+);
 Event EV_Client_SetAccel
 (
     "accel",
@@ -554,7 +564,16 @@ Event EV_Client_LoopSound
     EV_DEFAULT,
     "sFFf",
     "soundName volume min_distance pitch",
-    "Play the specifed sound as a looping sound"
+    "Play the specified sound as a looping sound"
+);
+// Added in 2.0
+Event EV_Client_StopLoopSound
+(
+    "stoploopsound",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Stop the looping sound"
 );
 Event EV_Client_Cache
 (
@@ -975,7 +994,7 @@ Event EV_Client_BounceDecal(
     "maxamount temporary",
     "Put a mark when the tempmodel bounces and hits a surface\n"
     "maxamount = Max amount of decals to make when bouncing\n"
-    "temporary = specify 1 for a temporary mark that only appears for a short time, 0 for a decal that stays aroung "
+    "temporary = specify 1 for a temporary mark that only appears for a short time, 0 for a decal that stays around "
     "longer (default is 0)\n"
 );
 Event EV_Client_SetDecalRadius
@@ -1075,6 +1094,15 @@ Event EV_Client_Print
     "string",
     "Prints a string."
 );
+// Added in 2.0
+Event EV_Client_PrintDeathMsg
+(
+    "printdeathmsg",
+    EV_DEFAULT,
+    "sssss",
+    "msg1, msg2, killer, victim, deathType",
+    "Prints a death message string.  Used to allow death messages to appear in their correct language on client machines.."
+);
 Event EV_Client_SetVolumetric
 (
     "volumetric",
@@ -1112,7 +1140,7 @@ Event EV_Client_SetAlignStretch(
     EV_DEFAULT,
     "F",
     "scaleMultiplier",
-    "Aligns the temp model to the direction of travel, and stretches it betwen the last and current positions.\n"
+    "Aligns the temp model to the direction of travel, and stretches it between the last and current positions.\n"
 );
 Event EV_Client_SetClampVelocity
 (
@@ -1185,6 +1213,14 @@ Event EV_Client_SFXStartDelayed
     "fDelay sCommand arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8",
     "Used for adding commands to a special effect with a time delay"
 );
+Event EV_Client_PlayForceFeedback
+(
+    "playforcefeedback",
+    EV_DEFAULT,
+    "s",
+    "effectname",
+    "Starts a force feedback effect."
+);
 
 EffectsEventQueueNode EffectsEventQueue;
 
@@ -1221,6 +1257,7 @@ CLASS_DECLARATION(Listener, ClientGameCommandManager, NULL) {
     {&EV_Client_SetColorVelocity,           &ClientGameCommandManager::SetAngularVelocity        },
     {&EV_Client_SetRandomVelocity,          &ClientGameCommandManager::SetRandomVelocity         },
     {&EV_Client_SetRandomVelocityAlongAxis, &ClientGameCommandManager::SetRandomVelocityAlongAxis},
+    {&EV_Client_NoTagAxis,                  &ClientGameCommandManager::SetNoTagAxis              },
     {&EV_Client_SetAccel,                   &ClientGameCommandManager::SetAccel                  },
     {&EV_Client_SetFriction,                &ClientGameCommandManager::SetFriction               },
     {&EV_Client_SetSpin,                    &ClientGameCommandManager::SetSpin                   },
@@ -1250,6 +1287,7 @@ CLASS_DECLARATION(Listener, ClientGameCommandManager, NULL) {
     {&EV_Client_StopSound,                  &ClientGameCommandManager::StopSound                 },
     {&EV_Client_StopAliasChannel,           &ClientGameCommandManager::StopAliasChannel          },
     {&EV_Client_LoopSound,                  &ClientGameCommandManager::LoopSound                 },
+    {&EV_Client_StopLoopSound,              &ClientGameCommandManager::StopLoopSound             },
     {&EV_Client_Cache,                      &ClientGameCommandManager::Cache                     },
     {&EV_Client_CacheImage,                 &ClientGameCommandManager::CacheImage                },
     {&EV_Client_CacheFont,                  &ClientGameCommandManager::CacheFont                 },
@@ -1312,6 +1350,7 @@ CLASS_DECLARATION(Listener, ClientGameCommandManager, NULL) {
     {&EV_Client_SetClampVelocity,           &ClientGameCommandManager::SetClampVel               },
     {&EV_Client_SetClampVelocityAxis,       &ClientGameCommandManager::SetClampVelAxis           },
     {&EV_Client_Print,                      &ClientGameCommandManager::Print                     },
+    {&EV_Client_PrintDeathMsg,              &ClientGameCommandManager::PrintDeathMsg             },
     {&EV_Client_EyeLimits,                  &ClientGameCommandManager::SetEyeLimits              },
     {&EV_Client_EyeMovement,                &ClientGameCommandManager::SetEyeMovement            },
     {&EV_Client_SFXStart,                   &ClientGameCommandManager::StartSFX                  },
@@ -1383,9 +1422,11 @@ qboolean ClientGameCommandManager::PostEventForEntity(Event *ev, float fWait)
     EffectsEventQueueNode *node;
     int                    inttime;
 
-    if (!m_fEventWait || current_entity_number < 0) {
-        if (!str::icmp(ev->getName(), ")")) {
-            m_fEventWait = 0.0;
+    if (m_fEventWait < 0 || current_entity_number < 0) {
+        if (m_fEventWait != 0.0) {
+            if (!str::icmp(ev->getName(), ")")) {
+                m_fEventWait = 0.0;
+            }
         }
 
         delete ev;
@@ -1402,7 +1443,7 @@ qboolean ClientGameCommandManager::PostEventForEntity(Event *ev, float fWait)
     event   = EffectsEventQueue.next;
     inttime = EVENT_msec + (fWait * 1000.0f + 0.5f);
 
-    while (event != &EffectsEventQueue && inttime > event->inttime) {
+    while (event != &EffectsEventQueue && inttime >= event->inttime) {
         event = event->next;
     }
 
@@ -1438,8 +1479,8 @@ void ClientGameCommandManager::SetBaseAndAmplitude(Event *ev, Vector& base, Vect
             base[j]      = ev->GetFloat(i++);
             amplitude[j] = ev->GetFloat(i++);
         } else {
-            base[j]      = 0.0;
-            amplitude[j] = atof(org.c_str());
+            base[j]      = atof(org.c_str());
+            amplitude[j] = 0.0;
         }
     }
 }
@@ -1462,6 +1503,13 @@ void ClientGameCommandManager::Print(Event *ev)
     }
 }
 
+void ClientGameCommandManager::PrintDeathMsg(Event* ev)
+{
+    if (current_entity) {
+        cgi.DPrintf("%d:%s\n", current_entity->entityNumber, ev->GetString(1).c_str());
+    }
+}
+
 qboolean ClientGameCommandManager::IsBlockCommand(const str& name)
 {
     if (!str::icmp(name, "originspawn")) {
@@ -1541,7 +1589,6 @@ void ClientGameCommandManager::CommandDelay(Event *ev)
         ev1->AddValue(ev->GetValue(i));
     }
 
-    delay = ev->GetFloat(1) * 1000;
     if (current_entity_number != -1) {
         PostEventForEntity(ev1, fWait);
     } else {
@@ -1551,6 +1598,16 @@ void ClientGameCommandManager::CommandDelay(Event *ev)
             current_tiki->name
         );
     }
+
+    if (IsBlockCommand(eventName)) {
+        m_fEventWait = fWait;
+    } else {
+        m_fEventWait = 0;
+    }
+
+    if (current_entity_number == -1 && m_fEventWait > 0) {
+        m_fEventWait = -1;
+    }
 }
 
 void ClientGameCommandManager::StartSFX(Event *ev)
@@ -2157,7 +2214,9 @@ void ClientGameCommandManager::SetInwardSphere(Event *ev)
     }
 
     m_spawnthing->cgd.flags |= T_INWARDSPHERE;
-    m_spawnthing->sphereRadius = ev->GetFloat(1);
+    if (ev->NumArgs() > 0) {
+        m_spawnthing->sphereRadius = ev->GetFloat(1);
+    }
 }
 
 //=============
@@ -2586,7 +2645,9 @@ void ClientGameCommandManager::SetColorRange(Event *ev)
         return;
     }
 
-    // FIXME: unused stub??
+    //
+    // Unused
+    //
 }
 
 //=============
@@ -2666,6 +2727,15 @@ void ClientGameCommandManager::SetRandomVelocityAlongAxis(Event *ev)
     SetRandomVelocity(ev);
 }
 
+void ClientGameCommandManager::SetNoTagAxis(Event* ev)
+{
+    if (!m_spawnthing) {
+        return;
+    }
+
+    m_spawnthing->cgd.flags2 |= T2_NOTAGAXIS;
+}
+
 void ClientGameCommandManager::SetRadialVelocity(Event *ev)
 {
     if (!m_spawnthing) {
@@ -2803,7 +2873,9 @@ void ClientGameCommandManager::SetAccel(Event *ev)
     m_spawnthing->cgd.accel[1] = ev->GetFloat(2);
     m_spawnthing->cgd.accel[2] = ev->GetFloat(3);
 
-    m_spawnthing->cgd.flags2 |= T2_ACCEL;
+    if (!(m_spawnthing->cgd.flags & T_SWARM)) {
+        m_spawnthing->cgd.flags2 |= T2_ACCEL;
+    }
 }
 
 void ClientGameCommandManager::SetFriction(Event *ev)
@@ -3032,7 +3104,7 @@ spawnthing_t *ClientGameCommandManager::InitializeSpawnthing(spawnthing_t *sp)
     sp->cgd.parent             = -1;
     sp->cgd.tiki               = nullptr;
     sp->cgd.lightstyle         = -1;
-    sp->cgd.physicsRate        = 10;
+    sp->cgd.physicsRate        = cg_effect_physicsrate->integer;
     sp->cgd.shadername         = "beamshader";
     sp->cgd.decal_orientation  = 0;
     sp->cgd.decal_radius       = 10;
@@ -3851,7 +3923,7 @@ void ClientGameCommandManager::PlaySound(
         } else {
             if (debugSound->integer) {
                 Com_Printf(
-                    "\nWARNING: OVERRIDE OVERRIDE OVERRIDESound %s had all its parm overriden by code.\n\n",
+                    "\nWARNING: OVERRIDE OVERRIDE OVERRIDESound %s had all its parm overridden by code.\n\n",
                     sound_name.c_str()
                 );
             }
@@ -3965,6 +4037,9 @@ void ClientGameCommandManager::StopSound(Event *ev)
     cgi.S_StopSound(current_entity_number, channel);
 }
 
+//===============
+// StopAliasChannel
+//===============
 void ClientGameCommandManager::StopAliasChannel(Event *ev)
 {
     str              sound_name;
@@ -4060,6 +4135,54 @@ void ClientGameCommandManager::LoopSound(Event *ev)
     current_centity->tikiLoopSoundFlags   = 0;
 }
 
+//===============
+// StopLoopSound
+//===============
+void ClientGameCommandManager::StopLoopSound(Event* ev)
+{
+    if (!current_centity) {
+        cgi.DPrintf("CCM::StopLoopSound : StopLoopSound in %s without current_centity\n", cgi.TIKI_Name(current_tiki));
+        return;
+    }
+
+    Com_Printf("\n\nClientGameCommandManager::StopLoopSound\n\n");
+    current_centity->tikiLoopSound = NULL;
+}
+
+//===============
+// CacheImageResource
+//===============
+void CacheImageResource(const char* stuff) {
+    str real_stuff;
+    char filename[1024];
+
+    if (cgi.fsDebug->integer == 2) {
+        Com_Printf("client cacheimage: %s\n", stuff);
+    }
+
+    Q_strncpyz(filename, stuff, sizeof(filename));
+    cgi.FS_CanonicalFilename(filename);
+
+    cgi.R_RegisterShaderNoMip(filename);
+}
+
+//===============
+// CacheFontResource
+//===============
+void CacheFontResource(const char* stuff) {
+    str real_stuff;
+    char filename[1024];
+
+    if (cgi.fsDebug->integer == 2) {
+        Com_Printf("client cacheimage: %s\n", stuff);
+    }
+
+    Q_strncpyz(filename, stuff, sizeof(filename));
+    cgi.FS_CanonicalFilename(filename);
+
+    cgi.R_LoadFont(filename);
+}
+
 //===============
 // CacheResource
 //===============
@@ -4099,12 +4222,12 @@ void ClientGameCommandManager::Cache(Event *ev)
 
 void ClientGameCommandManager::CacheImage(Event *ev)
 {
-    // FIXME: stub
+    CacheImageResource(ev->GetString(1).c_str());
 }
 
 void ClientGameCommandManager::CacheFont(Event *ev)
 {
-    // FIXME: stub
+    CacheFontResource(ev->GetString(1).c_str());
 }
 
 //===============
@@ -4112,15 +4235,16 @@ void ClientGameCommandManager::CacheFont(Event *ev)
 //===============
 void AliasResource(dtiki_t *pmdl, const char *alias, const char *realname, const char *parameters)
 {
-    if (pmdl) {
-        if (!pmdl->a->alias_list) {
-            pmdl->a->alias_list = cgi.AliasList_New(pmdl->a->name);
-        }
-
-        cgi.Alias_ListAdd((AliasList_t *)pmdl->a->alias_list, alias, realname, parameters);
-    } else {
+    if (!pmdl) {
         cgi.Alias_Add(alias, realname, parameters);
+        return;
     }
+
+    if (!pmdl->a->alias_list) {
+        pmdl->a->alias_list = cgi.AliasList_New(pmdl->a->name);
+    }
+
+    cgi.Alias_ListAdd((AliasList_t*)pmdl->a->alias_list, alias, realname, parameters);
 }
 
 qboolean bLoadForMap(const char *psMapsBuffer, const char *name)
@@ -4181,19 +4305,32 @@ void ClientGameCommandManager::AliasCache(Event *ev)
     psMapsBuffer  = NULL;
 
     for (i = 3; i <= ev->NumArgs(); i++) {
-        if (!strcmp(ev->GetToken(i).c_str(), "maps")) {
+        str s = ev->GetString(i);
+
+        if (!s.icmp("maps")) {
             i++;
-            psMapsBuffer = ev->GetToken(i);
-        } else if (!strcmp(ev->GetToken(i).c_str(), "always")) {
-            bAlwaysLoaded = true;
-        } else {
-            strcat(parmbuffer, ev->GetToken(i));
-            strcat(parmbuffer, " ");
+            psMapsBuffer = (char *)ev->GetToken(i).c_str();
+            continue;
         }
+
+        if (!s.icmp("always")) {
+            bAlwaysLoaded = true;
+            continue;
+        }
+
+        strcat(parmbuffer, s);
+        strcat(parmbuffer, " ");
     }
 
-    if (bAlwaysLoaded || bLoadForMap(psMapsBuffer, ev->GetString(1))) {
+    if (bAlwaysLoaded) {
         AliasResource(current_tiki, ev->GetString(1), ev->GetString(2), parmbuffer);
+    }
+
+    if (bLoadForMap(psMapsBuffer, ev->GetString(1))) {
+        if (!bAlwaysLoaded) {
+            AliasResource(current_tiki, ev->GetString(1), ev->GetString(2), parmbuffer);
+        }
+
         CacheResource(ev->GetString(2));
     }
 }
@@ -4223,28 +4360,33 @@ void ClientGameCommandManager::Alias(Event *ev)
     psMapsBuffer  = NULL;
 
     for (i = 3; i <= ev->NumArgs(); i++) {
-        if (!strcmp(ev->GetToken(i).c_str(), "maps")) {
+        str s = ev->GetString(i);
+
+        if (!s.icmp("maps")) {
             i++;
-            psMapsBuffer = ev->GetToken(i);
-        } else if (!strcmp(ev->GetToken(i).c_str(), "always")) {
+            psMapsBuffer = (char *)ev->GetToken(i).c_str();
+            continue;
+        }
+
+        if (!s.icmp("always")) {
             bAlwaysLoaded = true;
+        } else if (subtitle) {
+            strcat(parmbuffer, "\"");
+            strcat(parmbuffer, s);
+            strcat(parmbuffer, "\" ");
+
+            subtitle = 0;
         } else {
+            subtitle = s.icmp("subtitle") == 0;
+
             if (!subtitle) {
-                if (!Q_stricmp(ev->GetToken(i), "subtitle") || !Q_stricmp(ev->GetToken(i), "forcesubtitle")) {
-                    subtitle = qtrue;
-                    strcat(parmbuffer, ev->GetToken(i));
-                } else {
-                    strcat(parmbuffer, ev->GetToken(i));
-                }
-            } else {
-                strcat(parmbuffer, "\"");
-                strcat(parmbuffer, ev->GetToken(i));
-                strcat(parmbuffer, "\"");
-                subtitle = qfalse;
+                subtitle = s.icmp("forcesubtitle") == 0;
             }
 
-            strcat(parmbuffer, " ");
+            strcat(parmbuffer, s);
         }
+
+        strcat(parmbuffer, " ");
     }
 
     if (bAlwaysLoaded || bLoadForMap(psMapsBuffer, ev->GetString(1))) {
@@ -4976,7 +5118,15 @@ bool ClientGameCommandManager::GetTagPositionAndOrientation(str tagname, orienta
 //===============
 void ClientGameCommandManager::RestartAllEmitters(void)
 {
-    // FIXME: stub??
+    ctempmodel_t *p;
+
+    //
+    // FIXME: not sure if it's the right thing
+    //
+
+    for (p = m_active_tempmodels.prev; p != &m_active_tempmodels; p = p->next) {
+        p->cgd.createTime = cg.time;
+    }
 }
 
 //===============
@@ -5187,7 +5337,7 @@ void CG_ClientCommandDebugMessage(centity_t *cent, const char *fmt, ...)
         char    msg[1024];
 
         va_start(argptr, fmt);
-        vsprintf(msg, fmt, argptr);
+        Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
         va_end(argptr);
 
         if ((!cg_debugAnimWatch->integer) || ((cg_debugAnimWatch->integer - 1) == cent->currentState.number)) {
@@ -5342,7 +5492,7 @@ qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *c
     current_tiki = NULL;
 
     // Update the loading screen
-    sprintf(tempName, "m%s", filename);
+    Com_sprintf(tempName, sizeof(tempName), "m%s", filename);
     cgi.LoadResource(tempName);
 
     bufstart = buffer;
@@ -5351,7 +5501,7 @@ qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *c
         Event *ev;
 
         // grab each line as we go
-        strcpy(com_token, COM_ParseExt(&buffer, qtrue));
+        Q_strncpyz(com_token, COM_ParseExt(&buffer, qtrue), sizeof(com_token));
         if (!com_token[0]) {
             break;
         }
@@ -5359,7 +5509,7 @@ qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *c
         if (!Q_stricmp(com_token, "end") || !Q_stricmp(com_token, "server")) {
             // skip the line
             while (1) {
-                strcpy(com_token, COM_ParseExt(&buffer, qfalse));
+                Q_strncpyz(com_token, COM_ParseExt(&buffer, qfalse), sizeof(com_token));
                 if (!com_token[0]) {
                     break;
                 }
@@ -5372,7 +5522,7 @@ qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *c
 
         // get the rest of the line
         while (1) {
-            strcpy(com_token, COM_ParseExt(&buffer, qfalse));
+            Q_strncpyz(com_token, COM_ParseExt(&buffer, qfalse), sizeof(com_token));
             if (!com_token[0]) {
                 break;
             }
@@ -5384,7 +5534,7 @@ qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *c
     cgi.FS_FreeFile((void *)bufstart);
 
     // Update the loading screen
-    sprintf(tempName, "o%s", filename);
+    Com_sprintf(tempName, sizeof(tempName), "o%s", filename);
     cgi.LoadResource(tempName);
 
     return qtrue;

code/cgame/cg_commands.h

@@ -113,6 +113,7 @@ TIKI file, similar to ScriptMaster in the server game dll.
 #define T2_VARYCOLOR          (1 << 20)
 #define T2_SPIN               (1 << 21)
 #define T2_RELATIVEANGLES     (1 << 22)
+#define T2_NOTAGAXIS          (1 << 23)
 
 class spawnthing_t;
 class specialeffect_t;
@@ -763,6 +764,7 @@ private:
     void          SpawnVSSSource(int count, int timealive);
     void          EventViewKick(Event *ev);
     void          Print(Event *ev);
+    void          PrintDeathMsg(Event *ev); // Added in 2.0
     void          StartBlock(Event *ev);
     void          EndBlock(Event *ev);
     void          UpdateSpawnThing(spawnthing_t *ep);
@@ -788,6 +790,7 @@ private:
     void          SetScaleRate(Event *ev);
     void          SetRandomVelocity(Event *ev);
     void          SetRandomVelocityAlongAxis(Event *ev);
+    void          SetNoTagAxis(Event *ev); // Added in 2.0
     void          SetAccel(Event *ev);
     void          SetFriction(Event *ev);
     void          SetSpin(Event *ev);
@@ -849,6 +852,7 @@ private:
     void          StopSound(Event *ev);
     void          StopAliasChannel(Event *ev);
     void          LoopSound(Event *ev);
+    void          StopLoopSound(Event *ev); // Added in 2.0
     void          Cache(Event *ev);
     void          CacheImage(Event *ev);
     void          CacheFont(Event *ev);

code/cgame/cg_consolecmds.c

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2008-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -25,6 +25,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 // text commands typed in at the local console, or executed by a key binding
 
 #include "cg_local.h"
+#include "../fgame/bg_voteoptions.h"
 
 void CG_TargetCommand_f(void);
 
@@ -159,17 +160,157 @@ baseshader_t *CG_GetShaderUnderCrosshair(qboolean bVerbose, trace_t *pRetTrace)
 
 static void CG_PrintContentTypes(int iContentFlags)
 {
-    // FIXME: unimplemented
+    if (iContentFlags & CONTENTS_SOLID) {
+        cgi.Printf(" solid");
+    }
+    if (iContentFlags & CONTENTS_LAVA) {
+        cgi.Printf(" lava");
+    }
+    if (iContentFlags & CONTENTS_SLIME) {
+        cgi.Printf(" slime");
+    }
+    if (iContentFlags & CONTENTS_WATER) {
+        cgi.Printf(" water");
+    }
+    if (iContentFlags & CONTENTS_FOG) {
+        cgi.Printf(" fog");
+    }
+    if (iContentFlags & CONTENTS_FENCE) {
+        cgi.Printf(" fence");
+    }
+    if (iContentFlags & CONTENTS_AREAPORTAL) {
+        cgi.Printf(" areaportal");
+    }
+    if (iContentFlags & CONTENTS_PLAYERCLIP) {
+        cgi.Printf(" playerclip");
+    }
+    if (iContentFlags & CONTENTS_VEHICLECLIP) {
+        cgi.Printf(" vehicleclip");
+    }
+    if (iContentFlags & CONTENTS_MONSTERCLIP) {
+        cgi.Printf(" monsterclip");
+    }
+    if (iContentFlags & CONTENTS_WEAPONCLIP) {
+        cgi.Printf(" weaponclip");
+    }
+    if (iContentFlags & CONTENTS_SHOOTONLY) {
+        cgi.Printf(" shootableonly");
+    }
+    if (iContentFlags & CONTENTS_ORIGIN) {
+        cgi.Printf(" origin");
+    }
+    if (iContentFlags & CONTENTS_TRANSLUCENT) {
+        cgi.Printf(" trans");
+    }
 }
 
 static void CG_PrintSurfaceProperties(int iSurfaceFlags)
 {
-    // FIXME: unimplemented
+    if (iSurfaceFlags & SURF_NODAMAGE) {
+        cgi.Printf(" nodamage");
+    }
+    if (iSurfaceFlags & SURF_SLICK) {
+        cgi.Printf(" slick");
+    }
+    if (iSurfaceFlags & SURF_SKY) {
+        cgi.Printf(" sky");
+    }
+    if (iSurfaceFlags & SURF_LADDER) {
+        cgi.Printf(" ladder");
+    }
+    if (iSurfaceFlags & SURF_NOIMPACT) {
+        cgi.Printf(" noimpact");
+    }
+    if (iSurfaceFlags & SURF_NOMARKS) {
+        cgi.Printf(" nomarks");
+    }
+    if (iSurfaceFlags & SURF_CASTSHADOW) {
+        cgi.Printf(" castshadow");
+    }
+    if (iSurfaceFlags & SURF_NODRAW) {
+        cgi.Printf(" nodraw");
+    }
+    if (iSurfaceFlags & SURF_NOLIGHTMAP) {
+        cgi.Printf(" nolightmap");
+    }
+    if (iSurfaceFlags & SURF_ALPHASHADOW) {
+        cgi.Printf(" alphashadow");
+    }
+    if (iSurfaceFlags & SURF_NOSTEPS) {
+        cgi.Printf(" nofootsteps");
+    }
+    if (iSurfaceFlags & SURF_NONSOLID) {
+        cgi.Printf(" nonsolid");
+    }
+    if (iSurfaceFlags & SURF_OVERBRIGHT) {
+        cgi.Printf(" overbright");
+    }
+    if (iSurfaceFlags & SURF_BACKSIDE) {
+        cgi.Printf(" backside");
+    }
+    if (iSurfaceFlags & SURF_NODLIGHT) {
+        cgi.Printf(" nodlight");
+    }
+    if (iSurfaceFlags & SURF_HINT) {
+        cgi.Printf(" hint");
+    }
+    if (iSurfaceFlags & SURF_PATCH) {
+        cgi.Printf(" patch");
+    }
 }
 
 static void CG_PrintSurfaceType(int iSurfType)
 {
-    // FIXME: unimplemented
+    switch (iSurfType & MASK_SURF_TYPE) {
+    case SURF_FOLIAGE:
+        cgi.Printf("foliage");
+        break;
+    case SURF_SNOW:
+        cgi.Printf("snow");
+        break;
+    case SURF_CARPET:
+        cgi.Printf("carpet");
+        break;
+    case SURF_SAND:
+        cgi.Printf("sand");
+        break;
+    case SURF_PUDDLE:
+        cgi.Printf("puddle");
+        break;
+    case SURF_GLASS:
+        cgi.Printf("glass");
+        break;
+    case SURF_GRAVEL:
+        cgi.Printf("gravel");
+        break;
+    case SURF_MUD:
+        cgi.Printf("mud");
+        break;
+    case SURF_DIRT:
+        cgi.Printf("dirt");
+        break;
+    case SURF_GRILL:
+        cgi.Printf("metal grill");
+        break;
+    case SURF_GRASS:
+        cgi.Printf("grass");
+        break;
+    case SURF_ROCK:
+        cgi.Printf("rock");
+        break;
+    case SURF_PAPER:
+        cgi.Printf("paper");
+        break;
+    case SURF_WOOD:
+        cgi.Printf("wood");
+        break;
+    case SURF_METAL:
+        cgi.Printf("metal");
+        break;
+    default:
+        cgi.Printf("!!*none specified*!!");
+        break;
+    }
 }
 
 void CG_GetCHShader(void)
@@ -215,9 +356,9 @@ void CG_EditCHShader(void)
 
     pShader = CG_GetShaderUnderCrosshair(qfalse, NULL);
     if (pShader) {
-        strcpy(name, "editspecificshader ");
-        strcat(name, pShader->shader);
-        strcat(name, "\n");
+        Q_strncpyz(name, "editspecificshader ", sizeof(name));
+        Q_strcat(name, sizeof(name), pShader->shader);
+        Q_strcat(name, sizeof(name), "\n");
         cgi.AddCommand(name);
     } else {
         cgi.Printf("No surface selected\n");
@@ -339,56 +480,65 @@ typedef struct {
 } consoleCommand_t;
 
 static consoleCommand_t commands[] = {
-    {"useweaponclass",        &CG_UseWeaponClass_f      },
-    {"weapnext",              &CG_NextWeapon_f          },
-    {"weapprev",              &CG_PrevWeapon_f          },
-    {"uselast",               &CG_UseLastWeapon_f       },
-    {"holster",               &CG_HolsterWeapon_f       },
-    {"weapdrop",              &CG_DropWeapon_f          },
-    {"toggleitem",            &CG_ToggleItem_f          },
-    {"+scores",               &CG_ScoresDown_f          },
-    {"-scores",               &CG_ScoresUp_f            },
-    {"viewpos",               &CG_Viewpos_f             },
-    {"sizeup",                &CG_SizeUp_f              },
-    {"sizedown",              &CG_SizeDown_f            },
-    {"cg_eventlist",          &CG_EventList_f           },
-    {"cg_eventhelp",          &CG_EventHelp_f           },
-    {"cg_dumpevents",         &CG_DumpEventHelp_f       },
-    {"cg_pendingevents",      &CG_PendingEvents_f       },
-    {"cg_classlist",          &CG_ClassList_f           },
-    {"cg_classtree",          &CG_ClassTree_f           },
-    {"cg_classevents",        &CG_ClassEvents_f         },
-    {"cg_dumpclassevents",    &CG_DumpClassEvents_f     },
-    {"cg_dumpallclasses",     &CG_DumpAllClasses_f      },
-    {"testemitter",           &CG_TestEmitter_f         },
-    {"triggertestemitter",    &CG_TriggerTestEmitter_f  },
-    {"prevemittercommand",    &CG_PrevEmitterCommand_f  },
-    {"nextemittercommand",    &CG_NextEmitterCommand_f  },
-    {"newemittercommand",     &CG_NewEmitterCommand_f   },
-    {"deleteemittercommand",  &CG_DeleteEmitterCommand_f},
-    {"dumpemitter",           &CG_DumpEmitter_f         },
-    {"loademitter",           &CG_LoadEmitter_f         },
-    {"resetvss",              &CG_ResetVSSSources       },
-    {"getchshader",           &CG_GetCHShader           },
-    {"editchshader",          &CG_EditCHShader          },
-    {"messagemode",           &CG_MessageMode_f         },
-    {"messagemode_all",       &CG_MessageMode_All_f     },
-    {"messagemode_team",      &CG_MessageMode_Team_f    },
-    {"messagemode_private",   &CG_MessageMode_Private_f },
-    {"say",                   &CG_MessageSingleAll_f    },
-    {"sayteam",               &CG_MessageSingleTeam_f   },
-    {"teamsay",               &CG_MessageSingleTeam_f   },
-    {"sayprivate",            &CG_MessageSingleClient_f },
-    {"sayone",                &CG_MessageSingleClient_f },
-    {"wisper",                &CG_MessageSingleClient_f },
-    {"instamsg_main",         &CG_InstaMessageMain_f    },
-    {"instamsg_group_a",      &CG_InstaMessageGroupA_f  },
-    {"instamsg_group_b",      &CG_InstaMessageGroupB_f  },
-    {"instamsg_group_c",      &CG_InstaMessageGroupC_f  },
-    {"instamsg_group_d",      &CG_InstaMessageGroupD_f  },
-    {"instamsg_group_e",      &CG_InstaMessageGroupE_f  },
-    {"pushmenu_teamselect",   &CG_PushMenuTeamSelect_f  },
-    {"pushmenu_weaponselect", &CG_PushMenuWeaponSelect_f},
+    {"useweaponclass",         &CG_UseWeaponClass_f        },
+    {"weapnext",               &CG_NextWeapon_f            },
+    {"weapprev",               &CG_PrevWeapon_f            },
+    {"uselast",                &CG_UseLastWeapon_f         },
+    {"holster",                &CG_HolsterWeapon_f         },
+    {"weapdrop",               &CG_DropWeapon_f            },
+    {"toggleitem",             &CG_ToggleItem_f            },
+    {"+scores",                &CG_ScoresDown_f            },
+    {"-scores",                &CG_ScoresUp_f              },
+    {"viewpos",                &CG_Viewpos_f               },
+    {"sizeup",                 &CG_SizeUp_f                },
+    {"sizedown",               &CG_SizeDown_f              },
+    {"cg_eventlist",           &CG_EventList_f             },
+    {"cg_eventhelp",           &CG_EventHelp_f             },
+    {"cg_dumpevents",          &CG_DumpEventHelp_f         },
+    {"cg_pendingevents",       &CG_PendingEvents_f         },
+    {"cg_classlist",           &CG_ClassList_f             },
+    {"cg_classtree",           &CG_ClassTree_f             },
+    {"cg_classevents",         &CG_ClassEvents_f           },
+    {"cg_dumpclassevents",     &CG_DumpClassEvents_f       },
+    {"cg_dumpallclasses",      &CG_DumpAllClasses_f        },
+    {"testemitter",            &CG_TestEmitter_f           },
+    {"triggertestemitter",     &CG_TriggerTestEmitter_f    },
+    {"prevemittercommand",     &CG_PrevEmitterCommand_f    },
+    {"nextemittercommand",     &CG_NextEmitterCommand_f    },
+    {"newemittercommand",      &CG_NewEmitterCommand_f     },
+    {"deleteemittercommand",   &CG_DeleteEmitterCommand_f  },
+    {"dumpemitter",            &CG_DumpEmitter_f           },
+    {"loademitter",            &CG_LoadEmitter_f           },
+    {"resetvss",               &CG_ResetVSSSources         },
+    {"getchshader",            &CG_GetCHShader             },
+    {"editchshader",           &CG_EditCHShader            },
+    {"messagemode",            &CG_MessageMode_f           },
+    {"messagemode_all",        &CG_MessageMode_All_f       },
+    {"messagemode_team",       &CG_MessageMode_Team_f      },
+    {"messagemode_private",    &CG_MessageMode_Private_f   },
+    {"say",                    &CG_MessageSingleAll_f      },
+    {"sayteam",                &CG_MessageSingleTeam_f     },
+    {"teamsay",                &CG_MessageSingleTeam_f     },
+    {"sayprivate",             &CG_MessageSingleClient_f   },
+    {"sayone",                 &CG_MessageSingleClient_f   },
+    {"wisper",                 &CG_MessageSingleClient_f   },
+    {"instamsg_main",          &CG_InstaMessageMain_f      },
+    {"instamsg_group_a",       &CG_InstaMessageGroupA_f    },
+    {"instamsg_group_b",       &CG_InstaMessageGroupB_f    },
+    {"instamsg_group_c",       &CG_InstaMessageGroupC_f    },
+    {"instamsg_group_d",       &CG_InstaMessageGroupD_f    },
+    {"instamsg_group_e",       &CG_InstaMessageGroupE_f    },
+    {"pushmenu_teamselect",    &CG_PushMenuTeamSelect_f    },
+    {"pushmenu_weaponselect",  &CG_PushMenuWeaponSelect_f  },
+    // Added in 2.0
+    {"pushcallvote",           &CG_PushCallVote_f          },
+    {"pushcallvotesublist",    &CG_PushCallVoteSubList_f   },
+    {"pushcallvotesubtext",    &CG_PushCallVoteSubText_f   },
+    {"pushcallvotesubinteger", &CG_PushCallVoteSubInteger_f},
+    {"pushcallvotesubfloat",   &CG_PushCallVoteSubFloat_f  },
+    {"pushcallvotesubclient",  &CG_PushCallVoteSubClient_f },
+    {"pushvote",               &CG_PushVote_f              },
+    {"callentryvote",          &CG_CallEntryVote_f         },
 };
 
 /*

code/cgame/cg_drawtools.cpp

@@ -675,14 +675,17 @@ void CG_DrawObjectives()
 {
     float        vColor[4];
     float        fX, fY;
+    int          iNumObjectives;
+    float        fObjectivesTop;
     static float fWidth;
     float        fHeight;
     int          iNumLines[20];
     int          iTotalNumLines;
     int          i;
-    int          ii;
     int          iCurrentObjective;
     float        fTimeDelta;
+    const char   *pszLocalizedText;
+    const char   *pszLine;
 
     iTotalNumLines = 0;
     for (i = CS_OBJECTIVES; i < CS_OBJECTIVES + MAX_OBJECTIVES; ++i) {
@@ -702,26 +705,30 @@ void CG_DrawObjectives()
         return;
     }
 
-    for (i = 0; i < MAX_OBJECTIVES; i++) {
-        if ((cg.Objectives[i].flags & 0xFFFFFFFE)) {
-            iNumLines[i] = 0;
+    // Added in 2.0
+    //  Get the minimum Y value, it should be below the compass
+    fObjectivesTop = cgi.UI_GetObjectivesTop();
+    iNumObjectives = 0;
 
-            for (ii = 0; ii < MAX_STRING_CHARS; ii++) {
-                if (cg.Objectives[i].text[ii] == '\n') {
-                    iTotalNumLines++;
-                    iNumLines[i]++;
-                } else if (!cg.Objectives[i].text[ii]) {
-                    iTotalNumLines++;
-                    iNumLines[i]++;
-                    break;
-                }
-            }
+    for (i = 0; i < MAX_OBJECTIVES; i++) {
+        if ((cg.Objectives[i].flags == OBJ_FLAG_NONE) || (cg.Objectives[i].flags & OBJ_FLAG_HIDDEN)) {
+            continue;
         }
+
+        iNumObjectives++;
+        iNumLines[i] = 0;
+        pszLocalizedText = cgi.LV_ConvertString(cg.Objectives[i].text);
+        
+        for (pszLine = strchr(pszLocalizedText, '\n'); pszLine; pszLine = strchr(pszLine + 1, '\n')) {
+            iNumLines[i]++;
+        }
+
+        iTotalNumLines += iNumLines[i];
     }
 
     fX        = 25.0;
-    fY        = 125.0;
-    fWidth    = (float)(25 * iTotalNumLines + 155) + 5.0 - 130.0;
+    fY        = fObjectivesTop + 5;
+    fWidth    = (float)(iTotalNumLines * 12 + fObjectivesTop + iNumObjectives * 25 + 32) - fY;
     vColor[2] = 0.2f;
     vColor[1] = 0.2f;
     vColor[0] = 0.2f;
@@ -730,7 +737,7 @@ void CG_DrawObjectives()
     cgi.R_DrawStretchPic(fX, fY, 450.0, fWidth, 0.0, 0.0, 1.0, 1.0, cgs.media.objectivesBackShader);
 
     fX        = 30.0;
-    fY        = 130.0;
+    fY        = fObjectivesTop + 10;
     vColor[0] = 1.0;
     vColor[1] = 1.0;
     vColor[2] = 1.0;
@@ -740,12 +747,12 @@ void CG_DrawObjectives()
     fY = fY + 5.0;
 
     cgi.R_DrawString(cgs.media.objectiveFont, "_______________________________________________________", fX, fY, -1, 0);
-    fHeight = 155.0;
+    fHeight = fObjectivesTop + 35;
 
     for (i = 0; i < MAX_OBJECTIVES; ++i) {
         qhandle_t hBoxShader;
-
-        if ((cg.Objectives[i].flags & OBJ_FLAG_HIDDEN) || !cg.Objectives[i].flags) {
+        
+        if ((cg.Objectives[i].flags == OBJ_FLAG_NONE) || (cg.Objectives[i].flags & OBJ_FLAG_HIDDEN)) {
             continue;
         }
 
@@ -789,7 +796,7 @@ void CG_DrawObjectives()
         cgi.R_SetColor(vColor);
         cgi.R_DrawStretchPic(fX, fY, 16.0, 16.0, 0.0, 0.0, 1.0, 1.0, hBoxShader);
 
-        fHeight += 25 * iNumLines[i];
+        fHeight += iNumLines[i] * 12 + 25;
     }
 }
 
@@ -927,6 +934,8 @@ void CG_UpdateAttackerDisplay()
 
 void CG_UpdateCountdown()
 {
+    const char* message = "";
+
     if (!cg.snap) {
         return;
     }
@@ -937,16 +946,24 @@ void CG_UpdateCountdown()
         iSecondsLeft = (cgs.matchEndTime - cg.time) / 1000;
         if (iSecondsLeft >= 0) {
             iMinutesLeft = iSecondsLeft / 60;
-            cgi.Cvar_Set(
-                "ui_timemessage", va("%s %2i:%02i", cgi.LV_ConvertString("Time Left:"), iMinutesLeft, iSecondsLeft % 60)
-            );
+            message = va("%s %2i:%02i", cgi.LV_ConvertString("Time Left:"), iMinutesLeft, iSecondsLeft % 60);
         } else if (!cgs.matchEndTime) {
-            cgi.Cvar_Set("ui_timemessage", "");
+            message = "";
         }
     } else {
         // The match has not started yet
-        cgi.Cvar_Set("ui_timemessage", "Waiting For Players");
+        message = "Waiting For Players";
     }
+
+    if (strcmp(ui_timemessage->string, message)) {
+        cgi.Cvar_Set("ui_timemessage", message);
+    }
+}
+
+static void CG_RemoveStopwatch() {
+    cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+    cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_fuse\n");
+    cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_fuse_wet\n");
 }
 
 void CG_DrawStopwatch()
@@ -954,38 +971,55 @@ void CG_DrawStopwatch()
     int iFraction;
 
     if (!cg_hud->integer) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
 
     if (!cgi.stopWatch->iStartTime) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
 
     if (cgi.stopWatch->iStartTime >= cgi.stopWatch->iEndTime) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
 
     if (cgi.stopWatch->iEndTime <= cg.time) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
 
     if (cg.ObjectivesCurrentAlpha >= 0.02) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
 
     if (cg.snap && cg.snap->ps.stats[STAT_HEALTH] <= 0) {
-        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+        CG_RemoveStopwatch();
         return;
     }
+    if (cgi.stopWatch->eType >= SWT_FUSE_WET) {
+        iFraction = cgi.stopWatch->iEndTime - cgi.stopWatch->iStartTime;
+    } else {
+        iFraction = cgi.stopWatch->iEndTime - cg.time;
+    }
 
-    iFraction = cgi.stopWatch->iEndTime - cg.time;
     cgi.Cvar_Set("ui_stopwatch", va("%i", iFraction));
-    cgi.Cmd_Execute(EXEC_NOW, "ui_addhud hud_stopwatch\n");
+
+    switch (cgi.stopWatch->eType) {
+    case SWT_NORMAL:
+    default:
+        cgi.Cmd_Execute(EXEC_NOW, "ui_addhud hud_stopwatch\n");
+        break;
+    case SWT_FUSE:
+        cgi.Cmd_Execute(EXEC_NOW, "ui_addhud hud_fuse\n");
+        break;
+    case SWT_FUSE_WET:
+        cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_fuse\n");
+        cgi.Cmd_Execute(EXEC_NOW, "ui_addhud hud_fuse_wet\n");
+        break;
+    }
 }
 
 void CG_DrawInstantMessageMenu()
@@ -1085,7 +1119,7 @@ void CG_DrawSpectatorView_ver_15()
         char      buf[128];
 
         iClientNum = cg.snap->ps.stats[STAT_INFOCLIENT];
-        sprintf(buf, "%s : %i", cg.clientinfo[iClientNum].name, cg.snap->ps.stats[STAT_INFOCLIENT_HEALTH]);
+        Com_sprintf(buf, sizeof(buf), "%s : %i", cg.clientinfo[iClientNum].name, cg.snap->ps.stats[STAT_INFOCLIENT_HEALTH]);
 
         hShader  = 0;
         color[0] = 0.5;
@@ -1180,7 +1214,7 @@ void CG_DrawCrosshair()
     float      x, y;
     float      width, height;
 
-    shader = NULL;
+    shader = (qhandle_t)0;
 
     if (!cg_hud->integer || !ui_crosshair->integer) {
         return;
@@ -1190,7 +1224,7 @@ void CG_DrawCrosshair()
         return;
     }
 
-    if ((cg.snap->ps.pm_flags & PMF_NO_LEAN) || (cg.snap->ps.pm_flags & PMF_INTERMISSION)) {
+    if ((cg.snap->ps.pm_flags & PMF_NO_HUD) || (cg.snap->ps.pm_flags & PMF_INTERMISSION)) {
         return;
     }
 

code/cgame/cg_lightstyles.cpp

@@ -59,7 +59,7 @@ qboolean CG_LightStyleColor(int style, int realtime, vec4_t color, qboolean clam
 
     time = realtime / 50;
     frac = (realtime - (time * 50.0f)) / 50.0f;
-    memset(color, 0, sizeof(color));
+    VectorClear4(color);
     if ((style < 0) || (style >= (MAX_LIGHTSTYLES * 2))) {
         cgi.DPrintf("CG_LightStyleColor: style out of range.\n");
         return qtrue;

code/cgame/cg_local.h

@@ -187,6 +187,7 @@ extern "C" {
         float min_dist;
         float width;
         char  shader[MAX_RAIN_SHADERS][MAX_STRING_CHARS];
+        char  currentShader[MAX_STRING_CHARS];
         int   numshaders;
     } crain_t;
 
@@ -340,6 +341,7 @@ extern "C" {
         float        ObjectivesBaseAlpha;
         float        ObjectivesDesiredAlpha;
         float        ObjectivesCurrentAlpha;
+        int          ObjectivesCurrentIndex;
 
         // misc
         crain_t      rain;
@@ -429,6 +431,7 @@ extern "C" {
     extern cgs_t              cgs;
     extern cg_t               cg;
     extern clientGameImport_t cgi;
+    extern target_game_e      cg_target_game;
     extern int                cg_protocol;
     extern centity_t          cg_entities[MAX_GENTITIES];
     extern markPoly_t         *cg_markPolys;
@@ -500,6 +503,7 @@ extern "C" {
     extern cvar_t *voiceChat;
     extern cvar_t *cg_shadowscount;
     extern cvar_t *cg_shadowdebug;
+    extern cvar_t *ui_timemessage;
 
     //
     // cg_main.c
@@ -726,8 +730,8 @@ extern "C" {
     void CG_InitTestTreadMark();
     void CG_AddTreadMarks();
     int  CG_PermanentMark(
-         const vec3_t    origin,
-         const vec3_t    dir,
+         vec3_t          origin,
+         vec3_t          dir,
          float           orientation,
          float           fSScale,
          float           fTScale,
@@ -920,7 +924,8 @@ qboolean CG_LightStyleColor(int style, int realtime, vec4_t color, qboolean clam
     void CG_InstaMessageGroupD_f(void);
     void CG_InstaMessageGroupE_f(void);
     void CG_HudPrint_f(void);
-    int  CG_CheckCaptureKey(int key, qboolean down, unsigned int time);
+
+    qboolean CG_CheckCaptureKey(int key, qboolean down, unsigned int time);
 
     //
     // cg_vehicle.cpp

code/cgame/cg_main.c

@@ -35,12 +35,13 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 clientGameImport_t        cgi;
 static clientGameExport_t cge;
 
-cvar_t   *paused;
-cvar_t   *developer;
-cg_t      cg;
-cgs_t     cgs;
-int       cg_protocol;
-centity_t cg_entities[MAX_GENTITIES];
+cvar_t       *paused;
+cvar_t       *developer;
+cg_t          cg;
+cgs_t         cgs;
+target_game_e cg_target_game = TG_INVALID;
+int           cg_protocol;
+centity_t     cg_entities[MAX_GENTITIES];
 
 cvar_t *cg_animSpeed;
 cvar_t *cg_debugAnim;
@@ -109,6 +110,7 @@ cvar_t *vm_lean_lower;
 cvar_t *voiceChat;
 cvar_t *cg_shadowscount;
 cvar_t *cg_shadowdebug;
+cvar_t *ui_timemessage;
 
 /*
 =================
@@ -154,9 +156,9 @@ void CG_RegisterCvars(void)
     cg_shadowdebug                = cgi.Cvar_Get("cg_shadowdebug", "0", 0);
     developer                     = cgi.Cvar_Get("developer", "0", 0);
     dm_playermodel                = cgi.Cvar_Get("dm_playermodel", "american_army", 3);
-    dm_playergermanmodel          = cgi.Cvar_Get("dm_playergermanmodel", "german_wehrmacht_soldier", 3);
+    dm_playergermanmodel          = cgi.Cvar_Get("dm_playergermanmodel", "german_wehrmacht_soldier", CVAR_ARCHIVE | CVAR_USERINFO);
     cg_forceModel                 = cgi.Cvar_Get("cg_forceModel", "0", CVAR_ARCHIVE);
-    cg_animationviewmodel         = cgi.Cvar_Get("cg_animationviewmodel", "0", 8);
+    cg_animationviewmodel         = cgi.Cvar_Get("cg_animationviewmodel", "0", CVAR_SYSTEMINFO);
     cg_hitmessages                = cgi.Cvar_Get("cg_hitmessages", "1", CVAR_ARCHIVE);
     cg_acidtrip                   = cgi.Cvar_Get("cg_acidtrip", "0", CVAR_CHEAT);
     cg_hud                        = cgi.Cvar_Get("cg_hud", "0", 0);
@@ -196,53 +198,87 @@ void CG_RegisterCvars(void)
     vm_lean_lower                 = cgi.Cvar_Get("vm_lean_lower", "0.1", 0);
     voiceChat                     = cgi.Cvar_Get("cg_voicechat", "1", 0);
 
+    ui_timemessage = cgi.Cvar_Get("ui_timemessage", "", 0);
+
     // see if we are also running the server on this machine
     temp            = cgi.Cvar_Get("sv_running", "0", 0);
     cgs.localServer = temp->integer;
 }
 
+/*
+================
+CG_RegisterSoundsForFile
+
+Register the specified ubersound source file
+================
+*/
+void CG_RegisterSoundsForFile(const char *name)
+{
+    int startTime;
+    int endTime;
+
+    Com_Printf("\n\n-----------PARSING '%s'------------\n", name);
+    Com_Printf(
+        "Any SetCurrentTiki errors means that tiki wasn't prefetched and tiki-specific sounds for it won't work. To "
+        "fix prefetch the tiki. Ignore if you don't use that tiki on this level.\n"
+    );
+
+    startTime = cgi.Milliseconds();
+    CG_Command_ProcessFile(name, qfalse, NULL);
+    endTime = cgi.Milliseconds();
+
+    Com_Printf("Parse/Load time: %f seconds.\n", (float)(endTime - startTime) / 1000.0);
+    Com_Printf("-------------PARSING '%s' DONE---------------\n\n", name);
+}
+
+/*
+=================
+qsort_compare_strings
+
+perform case-insensitive sorting
+=================
+*/
+int qsort_compare_strings(const void *s1, const void *s2)
+{
+    return Q_stricmp(*(const char **)s1, *(const char **)s2);
+}
+
 /*
 =================
 CG_RegisterSounds
 
-called during a precache command
+Called during a precache command
 =================
 */
 void CG_RegisterSounds(void)
 {
-    int  startTime;
-    int  endTime;
-    char filename[MAX_QPATH];
+    char **fileList;
+    int    numFiles;
+    int    i;
 
-    Com_Printf("\n\n-----------PARSING UBERSOUND------------\n");
-    Com_Printf(
-        "Any SetCurrentTiki errors means that tiki wasn't prefetched and "
-        "tiki-specific sounds for it won't work. To fix prefe"
-        "tch the tiki. Ignore if you don't use that tiki on this level.\n"
-    );
-    Com_sprintf(filename, sizeof(filename), "ubersound/ubersound.scr");
+    fileList = cgi.FS_ListFilteredFiles("ubersound/", "scr", "*.scr", qfalse, &numFiles, qtrue);
+    if (cg_target_game >= TG_MOHTA) {
+        // Fixed in 2.0
+        //  The behavior has changed, all aliases get cleared
+        if (cgs.gametype != GT_SINGLE_PLAYER) {
+            cgi.Alias_Clear();
+        }
+    } else {
+        if (!cgs.localServer) {
+            cgi.Alias_Clear();
+        }
+    }
+    
+    qsort(fileList, numFiles, sizeof(char *), &qsort_compare_strings);
 
-    startTime = cgi.Milliseconds();
-    CG_Command_ProcessFile(filename, 0, 0);
-    endTime = cgi.Milliseconds();
+    for (i = 0; i < numFiles; i++) {
+        // Added in 2.0
+        //  Since 2.0, all files in the ubersound folder
+        //  are parsed
+        CG_RegisterSoundsForFile(va("ubersound/%s", fileList[i]));
+    }
 
-    Com_Printf("Parse/Load time: %f seconds.\n", (endTime - startTime) / 1000.0f);
-
-    Com_Printf("-------------UBERSOUND DONE---------------\n\n");
-    Com_Printf("\n\n-----------PARSING UBERDIALOG------------\n");
-    Com_Printf(
-        "Any SetCurrentTiki errors means that tiki wasn't prefetched and "
-        "tiki-specific sounds for it won't work. To fix prefe"
-        "tch the tiki. Ignore if you don't use that tiki on this level.\n"
-    );
-    Com_sprintf(filename, sizeof(filename), "ubersound/uberdialog.scr");
-
-    startTime = cgi.Milliseconds();
-    CG_Command_ProcessFile(filename, 0, 0);
-    endTime = cgi.Milliseconds() - startTime;
-
-    Com_Printf("Parse/Load time: %f seconds.\n", endTime / 1000.0f);
-    Com_Printf("-------------UBERDIALOG DONE---------------\n\n");
+    cgi.FS_FreeFileList(fileList);
 }
 
 /*
@@ -252,13 +288,11 @@ CG_IsHandleUnique
 Check if the model handle is unique
 ================
 */
-static qboolean CG_IsHandleUnique(int num) {
-    qhandle_t handle;
+static qboolean CG_IsHandleUnique(qhandle_t handle) {
     int i;
     int numRef;
 
     numRef = 0;
-    handle = cgs.model_draw[num];
     for (i = 0; i < MAX_MODELS; i++) {
         if (cgs.model_draw[i] == handle) {
             numRef++;
@@ -335,28 +369,39 @@ void CG_ProcessConfigString(int num, qboolean modelOnly)
             cg.rain.width = atof(str);
             return;
         case CS_RAIN_SHADER:
+            Q_strncpyz(cg.rain.currentShader, str, sizeof(cg.rain.currentShader));
             if (cg.rain.numshaders) {
-                for (i = 0; i < cg.rain.numshaders; i++) {
-                    sprintf(cg.rain.shader[i], "%s%i", str, i);
+                // Fixed in OPM
+                //  not sure why some maps set a digit at the end...
+                size_t len = strlen(cg.rain.currentShader);
+                if (isdigit(cg.rain.currentShader[len - 1])) {
+                    cg.rain.currentShader[len - 1] = 0;
                 }
-            } else {
-                strcpy(cg.rain.shader[0], str);
+            }
+            for (i = 0; i < cg.rain.numshaders; ++i) {
+                Com_sprintf(cg.rain.shader[i], sizeof(cg.rain.shader[i]), "%s%i", cg.rain.currentShader, i);
+            }
+            if (!cg.rain.numshaders) {
+                Q_strncpyz(cg.rain.shader[0], cg.rain.currentShader, sizeof(cg.rain.shader[0]));
             }
             return;
         case CS_RAIN_NUMSHADERS:
             cg.rain.numshaders = atoi(str);
             if (cg.rain.numshaders) {
                 for (i = 0; i < cg.rain.numshaders; i++) {
-                    sprintf(cg.rain.shader[i], "%s%i", str, i);
+                    Com_sprintf(cg.rain.shader[i], sizeof(cg.rain.shader[i]), "%s%i", cg.rain.currentShader, i);
                 }
             }
             return;
+        case CS_CURRENT_OBJECTIVE:
+            cg.ObjectivesCurrentIndex = atoi(str);
+            return;
         }
 
         if (num >= CS_OBJECTIVES && num < CS_OBJECTIVES + MAX_OBJECTIVES) {
             cobjective_t *objective = &cg.Objectives[num - CS_OBJECTIVES];
             objective->flags        = atoi(Info_ValueForKey(str, "flags"));
-            strcpy(objective->text, Info_ValueForKey(str, "text"));
+            Q_strncpyz(objective->text, Info_ValueForKey(str, "text"), sizeof(objective->text));
         }
 
         switch (num) {
@@ -411,7 +456,7 @@ void CG_ProcessConfigString(int num, qboolean modelOnly)
             if (len) {
                 qboolean streamed;
                 char     buf[1024];
-                strcpy(buf, str);
+                Q_strncpyz(buf, str, sizeof(buf));
         
                 streamed     = buf[len - 1] != '0';
                 buf[len - 1] = 0;
@@ -623,6 +668,8 @@ void CG_Init(clientGameImport_t *imported, int serverMessageNum, int serverComma
     cgi = *imported;
 
     cg_protocol = cgi.Cvar_Get("com_protocol", "", 0)->integer;
+    cg_target_game = (target_game_e)cgi.Cvar_Get("com_target_game", "0", 0)->integer;
+
     CG_InitCGMessageAPI(&cge);
     CG_InitScoresAPI(&cge);
 
@@ -811,7 +858,7 @@ void Com_Error(int level, const char *error, ...)
     char    text[1024];
 
     va_start(argptr, error);
-    vsprintf(text, error, argptr);
+    Q_vsnprintf(text, sizeof(text), error, argptr);
     va_end(argptr);
 
     cgi.Error(level, "%s", text);
@@ -823,7 +870,7 @@ void Com_Printf(const char *msg, ...)
     char    text[1024];
 
     va_start(argptr, msg);
-    vsprintf(text, msg, argptr);
+    Q_vsnprintf(text, sizeof(text), msg, argptr);
     va_end(argptr);
 
     cgi.Printf("%s", text);

code/cgame/cg_modelanim.c

@@ -180,6 +180,117 @@ void CG_PlayerTeamIcon(refEntity_t *pModel, entityState_t *pPlayerState)
     }
 }
 
+/*
+===============
+CG_InterpolateAnimParms
+
+Interpolate between current and next entity
+===============
+*/
+void CG_InterpolateAnimParms(entityState_t* state, entityState_t* sNext, refEntity_t* model)
+{
+    static cvar_t *vmEntity = NULL;
+    int i;
+    float t;
+    float animLength;
+    float t1, t2;
+
+    if (!vmEntity) {
+        vmEntity = cgi.Cvar_Get("viewmodelanim", "1", 0);
+    }
+
+    if (sNext && sNext->usageIndex == state->usageIndex) {
+        t1 = cg.time - cg.snap->serverTime;
+        t2 = cg.nextSnap->serverTime - cg.snap->serverTime;
+        t = t1 / t2;
+
+        model->actionWeight = (sNext->actionWeight - state->actionWeight) * t + state->actionWeight;
+
+        for (i = 0; i < MAX_FRAMEINFOS; i++) {
+            if (sNext->frameInfo[i].weight) {
+                model->frameInfo[i].index = sNext->frameInfo[i].index;
+                if (sNext->frameInfo[i].index == state->frameInfo[i].index && state->frameInfo[i].weight) {
+                    model->frameInfo[i].weight =
+                        (sNext->frameInfo[i].weight - state->frameInfo[i].weight) * t + state->frameInfo[i].weight;
+
+                    if (sNext->frameInfo[i].time >= state->frameInfo[i].time) {
+                        model->frameInfo[i].time = (sNext->frameInfo[i].time - state->frameInfo[i].time) * t + state->frameInfo[i].time;
+                    } else {
+                        animLength = cgi.Anim_Time(model->tiki, sNext->frameInfo[i].index);
+                        if (!animLength) {
+                            t1 = 0.0;
+                        } else {
+                            t1 = (animLength + sNext->frameInfo[i].time - state->frameInfo[i].time) * t
+                               + state->frameInfo[i].time;
+                        }
+
+                        t2 = t1;
+                        while (t2 > animLength) {
+                            t2 -= animLength;
+
+                            if (t2 == t1) {
+                                t2 = 1.0;
+                                break;
+                            }
+
+                            t1 = t2;
+                        }
+
+                        model->frameInfo[i].time = t2;
+                    }
+                } else {
+                    animLength = cgi.Anim_Time(model->tiki, sNext->frameInfo[i].index);
+                    if (!animLength) {
+                        t1 = 0.0;
+                    } else {
+                        t1 = sNext->frameInfo[i].time - (cg.nextSnap->serverTime - cg.time) / 1000.0;
+                    }
+
+                    model->frameInfo[i].time   = Q_max(0, t1);
+                    model->frameInfo[i].weight = sNext->frameInfo[i].weight;
+                }
+            } else if (sNext->frameInfo[i].index == state->frameInfo[i].index) {
+                animLength = cgi.Anim_Time(model->tiki, sNext->frameInfo[i].index);
+                if (!animLength) {
+                    t1 = 0.0;
+                } else {
+                    t1 = (cg.time - cg.snap->serverTime) / 1000.0 + state->frameInfo[i].time;
+                }
+
+                model->frameInfo[i].index  = Q_clamp_int(state->frameInfo[i].index, 0, model->tiki->a->num_anims - 1);
+                model->frameInfo[i].time   = Q_min(animLength, t1);
+                model->frameInfo[i].weight = (1.0 - t) * state->frameInfo[i].weight;
+            } else {
+                model->frameInfo[i].index  = -1;
+                model->frameInfo[i].weight = 0.0;
+            }
+        }
+    } else {
+        // no next state, don't blend anims
+
+        model->actionWeight = state->actionWeight;
+        for (i = 0; i < MAX_FRAMEINFOS; i++) {
+            if (state->frameInfo[i].weight) {
+                model->frameInfo[i].index  = Q_clamp_int(state->frameInfo[i].index, 0, model->tiki->a->num_anims - 1);
+                model->frameInfo[i].time   = state->frameInfo[i].time;
+                model->frameInfo[i].weight = state->frameInfo[i].weight;
+            } else {
+                model->frameInfo[i].index  = -1;
+                model->frameInfo[i].weight = 0.0;
+            }
+        }
+    }
+
+    if (vmEntity->integer == state->number) {
+        static cvar_t *curanim;
+        if (!curanim) {
+            curanim = cgi.Cvar_Get("viewmodelanimslot", "1", 0);
+        }
+
+        cgi.Cvar_Set("viewmodelanimclienttime", va("%0.2f", model->frameInfo[curanim->integer].time));
+    }
+}
+
 /*
 ===============
 CG_CastFootShadow
@@ -550,7 +661,7 @@ void CG_AnimationDebugMessage(int number, const char *fmt, ...)
         char    msg[1024];
 
         va_start(argptr, fmt);
-        vsprintf(msg, fmt, argptr);
+        Q_vsnprintf(msg, sizeof(msg), fmt, argptr);
         va_end(argptr);
 
         if ((!cg_debugAnimWatch->integer) || ((cg_debugAnimWatch->integer - 1) == number)) {
@@ -654,8 +765,8 @@ void CG_UpdateForceModels()
     pszAlliesPartial = dm_playermodel->string;
     pszAxisPartial = dm_playergermanmodel->string;
 
-    sprintf(szAlliesModel, "models/player/%s.tik", pszAlliesPartial);
-    sprintf(szAxisModel, "models/player/%s.tik", pszAxisPartial);
+    Com_sprintf(szAlliesModel, sizeof(szAlliesModel), "models/player/%s.tik", pszAlliesPartial);
+    Com_sprintf(szAxisModel, sizeof(szAxisModel), "models/player/%s.tik", pszAxisPartial);
     hModel = cgi.R_RegisterModel(szAlliesModel);
     if (!hModel) hModel = cgi.R_RegisterModel("models/player/american_army.tik");
 
@@ -697,7 +808,6 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     int            i;
     vec3_t         vMins, vMaxs, vTmp;
     const char    *szTagName;
-    static cvar_t *vmEntity = NULL;
     int            iAnimFlags;
 
     s1 = &cent->currentState;
@@ -709,10 +819,6 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
 
     memset(&model, 0, sizeof(model));
 
-    if (!vmEntity) {
-        vmEntity = cgi.Cvar_Get("viewmodelanim", "1", 0);
-    }
-
     if (cent->interpolate) {
         sNext = &cent->nextState;
     }
@@ -880,103 +986,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     model.renderfx |= s1->renderfx;
     cgi.TIKI_SetEyeTargetPos(model.tiki, model.entityNumber, s1->eyeVector);
 
-    if (sNext && sNext->usageIndex == s1->usageIndex) {
-        float t;
-        float animLength;
-        float t1, t2;
-
-        t1                 = cg.time - cg.snap->serverTime;
-        t2                 = cg.nextSnap->serverTime - cg.snap->serverTime;
-        t                  = t1 / t2;
-        model.actionWeight = (sNext->actionWeight - s1->actionWeight) * t + s1->actionWeight;
-
-        for (i = 0; i < MAX_FRAMEINFOS; i++) {
-            if (sNext->frameInfo[i].weight) {
-                model.frameInfo[i].index = sNext->frameInfo[i].index;
-                if (sNext->frameInfo[i].index == s1->frameInfo[i].index && s1->frameInfo[i].weight) {
-                    model.frameInfo[i].weight =
-                        (sNext->frameInfo[i].weight - s1->frameInfo[i].weight) * t + s1->frameInfo[i].weight;
-
-                    if (sNext->frameInfo[i].time >= s1->frameInfo[i].time) {
-                        model.frameInfo[i].time =
-                            (sNext->frameInfo[i].time - s1->frameInfo[i].time) * t + s1->frameInfo[i].time;
-                    } else {
-                        animLength = cgi.Anim_Time(model.tiki, sNext->frameInfo[i].index);
-                        if (!animLength) {
-                            t1 = 0.0;
-                        } else {
-                            t1 = (animLength + sNext->frameInfo[i].time - s1->frameInfo[i].time) * t
-                               + s1->frameInfo[i].time;
-                        }
-
-                        t2 = t1;
-                        while (t2 > animLength) {
-                            t2 -= animLength;
-                        }
-
-                        model.frameInfo[i].time = t2;
-                    }
-                } else {
-                    animLength = cgi.Anim_Time(model.tiki, sNext->frameInfo[i].index);
-                    if (!animLength) {
-                        t1 = 0.0;
-                    } else {
-                        t1 = sNext->frameInfo[i].time - (cg.nextSnap->serverTime - cg.time) / 1000.0;
-                    }
-
-                    t2 = t1;
-                    if (t2 < 0.0) {
-                        t2 = 0.0;
-                    }
-
-                    model.frameInfo[i].time   = t2;
-                    model.frameInfo[i].weight = sNext->frameInfo[i].weight;
-                }
-            } else if (sNext->frameInfo[i].index == s1->frameInfo[i].index) {
-                animLength = cgi.Anim_Time(model.tiki, sNext->frameInfo[i].index);
-                if (!animLength) {
-                    t1 = 0.0;
-                } else {
-                    t1 = (cg.time - cg.snap->serverTime) / 1000.0 + s1->frameInfo[i].time;
-                }
-
-                t2 = t1;
-                if (t2 < animLength) {
-                    t2 = animLength;
-                }
-
-                model.frameInfo[i].index  = s1->frameInfo[i].index;
-                model.frameInfo[i].time   = t2;
-                model.frameInfo[i].weight = (1.0 - t) * s1->frameInfo[i].weight;
-            } else {
-                model.frameInfo[i].index  = -1;
-                model.frameInfo[i].weight = 0.0;
-            }
-        }
-    } else {
-        // no next state, don't blend anims
-
-        model.actionWeight = s1->actionWeight;
-        for (i = 0; i < MAX_FRAMEINFOS; i++) {
-            if (s1->frameInfo[i].weight) {
-                model.frameInfo[i].index  = s1->frameInfo[i].index;
-                model.frameInfo[i].time   = s1->frameInfo[i].time;
-                model.frameInfo[i].weight = s1->frameInfo[i].weight;
-            } else {
-                model.frameInfo[i].index  = -1;
-                model.frameInfo[i].weight = 0.0;
-            }
-        }
-    }
-
-    if (vmEntity->integer == s1->number) {
-        static cvar_t *curanim;
-        if (!curanim) {
-            curanim = cgi.Cvar_Get("viewmodelanimslot", "1", 0);
-        }
-
-        cgi.Cvar_Set("viewmodelanimclienttime", va("%0.2f", model.frameInfo[curanim->integer].time));
-    }
+    CG_InterpolateAnimParms(s1, sNext, &model);
 
     if (cent->currentState.parent != ENTITYNUM_NONE) {
         int          iTagNum;
@@ -1227,6 +1237,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             memset(model.surfaces, 0, sizeof(model.surfaces));
 
             CG_ViewModelAnimation(&model);
+            model.renderfx |= RF_FRAMELERP;
             cgi.ForceUpdatePose(&model);
 
             if ((cent->currentState.eFlags & EF_UNARMED) || cg_drawviewmodel->integer <= 1
@@ -1323,7 +1334,12 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
         if (model.frameInfo[i].weight) {
             if (!((cent->animLastWeight >> i) & 1) || model.frameInfo[i].index != cent->animLast[i]) {
                 CG_ProcessEntityCommands(TIKI_FRAME_ENTRY, model.frameInfo[i].index, s1->number, &model, cent);
-                cent->animLastTimes[i] = 0.0;
+                if (cent->animLastTimes[i] == -1) {
+                    cent->animLast[i] = model.frameInfo[i].index;
+                    cent->animLastTimes[i] = model.frameInfo[i].time;
+                } else {
+                    cent->animLastTimes[i] = 0;
+                }
             }
 
             CG_ClientCommands(&model, cent, i);

code/cgame/cg_nature.cpp

@@ -51,16 +51,16 @@ void RainTouch(ctempmodel_t *ct, trace_t *trace)
 
 void ClientGameCommandManager::RainTouch(Event *ev)
 {
-    // FIXME: unimplemented
+    // Nothing to do
 }
 
 void ClientGameCommandManager::InitializeRainCvars()
 {
     int i;
 
-    cg_rain = cgi.Cvar_Get("cg_rain", "0", CVAR_ARCHIVE);
+    cg_rain = cgi.Cvar_Get("cg_rain", "1", CVAR_ARCHIVE);
     cg_rain_drawcoverage =
-        cgi.Cvar_Get("cg_rain_drawcoverage", "0", CVAR_SAVEGAME | CVAR_SERVER_CREATED | CVAR_SYSTEMINFO);
+        cgi.Cvar_Get("cg_rain_drawcoverage", "0", CVAR_SAVEGAME | CVAR_RESETSTRING | CVAR_SYSTEMINFO);
 
     cg.rain.density    = 0.0;
     cg.rain.speed      = 2048.0f;

code/cgame/cg_predict.c

@@ -190,8 +190,9 @@ void CG_ShowTrace(trace_t *trace, int passent, const char *reason)
     assert(reason);
     assert(trace);
 
-    sprintf(
+    Com_sprintf(
         text,
+        sizeof(text),
         "%0.2f : Pass (%d) Frac %f Hit (%d): '%s'\n",
         (float)cg.time / 1000.0f,
         passent,
@@ -349,6 +350,13 @@ static void CG_InterpolatePlayerStateCamera(void)
         return;
     }
 
+    // Added in 2.0
+    if (cg.predicted_player_state.camera_flags & CF_CAMERA_ANGLES_TURRETMODE) {
+        VectorCopy(cg.nextSnap->ps.camera_origin, cg.camera_origin);
+        VectorCopy(cg.nextSnap->ps.camera_angles, cg.camera_angles);
+        return;
+    }
+
     for (i = 0; i < 3; i++) {
         cg.camera_origin[i] = prev->ps.camera_origin[i] + f * (next->ps.camera_origin[i] - prev->ps.camera_origin[i]);
         cg.camera_angles[i] = LerpAngle(prev->ps.camera_angles[i], next->ps.camera_angles[i], f);
@@ -493,8 +501,13 @@ void CG_PredictPlayerState(void)
         cg_pmove.leanSpeed = 2.f;
     } else {
         cg_pmove.alwaysAllowLean = qtrue;
+        if (cgs.gametype != GT_SINGLE_PLAYER) {
+            cg_pmove.leanMax = 40.f;
+        } else {
+            // Don't allow lean in single-player, like in the original game
+            cg_pmove.leanMax = 0;
+        }
 
-        cg_pmove.leanMax = 40.f;
         cg_pmove.leanAdd = 10.f;
         cg_pmove.leanRecoverSpeed = 15.f;
         cg_pmove.leanSpeed = 4.f;
@@ -515,7 +528,11 @@ void CG_PredictPlayerState(void)
     // the server time is beyond our current cg.time,
     // because predicted player positions are going to
     // be ahead of everything else anyway
-    if (cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport) {
+    // Added in OPM: prediction check
+    //  Don't use the next snapshot if the prediction is about to be disabled
+    //  this prevent "blinking" issues like when entering a vehicle turret gun
+    //  where arms would be seen shortly
+    if (cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport && !(cg.nextSnap->ps.pm_flags & PMF_NO_PREDICTION)) {
         cg.predicted_player_state = cg.nextSnap->ps;
         cg.physicsTime            = cg.nextSnap->serverTime;
     } else {

code/cgame/cg_public.h

@@ -120,6 +120,7 @@ functions exported to the main executable
 
         // console variable interaction
         cvar_t *(*Cvar_Get)(const char *var_name, const char *value, int flags);
+        cvar_t *(*Cvar_Find)(const char *var_name);
         void (*Cvar_Set)(const char *var_name, const char *value);
 
         // ClientCommand and ConsoleCommand parameter access
@@ -360,6 +361,8 @@ functions exported to the main executable
         void (*UI_ShowMenu)(const char *name, qboolean bForce);
         void (*UI_HideMenu)(const char *name, qboolean bForce);
         int (*UI_FontStringWidth)(fontheader_t *font, const char *string, int maxLen);
+        // Added in 2.0
+        float (*UI_GetObjectivesTop)(void);
 
         int (*Key_StringToKeynum)(const char *str);
         const char *(*Key_KeynumToBindString)(int keyNum);
@@ -430,6 +433,8 @@ functions exported to the main executable
         void (*CL_RestoreSavedCgameState)();
         void (*CL_ClearSavedCgameState)();
 
+        size_t (*getConfigStringIdNormalized)(size_t num);
+
         cvar_t       *fsDebug;
         hdelement_t  *HudDrawElements;
         clientAnim_t *anim;
@@ -463,8 +468,8 @@ functions exported to the main executable
         int (*CG_GetParent)(int entNum);
         float (*CG_GetObjectiveAlpha)();
         int (*CG_PermanentMark)(
-            const vec3_t    origin,
-            const vec3_t    dir,
+            vec3_t          origin,
+            vec3_t          dir,
             float           orientation,
             float           sScale,
             float           tScale,

code/cgame/cg_scoreboard.cpp

@@ -58,19 +58,19 @@ void CG_PrepScoreBoardInfo()
 {
     switch (cgs.gametype) {
     case GT_TEAM_ROUNDS:
-        strcpy(cg.scoresMenuName, "DM_Round_Scoreboard");
+        Q_strncpyz(cg.scoresMenuName, "DM_Round_Scoreboard", sizeof(cg.scoresMenuName));
         break;
     case GT_OBJECTIVE:
-        strcpy(cg.scoresMenuName, "Obj_Scoreboard");
+        Q_strncpyz(cg.scoresMenuName, "Obj_Scoreboard", sizeof(cg.scoresMenuName));
         break;
     case GT_TOW:
-        strcpy(cg.scoresMenuName, "Tow_Scoreboard");
+        Q_strncpyz(cg.scoresMenuName, "Tow_Scoreboard", sizeof(cg.scoresMenuName));
         break;
     case GT_LIBERATION:
-        strcpy(cg.scoresMenuName, "Lib_Scoreboard");
+        Q_strncpyz(cg.scoresMenuName, "Lib_Scoreboard", sizeof(cg.scoresMenuName));
         break;
     default:
-        strcpy(cg.scoresMenuName, "DM_Scoreboard");
+        Q_strncpyz(cg.scoresMenuName, "DM_Scoreboard", sizeof(cg.scoresMenuName));
         break;
     }
 }
@@ -296,14 +296,15 @@ void CG_ParseScores_ver_15()
 
                 switch (iClientTeam) {
                 case 1:
-                    strcpy(szString3, cgi.LV_ConvertString("Spectators"));
+                    Q_strncpyz(szString3, cgi.LV_ConvertString("Spectators"), sizeof(szString3));
                     break;
                 case 2:
-                    strcpy(szString3, cgi.LV_ConvertString("Free-For-Allers"));
+                    Q_strncpyz(szString3, cgi.LV_ConvertString("Free-For-Allers"), sizeof(szString3));
                     break;
                 case 3:
-                    sprintf(
+                    Com_sprintf(
                         szString3,
+                        sizeof(szString3),
                         "%s - %d %s",
                         cgi.LV_ConvertString("Allies"),
                         atoi(cgi.Argv(2 + iCurrentEntry + iDatumCount * i)),
@@ -312,8 +313,9 @@ void CG_ParseScores_ver_15()
                     iCurrentEntry++;
                     break;
                 case 4:
-                    sprintf(
+                    Com_sprintf(
                         szString3,
+                        sizeof(szString3),
                         "%s - %d %s",
                         cgi.LV_ConvertString("Axis"),
                         atoi(cgi.Argv(2 + iCurrentEntry + iDatumCount * i)),
@@ -322,7 +324,7 @@ void CG_ParseScores_ver_15()
                     iCurrentEntry++;
                     break;
                 default:
-                    strcpy(szString3, cgi.LV_ConvertString("No Team"));
+                    Q_strncpyz(szString3, cgi.LV_ConvertString("No Team"), sizeof(szString3));
                     break;
                 }
             } else if (iClientNum == -2) {
@@ -330,14 +332,14 @@ void CG_ParseScores_ver_15()
                 szString2[0] = 0;
                 szString3[0] = 0;
             } else {
-                strcpy(szString2, va("%i", iClientNum));
-                strcpy(szString3, cg.clientinfo[iClientNum].name);
+                Q_strncpyz(szString2, va("%i", iClientNum), sizeof(szString2));
+                Q_strncpyz(szString3, cg.clientinfo[iClientNum].name, sizeof(szString3));
             }
 
-            strcpy(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString7, cgi.Argv(5 + iCurrentEntry + iDatumCount * i));
+            Q_strncpyz(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i), sizeof(szString4));
+            Q_strncpyz(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i), sizeof(szString5));
+            Q_strncpyz(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i), sizeof(szString6));
+            Q_strncpyz(szString7, cgi.Argv(5 + iCurrentEntry + iDatumCount * i), sizeof(szString7));
 
             if (cgs.gametype >= GT_TEAM_ROUNDS && iClientNum == -1
                 && (iClientTeam == TEAM_ALLIES || iClientTeam == TEAM_AXIS)) {
@@ -370,19 +372,19 @@ void CG_ParseScores_ver_15()
         } else {
             iClientNum = atoi(cgi.Argv(iCurrentEntry + iDatumCount * i));
             if (iClientNum >= 0) {
-                strcpy(szString2, va("%i", iClientNum));
-                strcpy(szString3, cg.clientinfo[iClientNum].name);
-                strcpy(szString4, cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString5, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString6, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString7, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
+                Q_strncpyz(szString2, va("%i", iClientNum), sizeof(szString2));
+                Q_strncpyz(szString3, cg.clientinfo[iClientNum].name, sizeof(szString3));
+                Q_strncpyz(szString4, cgi.Argv(1 + iCurrentEntry + iDatumCount * i), sizeof(szString4));
+                Q_strncpyz(szString5, cgi.Argv(2 + iCurrentEntry + iDatumCount * i), sizeof(szString5));
+                Q_strncpyz(szString6, cgi.Argv(3 + iCurrentEntry + iDatumCount * i), sizeof(szString6));
+                Q_strncpyz(szString7, cgi.Argv(4 + iCurrentEntry + iDatumCount * i), sizeof(szString7));
             } else {
                 szString2[0] = 0;
                 if (iClientNum == -3) {
-                    strcpy(szString2, cgi.LV_ConvertString("Players"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Players"), sizeof(szString2));
                     bIsHeader = qtrue;
                 } else if (iClientNum == -2) {
-                    strcpy(szString2, cgi.LV_ConvertString("Spectators"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Spectators"), sizeof(szString2));
                     bIsHeader = qtrue;
                 } else {
                     // unknown
@@ -535,32 +537,32 @@ void CG_ParseScores_ver_6()
 
                 switch (iClientTeam) {
                 case 1:
-                    strcpy(szString2, cgi.LV_ConvertString("Spectators"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Spectators"), sizeof(szString2));
                     break;
                 case 2:
-                    strcpy(szString2, cgi.LV_ConvertString("Free-For-Allers"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Free-For-Allers"), sizeof(szString2));
                     break;
                 case 3:
-                    strcpy(szString2, cgi.LV_ConvertString("Allies"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Allies"), sizeof(szString2));
                     break;
                 case 4:
-                    strcpy(szString2, cgi.LV_ConvertString("Axis"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Axis"), sizeof(szString2));
                     break;
                 default:
-                    strcpy(szString2, cgi.LV_ConvertString("No Team"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("No Team"), sizeof(szString2));
                     break;
                 }
             } else if (iClientNum == -2) {
                 // spectating
                 szString2[0] = 0;
             } else {
-                strcpy(szString2, cg.clientinfo[iClientNum].name);
+                Q_strncpyz(szString2, cg.clientinfo[iClientNum].name, sizeof(szString2));
             }
 
-            strcpy(szString3, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString4, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString5, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
-            strcpy(szString6, cgi.Argv(5 + iCurrentEntry + iDatumCount * i));
+            Q_strncpyz(szString3, cgi.Argv(2 + iCurrentEntry + iDatumCount * i), sizeof(szString3));
+            Q_strncpyz(szString4, cgi.Argv(3 + iCurrentEntry + iDatumCount * i), sizeof(szString4));
+            Q_strncpyz(szString5, cgi.Argv(4 + iCurrentEntry + iDatumCount * i), sizeof(szString5));
+            Q_strncpyz(szString6, cgi.Argv(5 + iCurrentEntry + iDatumCount * i), sizeof(szString6));
 
             if (iClientNum == cg.snap->ps.clientNum) {
                 pItemTextColor = vThisClientTextColor;
@@ -587,17 +589,17 @@ void CG_ParseScores_ver_6()
         } else {
             iClientNum = atoi(cgi.Argv(iCurrentEntry + iDatumCount * i));
             if (iClientNum >= 0) {
-                strcpy(szString2, cg.clientinfo[iClientNum].name);
-                strcpy(szString3, cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
-                strcpy(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
+                Q_strncpyz(szString2, cg.clientinfo[iClientNum].name, sizeof(szString2));
+                Q_strncpyz(szString3, cgi.Argv(1 + iCurrentEntry + iDatumCount * i), sizeof(szString3));
+                Q_strncpyz(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i), sizeof(szString4));
+                Q_strncpyz(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i), sizeof(szString5));
+                Q_strncpyz(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i), sizeof(szString6));
             } else {
                 if (iClientNum == -3) {
-                    strcpy(szString2, cgi.LV_ConvertString("Players"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Players"), sizeof(szString2));
                     bIsHeader = qtrue;
                 } else if (iClientNum == -2) {
-                    strcpy(szString2, cgi.LV_ConvertString("Spectators"));
+                    Q_strncpyz(szString2, cgi.LV_ConvertString("Spectators"), sizeof(szString2));
                     bIsHeader = qtrue;
                 } else {
                     // unknown

code/cgame/cg_servercmds.c

@@ -1,6 +1,7 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2008-2024 the OpenMoHAA team
+Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of OpenMoHAA source code.
 
@@ -26,11 +27,27 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "cg_local.h"
 #include "../fgame/bg_voteoptions.h"
 
+static qboolean CG_IsStatementFiltered(char *cmd);
+
+/*
+================
+IsWeaponAllowed
+
+Returns true if the weapon is allowed
+================
+*/
 static const char *IsWeaponAllowed(int dmFlags, int flags)
 {
     return (dmFlags & flags) ? "0" : "1";
 }
 
+/*
+================
+QueryLandminesAllowed2
+
+Returns true if landmines is allowed by the map or by a dm flag
+================
+*/
 static qboolean QueryLandminesAllowed2(const char *mapname, int dmflags)
 {
     if (dmflags & DF_WEAPON_NO_LANDMINE) {
@@ -134,6 +151,7 @@ void CG_ParseServerinfo(void)
     cgi.Cvar_Set("cg_fraglimit", Info_ValueForKey(info, "fraglimit"));
     cgi.Cvar_Set("cg_timelimit", Info_ValueForKey(info, "timelimit"));
     cgi.Cvar_Set("cg_maxclients", Info_ValueForKey(info, "sv_gametype"));
+    cgi.Cvar_Set("cg_allowvote", Info_ValueForKey(info, "g_allowvote"));
     cgi.Cvar_Set("cg_obj_alliedtext1", Info_ValueForKey(info, "g_obj_alliedtext1"));
     cgi.Cvar_Set("cg_obj_alliedtext2", Info_ValueForKey(info, "g_obj_alliedtext2"));
     cgi.Cvar_Set("cg_obj_alliedtext3", Info_ValueForKey(info, "g_obj_alliedtext3"));
@@ -148,10 +166,10 @@ void CG_ParseServerinfo(void)
     cgi.Cvar_Set("cg_scoreboardpicover", Info_ValueForKey(info, "g_scoreboardpicover"));
     mapChecksumStr = Info_ValueForKey(info, "sv_mapChecksum");
     if (mapChecksumStr && mapChecksumStr[0]) {
-        cgs.mapChecksum = atoi(mapChecksumStr);
+        cgs.mapChecksum    = atoi(mapChecksumStr);
         cgs.useMapChecksum = qtrue;
     } else {
-        cgs.mapChecksum = 0;
+        cgs.mapChecksum    = 0;
         cgs.useMapChecksum = qfalse;
     }
 
@@ -169,7 +187,7 @@ void CG_ParseServerinfo(void)
     if (spawnpos) {
         Q_strncpyz(map, mapname, spawnpos - mapname + 1);
     } else {
-        strcpy(map, mapname);
+        Q_strncpyz(map, mapname, sizeof(map));
     }
 
     Com_sprintf(cgs.mapname, sizeof(cgs.mapname), "maps/%s.bsp", map);
@@ -296,7 +314,7 @@ static void CG_ServerCommand(qboolean modelOnly)
     }
 
     if (!strcmp(cmd, "cs")) {
-        CG_ConfigStringModified(atoi(cgi.Argv(1)), modelOnly);
+        CG_ConfigStringModified(cgi.getConfigStringIdNormalized(atoi(cgi.Argv(1))), modelOnly);
         return;
     }
 
@@ -311,12 +329,12 @@ static void CG_ServerCommand(qboolean modelOnly)
         }
         return;
     } else if (!strcmp(cmd, "printdeathmsg")) {
-        const char *s1, *s2, * attackerName, * victimName, *type;
+        const char *s1, *s2, *attackerName, *victimName, *type;
         const char *result1, *result2;
         int         hudColor;
 
-        result1 = NULL;
-        result2 = NULL;
+        result1      = NULL;
+        result2      = NULL;
         s1           = cgi.Argv(1);
         s2           = cgi.Argv(2);
         attackerName = cgi.Argv(3);
@@ -352,7 +370,14 @@ static void CG_ServerCommand(qboolean modelOnly)
     }
 
     if (!strcmp(cmd, "stufftext")) {
-        cgi.Cmd_Stuff(cgi.Argv(1));
+        char *cmd = cgi.Argv(1);
+        if (CG_IsStatementFiltered(cmd)) {
+            // Added in OPM
+            //  Don't execute filtered commands
+            return;
+        }
+
+        cgi.Cmd_Stuff(cmd);
         cgi.Cmd_Stuff("\n");
         return;
     }
@@ -429,3 +454,233 @@ void CG_ExecuteNewServerCommands(int latestSequence, qboolean differentServer)
         }
     }
 }
+
+//
+// List of client variables allowed to be changed by the server
+//
+static const char *whiteListedVariables[] = {
+    "r_fastsky", // some mods set this variable to make the sky uniform
+    "ui_hud",
+};
+
+//
+// List of client variables allowed to be changed by the server
+//
+static const char *whiteListedLocalServerVariables[] = {"ui_hidemouse", "ui_showmouse", "cg_marks_add"};
+
+//
+// List of commands allowed to be executed by the server
+//
+static const char *whiteListedCommands[] = {
+    "primarydmweapon",
+    "pushmenu",
+    "pushmenu_teamselect",
+    "pushmenu_weaponselect",
+    "popmenu",
+    "wait",
+    "globalwidgetcommand", // used for mods adding custom HUDs
+    "ui_addhud",
+    "ui_removehud",
+    "tmstart",
+    "tmstartloop",
+    "tmstop",
+    "tmvolume",
+    "`stufftext",
+    "+moveup", // workaround for mods that want to prevent inactivity when handling the spectate
+    "-moveup",
+    "screenshot",
+    "screenshotJPEG",
+    "levelshot"
+};
+
+//
+// List of commands allowed to be executed by the server
+//
+static const char *whiteListedLocalServerCommands[] = {
+    "spmap", // Used by briefings
+    "map",
+    "disconnect",
+    "cinematic",
+    "showmenu",
+    "hidemenu"
+};
+
+/*
+====================
+CG_IsVariableFiltered
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsVariableFiltered(const char *name)
+{
+    cvar_t *var;
+    size_t i;
+
+    for (i = 0; i < ARRAY_LEN(whiteListedVariables); i++) {
+        if (!Q_stricmp(name, whiteListedVariables[i])) {
+            return qfalse;
+        }
+    }
+
+    if (cgs.localServer) {
+        for (i = 0; i < ARRAY_LEN(whiteListedLocalServerVariables); i++) {
+            if (!Q_stricmp(name, whiteListedLocalServerVariables[i])) {
+                return qfalse;
+            }
+        }
+    }
+
+    // Filtered
+    return qtrue;
+}
+
+/*
+====================
+CG_IsSetVariableFiltered
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsSetVariableFiltered(const char *name, char type)
+{
+    cvar_t *var;
+
+    if (!CG_IsVariableFiltered(name)) {
+        return qfalse;
+    }
+
+    if (type != 'u' && type != 's') {
+        // Don't allow custom info variables to avoid flooding
+        // the client with many serverinfo and userinfo variables
+
+        var = cgi.Cvar_Find(name);
+        if (!var) {
+            // Allow as it doesn't exist
+            return qfalse;
+        }
+
+        if (var->flags & CVAR_USER_CREATED) {
+            // Allow, it's user-created, wouldn't cause issues
+            return qfalse;
+        }
+    }
+
+    // Filtered
+    return qtrue;
+}
+
+/*
+====================
+CG_IsCommandFiltered
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsCommandFiltered(const char *name)
+{
+    size_t i;
+
+    for (i = 0; i < ARRAY_LEN(whiteListedCommands); i++) {
+        if (!Q_stricmp(name, whiteListedCommands[i])) {
+            return qfalse;
+        }
+    }
+
+    if (cgs.localServer) {
+        // Allow more commands when the client is hosting the server
+        // Mostly used on single-player mode, like when briefings switch to the next map
+        for (i = 0; i < ARRAY_LEN(whiteListedLocalServerCommands); i++) {
+            if (!Q_stricmp(name, whiteListedLocalServerCommands[i])) {
+                return qfalse;
+            }
+        }
+    }
+
+    //
+    // Test variables
+    //
+    return CG_IsVariableFiltered(name);
+}
+
+/*
+====================
+RemoveEndToken
+====================
+*/
+static qboolean RemoveEndToken(char* com_token) {
+    char* p;
+
+    for (p = com_token; p[0]; p++) {
+        if (*p == ';') {
+            *p = 0;
+            return qtrue;
+        }
+    }
+
+    return qfalse;
+}
+
+/*
+====================
+CG_IsStatementFiltered
+
+Returns whether or not the statement is filtered
+====================
+*/
+static qboolean CG_IsStatementFiltered(char *cmd)
+{
+    char* parsed;
+    char* p;
+    char com_token[256];
+    qboolean bNextStatement = qfalse;
+
+    parsed = cmd;
+
+    for (Q_strncpyz(com_token, COM_ParseExt(&parsed, qtrue), sizeof(com_token)); com_token[0]; Q_strncpyz(com_token, COM_ParseExt(&parsed, qtrue), sizeof(com_token))) {
+        bNextStatement = RemoveEndToken(com_token);
+
+        if (com_token[0] == ';') {
+            continue;
+        }
+
+        if (!Q_stricmp(com_token, "set") || !Q_stricmp(com_token, "setu") || !Q_stricmp(com_token, "seta")
+            || !Q_stricmp(com_token, "sets")) {
+            char type = com_token[3];
+
+            //
+            // variable
+            //
+            Q_strncpyz(com_token, COM_ParseExt(&parsed, qfalse), sizeof(com_token));
+            bNextStatement |= RemoveEndToken(com_token);
+            if (com_token[0] == ';') {
+                continue;
+            }
+
+            if (CG_IsSetVariableFiltered(com_token, type)) {
+                return qtrue;
+            }
+        } else {
+            //
+            // normal command
+            //
+            if (CG_IsCommandFiltered(com_token)) {
+                return qtrue;
+            }
+        }
+
+        if (!bNextStatement) {
+            // Skip up to the next statement
+            while (parsed && parsed[0]) {
+                char c = parsed[0];
+
+                parsed++;
+                if (c == '\n' || c == ';') {
+                    break;
+                }
+            }
+        }
+    }
+
+    return qfalse;
+}

code/cgame/cg_snapshot.c

@@ -73,10 +73,10 @@ static void CG_ResetEntity(centity_t *cent)
     CG_RemoveClientEntity(cent->currentState.number, tiki, cent);
 
     // reset the animation for the entities
-    if (tiki && tiki->a->bIsCharacter) {
+    if (tiki) {
         for (i = 0; i < MAX_FRAMEINFOS; i++) {
-            cent->animLast[i]      = cent->currentState.frameInfo[i].index;
-            cent->animLastTimes[i] = cent->currentState.frameInfo[i].time;
+            cent->animLast[i]      = -1;
+            cent->animLastTimes[i] = -1;
             if (cent->currentState.frameInfo[i].weight) {
                 cent->animLastWeight |= 1 << i;
             } else {
@@ -87,7 +87,8 @@ static void CG_ResetEntity(centity_t *cent)
     } else {
         // clear all the last animations
         for (i = 0; i < MAX_FRAMEINFOS; i++) {
-            cent->animLast[i] = -1;
+            cent->animLast[i]      = -1;
+            cent->animLastTimes[i] = 0.0;
         }
 
         cent->animLastWeight = 0;
@@ -346,8 +347,10 @@ static snapshot_t *CG_ReadNextSnapshot(void)
     snapshot_t *dest;
 
     if (cg.latestSnapshotNum > cgs.processedSnapshotNum + 1000) {
-        cgi.Error(
-            ERR_DROP, "CG_ReadNextSnapshot: way out of range, %i > %i", cg.latestSnapshotNum, cgs.processedSnapshotNum
+        cgi.Printf(
+            "WARNING: CG_ReadNextSnapshot: way out of range, %i > %i\n",
+            cg.latestSnapshotNum,
+            cgs.processedSnapshotNum
         );
     }
 

code/cgame/cg_specialfx.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -38,7 +38,8 @@ static vec3_t g_vLadderstepMaxs;
 
 ClientSpecialEffectsManager sfxManager;
 
-Event EV_SFX_EffectDelay(
+Event EV_SFX_EffectDelay
+(
     "effectdelay",
     EV_DEFAULT,
     "iivvvvv",
@@ -94,7 +95,7 @@ void ClientSpecialEffectsManager::LoadEffects()
     cgi.DPrintf("Loading Special Effects...\n");
     AxisClear(axis);
 
-    for (i = 0; i < MAX_SPECIAL_EFFECTS; i++) {
+    for (i = 0; i < SFX_COUNT; i++) {
         switch (i) {
         case SFX_BHIT_PAPER_LITE:
             szEffectModel = "models/fx/bh_paper_lite.tik";
@@ -234,9 +235,15 @@ void ClientSpecialEffectsManager::LoadEffects()
             szEffectModel = "models/fx/bazookaexp_base.tik";
             break;
         case SFX_EXP_HEAVYSHELL_BASE:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/heavyshellexp_base.tik";
             break;
         case SFX_EXP_TANK_BASE:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/tankexp_base.tik";
             break;
         case SFX_EXP_GREN_PAPER:
@@ -285,30 +292,57 @@ void ClientSpecialEffectsManager::LoadEffects()
             szEffectModel = "models/fx/grenexp_carpet.tik";
             break;
         case SFX_EXP_HEAVYSHELL_DIRT:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/heavyshellexp_dirt.tik";
             break;
         case SFX_EXP_HEAVYSHELL_STONE:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/heavyshellexp_stone.tik";
             break;
         case SFX_EXP_HEAVYSHELL_SNOW:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/heavyshellexp_snow.tik";
             break;
         case SFX_EXP_TANK_DIRT:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/tankexp_dirt.tik";
             break;
         case SFX_EXP_TANK_STONE:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/tankexp_stone.tik";
             break;
         case SFX_EXP_TANK_SNOW:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/tankexp_snow.tik";
             break;
         case SFX_EXP_BAZOOKA_DIRT:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/bazookaexp_dirt.tik";
             break;
         case SFX_EXP_BAZOOKA_STONE:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/bazookaexp_stone.tik";
             break;
         case SFX_EXP_BAZOOKA_SNOW:
+            if (cg_protocol < protocol_e::PROTOCOL_MOHTA_MIN) {
+                continue;
+            }
             szEffectModel = "models/fx/bazookaexp_snow.tik";
             break;
         case SFX_WATER_RIPPLE_STILL:
@@ -478,7 +512,7 @@ void ClientSpecialEffectsManager::ExecuteEffect(
                 current_tiki   = NULL;
 
                 pCommand->emitter->cgd.origin = vPos;
-                if (pCommand->emitter->cgd.flags & T_ANGLES) {
+                if (!(pCommand->emitter->cgd.flags & T_ANGLES)) {
                     pCommand->emitter->cgd.angles = vAngles;
                 }
 
@@ -486,7 +520,7 @@ void ClientSpecialEffectsManager::ExecuteEffect(
                 AxisCopy(axis, pCommand->emitter->tag_axis);
                 pCommand->emitter->cgd.createTime = cg.time;
                 commandManager.SetSpawnthing(pCommand->emitter);
-            
+
                 (commandManager.*pCommand->endfcn)();
             }
         }
@@ -904,7 +938,144 @@ void CG_LandingSound(centity_t *ent, refEntity_t *pREnt, float volume, int iEqui
 
 void CG_BodyFallSound(centity_t *ent, refEntity_t *pREnt, float volume)
 {
-    // FIXME: unimplemented
+    int     contents;
+    int     surftype;
+    int     iEffectNum = -1;
+    vec3_t  vStart, vEnd;
+    vec3_t  midlegs;
+    str     sSoundName;
+    trace_t trace;
+
+    VectorCopy(ent->lerpOrigin, vStart);
+    vStart[2] += 8;
+
+    VectorCopy(vStart, vEnd);
+    vEnd[2] -= 64;
+
+    if (ent->currentState.eType == ET_PLAYER) {
+        CG_Trace(
+            &trace,
+            vStart,
+            g_vFootstepMins,
+            g_vFootstepMaxs,
+            vEnd,
+            ent->currentState.number,
+            MASK_PLAYERSOLID,
+            qtrue,
+            qtrue,
+            "Player Landing"
+        );
+    } else {
+        CG_Trace(
+            &trace,
+            vStart,
+            g_vFootstepMins,
+            g_vFootstepMaxs,
+            vEnd,
+            ent->currentState.number,
+            MASK_MONSTERSOLID,
+            qfalse,
+            qfalse,
+            "Monster Landing"
+        );
+    }
+
+    if (trace.fraction == 1) {
+        return;
+    }
+
+    sSoundName = "snd_bodyfall_";
+    contents   = CG_PointContents(trace.endpos, -1);
+    if (contents & MASK_WATER) {
+        // take our ground position and trace upwards
+        VectorCopy(trace.endpos, midlegs);
+        midlegs[2] += WATER_NO_SPLASH_HEIGHT;
+        contents = CG_PointContents(midlegs, -1);
+        if (contents & MASK_WATER) {
+            sSoundName += "wade";
+        } else {
+            sSoundName += "puddle";
+            iEffectNum = SFX_FOOT_PUDDLE;
+        }
+    } else {
+        surftype = trace.surfaceFlags & MASK_SURF_TYPE;
+        switch (surftype) {
+        case SURF_FOLIAGE:
+            sSoundName += "foliage";
+            iEffectNum = SFX_FOOT_GRASS;
+            break;
+        case SURF_SNOW:
+            sSoundName += "snow";
+            iEffectNum = SFX_FOOT_SNOW;
+            break;
+        case SURF_CARPET:
+            sSoundName += "carpet";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        case SURF_SAND:
+            sSoundName += "sand";
+            iEffectNum = SFX_FOOT_SAND;
+            break;
+        case SURF_PUDDLE:
+            sSoundName += "puddle";
+            iEffectNum = SFX_FOOT_PUDDLE;
+            break;
+        case SURF_GLASS:
+            sSoundName += "glass";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        case SURF_GRAVEL:
+            sSoundName += "gravel";
+            iEffectNum = SFX_FOOT_HEAVY_DUST;
+            break;
+        case SURF_MUD:
+            sSoundName += "mud";
+            iEffectNum = SFX_FOOT_MUD;
+            break;
+        case SURF_DIRT:
+            sSoundName += "dirt";
+            iEffectNum = SFX_FOOT_DIRT;
+            break;
+        case SURF_GRILL:
+            sSoundName += "grill";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        case SURF_GRASS:
+            sSoundName += "grass";
+            iEffectNum = SFX_FOOT_GRASS;
+            break;
+        case SURF_ROCK:
+            sSoundName += "stone";
+            iEffectNum = SFX_FOOT_HEAVY_DUST;
+            break;
+        case SURF_PAPER:
+            sSoundName += "paper";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        case SURF_WOOD:
+            sSoundName += "wood";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        case SURF_METAL:
+            sSoundName += "metal";
+            iEffectNum = SFX_FOOT_LIGHT_DUST;
+            break;
+        default:
+            sSoundName += "stone";
+            iEffectNum = SFX_FOOT_HEAVY_DUST;
+            break;
+        }
+    }
+
+    if (cg_debugFootsteps->integer) {
+        cgi.DPrintf("BodyFall: %s    volume: %.2f   effect = %i\n", sSoundName.c_str(), volume, iEffectNum);
+    }
+
+    commandManager.PlaySound(sSoundName, trace.endpos, -1, volume, -1, -1, 1);
+
+    if (iEffectNum != -1) {
+        sfxManager.MakeEffect_Angles(iEffectNum, trace.endpos, Vector(270, 0, 0));
+    }
 }
 
 /*
@@ -1023,5 +1194,5 @@ qboolean ClientSpecialEffectsManager::EffectsPending()
 
 specialeffect_t *ClientSpecialEffectsManager::GetTestEffectPointer()
 {
-    return &m_effects[SPECIAL_EFFECT_TEST];
+    return &m_effects[SFX_TEST_EFFECT];
 }

code/cgame/cg_specialfx.h

@@ -170,12 +170,9 @@ public:
     specialeffectcommand_t *AddNewCommand();
 };
 
-#define MAX_SPECIAL_EFFECTS 99
-#define SPECIAL_EFFECT_TEST MAX_SPECIAL_EFFECTS - 1
-
 class ClientSpecialEffectsManager : public Listener
 {
-    specialeffect_t m_effects[99];
+    specialeffect_t m_effects[SFX_COUNT];
     qboolean        m_bEffectsLoaded;
     int             m_iNumPendingEvents;
 

code/cgame/cg_tempmodels.cpp

@@ -79,6 +79,11 @@ void ClientGameCommandManager::FreeTempModel(ctempmodel_t *p)
 
     RemoveClientEntity(p->number, p->cgd.tiki, NULL, p);
 
+    if (m_active_tempmodels.next == p) {
+        // use the next active temp model
+        m_active_tempmodels.next = p->next;
+    }
+
     // remove from the doubly linked active list
     p->prev->next = p->next;
     p->next->prev = p->prev;
@@ -86,6 +91,22 @@ void ClientGameCommandManager::FreeTempModel(ctempmodel_t *p)
     // the free list is only singly linked
     p->next           = m_free_tempmodels;
     m_free_tempmodels = p;
+
+    if (p->m_spawnthing) {
+        p->m_spawnthing->numtempmodels--;
+        // delete unused spawnthings
+        if (!p->m_spawnthing->numtempmodels) {
+            m_emitters.RemoveObject(p->m_spawnthing);
+
+            if (p->m_spawnthing == m_spawnthing) {
+                m_spawnthing = NULL;
+            }
+
+            delete p->m_spawnthing;
+        }
+
+        p->m_spawnthing = NULL;
+    }
 }
 
 //===============
@@ -418,9 +439,11 @@ qboolean ClientGameCommandManager::TempModelRealtimeEffects(ctempmodel_t *p, flo
 
         p->ent.shaderRGBA[0] = (int)((float)tempColor[0] * vLighting[0]);
         p->ent.shaderRGBA[1] = (int)((float)tempColor[1] * vLighting[1]);
+        p->ent.shaderRGBA[2] = (int)((float)tempColor[2] * vLighting[2]);
     } else {
         p->ent.shaderRGBA[0] = tempColor[0];
         p->ent.shaderRGBA[1] = tempColor[1];
+        p->ent.shaderRGBA[2] = tempColor[2];
     }
 
     if (p->cgd.flags & T_FADEIN && (fadein < 1)) // Do the fadein effect
@@ -518,6 +541,7 @@ qboolean ClientGameCommandManager::TempModelPhysics(ctempmodel_t *p, float ftime
     Vector  tempangles;
     trace_t trace;
     float   dot;
+    int     i;
 
     VectorCopy(p->ent.origin, p->lastEnt.origin);
     AxisCopy(p->ent.axis, p->lastEnt.axis);
@@ -633,9 +657,7 @@ qboolean ClientGameCommandManager::TempModelPhysics(ctempmodel_t *p, float ftime
             p->cgd.velocity.x = Q_clamp_float(p->cgd.velocity.x, p->cgd.minVel.x, p->cgd.maxVel.x);
             p->cgd.velocity.y = Q_clamp_float(p->cgd.velocity.y, p->cgd.minVel.y, p->cgd.maxVel.y);
             p->cgd.velocity.z = Q_clamp_float(p->cgd.velocity.z, p->cgd.minVel.z, p->cgd.maxVel.z);
-        }
-
-        if (p->cgd.flags2 & T2_CLAMP_VEL_AXIS) {
+        } else if (p->cgd.flags2 & T2_CLAMP_VEL_AXIS) {
             Vector localVelocity;
             localVelocity.x = DotProduct(p->cgd.velocity, p->ent.axis[0]);
             localVelocity.y = DotProduct(p->cgd.velocity, p->ent.axis[1]);
@@ -650,8 +672,48 @@ qboolean ClientGameCommandManager::TempModelPhysics(ctempmodel_t *p, float ftime
             p->cgd.velocity.z = DotProduct(localVelocity, p->ent.axis[2]);
         }
 
-        if (p->cgd.flags2 & T_ALIGN) {
-            // FIXME: vss wind
+        if (p->cgd.flags2 & T2_WIND_AFFECT) {
+            for (i = 0; i < 3; i++) {
+                float fWind;
+
+                switch (i) {
+                case 0:
+                    fWind = vss_wind_x->value;
+                    break;
+                case 1:
+                    fWind = vss_wind_y->value;
+                    break;
+                case 2:
+                    fWind = vss_wind_z->value;
+                    break;
+                }
+
+                if (fWind < 0) {
+                    if (p->cgd.velocity[i] > fWind) {
+                        p->cgd.velocity[i] -= ftime * vss_wind_strength->value;
+                        if (p->cgd.velocity[i] > fWind) {
+                            p->cgd.velocity[i] = fWind;
+                        }
+                    } else if (p->cgd.velocity[i] < fWind) {
+                        p->cgd.velocity[i] += ftime * vss_movement_dampen->value;
+                        if (p->cgd.velocity[i] < fWind) {
+                            p->cgd.velocity[i] = fWind;
+                        }
+                    }
+                } else {
+                    if (p->cgd.velocity[i] < fWind) {
+                        p->cgd.velocity[i] += ftime * vss_wind_strength->value;
+                        if (p->cgd.velocity[i] > fWind) {
+                            p->cgd.velocity[i] = fWind;
+                        }
+                    } else if (p->cgd.velocity[i] > fWind) {
+                        p->cgd.velocity[i] -= ftime * vss_wind_strength->value;
+                        if (p->cgd.velocity[i] < fWind) {
+                            p->cgd.velocity[i] = fWind;
+                        }
+                    }
+                }
+            }
         }
     } else {
         Vector normal;
@@ -913,7 +975,12 @@ void ClientGameCommandManager::AddTempModels(void)
         // time of this tempmodel
         lerpfrac = (float)(cg.time - p->lastPhysicsTime) / (float)physics_rate;
         // Clamp
-        lerpfrac = Q_clamp_float(lerpfrac, 0, 1);
+        if (lerpfrac > 1 || (p->cgd.flags2 & T2_PHYSICS_EVERYFRAME)) {
+            lerpfrac = 1;
+        }
+        if (lerpfrac < 0) {
+            lerpfrac = 0;
+        }
 
         // Increment the time this tempmodel has been alive
         p->aliveTime += frameTime;
@@ -1137,7 +1204,13 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
             {
                 Vector dst;
                 // Create a circular shaped burst around the up vector
-                float angle = ((float)count / (float)m_spawnthing->count) * 360; // * M_PI * 2;
+                float angle;
+                
+                if (mcount == 1) {
+                    angle = random() * 360;
+                } else {
+                    angle = ((float)count / (float)m_spawnthing->count) * 360; // * M_PI * 2;
+                }
 
                 Vector end = Vector(vLeft) * m_spawnthing->sphereRadius * current_entity_scale;
                 RotatePointAroundVector(dst, Vector(vForward), end, angle);
@@ -1146,7 +1219,7 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
                 newForward = p->cgd.origin - m_spawnthing->cgd.origin;
                 newForward.normalize();
             }
-        } else if (m_spawnthing->cgd.flags & T_SPHERE) {
+        } else if (m_spawnthing->cgd.flags & T_INWARDSPHERE) {
             // Project the origin along a random ray, and set the forward
             // vector pointing back to the origin
             Vector dir, end;
@@ -1182,10 +1255,9 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
             cosa   = cos(fAngle);
 
             p->cgd.origin = start + vForward * fHeight;
-            p->cgd.origin += start + vLeft * (cosa * fRadius);
-            p->cgd.origin += start + vUp * (sina * fRadius);
-        } else if (m_spawnthing->sphereRadius != 0) // Offset in a spherical pattern
-        {
+            p->cgd.origin += vLeft * (cosa * fRadius);
+            p->cgd.origin += vUp * (sina * fRadius);
+        } else if (m_spawnthing->sphereRadius != 0) { // Offset in a spherical pattern
             Vector dir, end;
 
             dir = Vector(crandom(), crandom(), crandom());
@@ -1391,7 +1463,7 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
             p->cgd.avelocity[i] = m_spawnthing->avelocity_amplitude[i] * random() + m_spawnthing->avelocity_base[i];
 
             // Randomize angles or set absolute
-            p->cgd.angles[i] += random() * m_spawnthing->angles_amplitude[i];
+            p->cgd.angles[i] = m_spawnthing->angles_amplitude[i] * random() + m_spawnthing->cgd.angles[i];
         }
 
         // If forward velocity is set, just use that otherwise use random
@@ -1425,18 +1497,15 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
             }
         }
 
-        // Calculate one tick of velocity based on time alive ( passed in )
-        p->cgd.origin = p->cgd.origin + (p->cgd.velocity * ((float)p->aliveTime / 1000.0f) * current_entity_scale);
-
-        if (p->cgd.flags2 & T2_ACCEL) {
+        if (m_spawnthing->cgd.flags2 & T2_RADIALVELOCITY) {
             float fLength;
 
             p->cgd.velocity = p->cgd.origin - start;
 
             fLength = p->cgd.velocity.length();
             if (fLength) {
-                float fVel = m_spawnthing->cgd.velocity.x
-                           + (m_spawnthing->cgd.velocity.y + m_spawnthing->cgd.velocity.z * crandom()) / fLength;
+                float fVel = m_spawnthing->cgd.velocity[0]
+                           + (m_spawnthing->cgd.velocity[1] + m_spawnthing->cgd.velocity[2] * random()) / fLength;
 
                 p->cgd.velocity *= fVel;
             }
@@ -1447,20 +1516,22 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
                 (m_spawnthing->randvel_base[i] + m_spawnthing->randvel_amplitude[i] * random()) * current_entity_scale;
 
             if (m_spawnthing->cgd.flags & T_RANDVELAXIS) {
-                p->cgd.velocity += fVel * Vector(m_spawnthing->tag_axis[i]);
+                if (p->cgd.flags2 & T2_NOTAGAXIS) {
+                    p->cgd.velocity += fVel * Vector(m_spawnthing->axis[i]);
+                } else {
+                    p->cgd.velocity += fVel * Vector(m_spawnthing->tag_axis[i]);
+                }
             } else {
                 p->cgd.velocity[i] += fVel;
             }
         }
 
         if (p->cgd.flags & (T_ALIGN | T_DETAIL)) {
-            if (p->cgd.velocity.x && p->cgd.velocity.y) {
-                p->cgd.angles = p->cgd.velocity.toAngles();
-            }
-
-            p->cgd.origin += p->cgd.velocity * (p->aliveTime / 1000.0) * current_entity_scale;
+            p->cgd.angles = p->cgd.velocity.toAngles();
         }
 
+        p->cgd.origin += p->cgd.velocity * (p->aliveTime / 1000.0) * current_entity_scale;
+
         if (p->cgd.flags & T_AUTOCALCLIFE) {
             Vector  end, delta;
             float   length, speed;

code/cgame/cg_ui.cpp

@@ -25,6 +25,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cg_local.h"
 #include "str.h"
+#include "../client/keycodes.h"
 
 void CG_MessageMode_f(void)
 {
@@ -61,8 +62,8 @@ void CG_MessageMode_Private_f(void)
         return;
     }
 
-    clientNum = atoi(cgi.Argv(1)) - 1;
-    if (clientNum < 0 || clientNum >= MAX_CLIENTS) {
+    clientNum = atoi(cgi.Argv(1));
+    if (clientNum < 1 || clientNum >= MAX_CLIENTS) {
         cgi.Printf(HUD_MESSAGE_CHAT_WHITE "Message Error: %s is a bad client number\n", cgi.Argv(1));
         return;
     }
@@ -192,8 +193,36 @@ void CG_HudPrint_f(void)
     cgi.Printf("\x1%s", cgi.Argv(1));
 }
 
-int CG_CheckCaptureKey(int key, qboolean down, unsigned int time)
+qboolean CG_CheckCaptureKey(int key, qboolean down, unsigned int time)
 {
-    // FIXME: unimplemented
-    return 0;
+    char minKey = '1', maxKey = '9';
+
+    if (!cg.iInstaMessageMenu || !down) {
+        return qfalse;
+    }
+
+    if (cg_protocol >= protocol_e::PROTOCOL_MOHTA_MIN) {
+        maxKey = '8';
+    }
+
+    if (key < minKey || key > maxKey) {
+        if (key == K_ESCAPE || key == '0') {
+            cg.iInstaMessageMenu = 0;
+            return qtrue;
+        }
+        return qfalse;
+    }
+
+    if (cg.iInstaMessageMenu == -1) {
+        if (key > '6') {
+            cg.iInstaMessageMenu = 0;
+        } else {
+            cg.iInstaMessageMenu = key - '0';
+        }
+    } else if (cg.iInstaMessageMenu > 0) {
+        cgi.SendClientCommand(va("dmmessage 0 *%i%i\n", cg.iInstaMessageMenu, key - '0'));
+        cg.iInstaMessageMenu = 0;
+    }
+
+    return qtrue;
 }

code/cgame/cg_view.c

@@ -242,6 +242,7 @@ void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition)
     float      mat[3][3];
     vec3_t     vOldOrigin;
     vec3_t     vStart, vEnd, vMins, vMaxs;
+    vec3_t     vVelocity;
     trace_t    trace;
 
     VectorSet(vMins, -6, -6, -6);
@@ -297,6 +298,15 @@ void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition)
 
     VectorCopy(origin, vOldOrigin);
 
+    if (!cg.predicted_player_state.walking || !(cg.predicted_player_state.pm_flags & PMF_FROZEN)) {
+        VectorCopy(cg.predicted_player_state.velocity, vVelocity);
+    } else {
+        //
+        // Added in OPM
+        //  When frozen, there must be no movement at all
+        VectorClear(vVelocity);
+    }
+
     if (bUseWorldPosition) {
         iMask = MASK_VIEWSOLID;
     } else {
@@ -367,7 +377,7 @@ void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition)
         }
 
         if (cg.predicted_player_state.walking) {
-            fVel   = VectorLength(cg.predicted_player_state.velocity);
+            fVel   = VectorLength(vVelocity);
             fPhase = fVel * 0.0015 + 0.9;
             cg.fCurrentViewBobPhase += (cg.frametime / 1000.0 + cg.frametime / 1000.0) * M_PI * fPhase;
 
@@ -446,7 +456,7 @@ void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition)
         AngleVectorsLeft(vDelta, mat[0], mat[1], mat[2]);
 
         CG_CalcViewModelMovement(
-            cg.fCurrentViewBobPhase, cg.fCurrentViewBobAmp, cg.predicted_player_state.velocity, vDelta
+            cg.fCurrentViewBobPhase, cg.fCurrentViewBobAmp, vVelocity, vDelta
         );
 
         VectorMA(pREnt->origin, vDelta[0], mat[0], pREnt->origin);
@@ -560,17 +570,6 @@ static int CG_CalcViewValues(void)
     CG_CalcVrect();
     CG_SetupFog();
 
-    // setup fog and far clipping plane
-    cg.refdef.farplane_distance = cg.farplane_distance;
-    VectorCopy(cg.farplane_color, cg.refdef.farplane_color);
-    cg.refdef.farplane_cull = cg.farplane_cull;
-
-    // setup portal sky
-    cg.refdef.sky_alpha  = cg.sky_alpha;
-    cg.refdef.sky_portal = cg.sky_portal;
-    memcpy(cg.refdef.sky_axis, cg.sky_axis, sizeof(cg.sky_axis));
-    VectorCopy(cg.sky_origin, cg.refdef.sky_origin);
-
     ps = &cg.predicted_player_state;
 
     VectorCopy(ps->origin, cg.refdef.vieworg);
@@ -723,7 +722,37 @@ float CG_SensitivityScale()
 
 void CG_AddLightShow()
 {
-    // FIXME: unimplemented
+    int i;
+    float fSlopeY, fSlopeZ;
+    float x, y, z;
+    vec3_t vOrg;
+    float r, g, b;
+    float fMax;
+
+    fSlopeY = tan(cg.refdef.fov_x * 0.5);
+    fSlopeZ = tan(cg.refdef.fov_y * 0.5);
+
+    for (i = 0; i < cg_acidtrip->integer; i++) {
+        x = pow(random(), 1.0 / 3.0) * 2048.0;
+        y = crandom() * x * fSlopeY;
+        z = crandom() * x * fSlopeZ;
+
+        VectorCopy(cg.refdef.vieworg, vOrg);
+        VectorMA(vOrg, x, cg.refdef.viewaxis[0], vOrg);
+        VectorMA(vOrg, y, cg.refdef.viewaxis[1], vOrg);
+        VectorMA(vOrg, z, cg.refdef.viewaxis[2], vOrg);
+
+        r = random();
+        g = random();
+        b = random();
+
+        fMax = Q_max(r, Q_max(g, b));
+        r /= fMax;
+        g /= fMax;
+        b /= fMax;
+
+        cgi.R_AddLightToScene(vOrg, (rand() & 0x1FF) + 0x80, r, g, b, 0);
+    }
 }
 
 qboolean CG_FrustumCullSphere(const vec3_t vPos, float fRadius) {
@@ -882,13 +911,13 @@ void CG_DrawActiveFrame(int serverTime, int frameTime, stereoFrame_t stereoView,
                     {
                     default:
                     case 0:
-                        cgi.UI_HideMenu("mission_success_1", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_success_1", qtrue);
                         break;
                     case 2:
-                        cgi.UI_HideMenu("mission_success_2", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_success_2", qtrue);
                         break;
                     case 3:
-                        cgi.UI_HideMenu("mission_success_3", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_success_3", qtrue);
                         break;
                     }
                 } else {
@@ -896,21 +925,21 @@ void CG_DrawActiveFrame(int serverTime, int frameTime, stereoFrame_t stereoView,
                     {
                     default:
                     case 0:
-                        cgi.UI_HideMenu("mission_failed_1", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_failed_1", qtrue);
                         break;
                     case 2:
-                        cgi.UI_HideMenu("mission_failed_2", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_failed_2", qtrue);
                         break;
                     case 3:
-                        cgi.UI_HideMenu("mission_failed_3", CVAR_ARCHIVE);
+                        cgi.UI_HideMenu("mission_failed_3", qtrue);
                         break;
                     }
                 }
             } else {
                 if (cgi.Cvar_Get("g_success", "", 0)->integer) {
-                    cgi.UI_HideMenu("StatsScreen_Success", qfalse);
+                    cgi.UI_HideMenu("StatsScreen_Success", qtrue);
                 } else {
-                    cgi.UI_HideMenu("StatsScreen_Failed", qfalse);
+                    cgi.UI_HideMenu("StatsScreen_Failed", qtrue);
                 }
             }
         }

code/cgame/cg_viewmodelanim.c

@@ -28,6 +28,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 static const char *AnimPrefixList[] = {
     "",
+    "unarmed",
     "papers",
     "colt45",
     "p38",
@@ -45,7 +46,6 @@ static const char *AnimPrefixList[] = {
     "bazooka",
     "panzerschreck",
     "shotgun",
-    "unarmed",
     //
     // Team Assault and Team Tactics weapons
     "mg42portable",
@@ -82,6 +82,7 @@ static const char *AnimPrefixList[] = {
 
 enum animPrefix_e {
     WPREFIX_NONE,
+    WPREFIX_UNARMED,
     WPREFIX_PAPERS,
     WPREFIX_COLT45,
     WPREFIX_P38,
@@ -99,7 +100,6 @@ enum animPrefix_e {
     WPREFIX_BAZOOKA,
     WPREFIX_PANZERSCHRECK,
     WPREFIX_SHOTGUN,
-    WPREFIX_UNARMED,
     //
     // Team Assault and Team Tactics weapons
     WPREFIX_MG42_PORTABLE,
@@ -308,6 +308,9 @@ int CG_GetVMAnimPrefixIndex()
         if (!Q_stricmp(szWeaponName, "Panzerschreck")) {
             return WPREFIX_PANZERSCHRECK;
         }
+        if (!Q_stricmp(szWeaponName, "Gewehrgranate")) {
+            return WPREFIX_KAR98_MORTAR;
+        }
         if (!Q_stricmp(szWeaponName, "Shotgun")) {
             return WPREFIX_SHOTGUN;
         }
@@ -335,9 +338,11 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
     char        szAnimName[MAX_QPATH];
     dtiki_t    *pTiki;
     qboolean    bAnimChanged;
+    qboolean    bWeaponChanged;
 
     fCrossblendFrac = 0.0;
-    bAnimChanged    = 0;
+    bAnimChanged    = qfalse;
+    bWeaponChanged  = qfalse; // Added in OPM
     pTiki           = pModel->tiki;
 
     if (cgi.anim->g_iLastEquippedWeaponStat == cg.snap->ps.stats[STAT_EQUIPPED_WEAPON]
@@ -346,13 +351,15 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
     } else {
         iAnimPrefixIndex                    = CG_GetVMAnimPrefixIndex();
         cgi.anim->g_iLastEquippedWeaponStat = cg.snap->ps.stats[STAT_EQUIPPED_WEAPON];
-        strcpy(cgi.anim->g_szLastActiveItem, CG_ConfigString(CS_WEAPONS + cg.snap->ps.activeItems[1]));
+        Q_strncpyz(cgi.anim->g_szLastActiveItem, CG_ConfigString(CS_WEAPONS + cg.snap->ps.activeItems[1]), sizeof(cgi.anim->g_szLastActiveItem));
         cgi.anim->g_iLastAnimPrefixIndex = iAnimPrefixIndex;
-        bAnimChanged                     = qtrue;
+
+        bAnimChanged   = qtrue;
+        bWeaponChanged = qtrue;
     }
 
     if (cgi.anim->g_iLastVMAnim == -1) {
-        sprintf(szAnimName, "%s_idle", AnimPrefixList[iAnimPrefixIndex]);
+        Com_sprintf(szAnimName, sizeof(szAnimName), "%s_idle", AnimPrefixList[iAnimPrefixIndex]);
         cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index = cgi.Anim_NumForName(pTiki, szAnimName);
 
         if (cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index == -1) {
@@ -421,21 +428,28 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
             break;
         }
 
-        sprintf(szAnimName, "%s_%s", AnimPrefixList[iAnimPrefixIndex], pszAnimSuffix);
-        fCrossblendTime = cgi.Anim_CrossblendTime(pTiki, cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index);
-        fCrossblendAmount = cgi.anim->g_iCurrentVMDuration / 1000.0;
+        Com_sprintf(szAnimName, sizeof(szAnimName), "%s_%s", AnimPrefixList[iAnimPrefixIndex], pszAnimSuffix);
+        if (!bWeaponChanged) {
+            fCrossblendTime =
+                cgi.Anim_CrossblendTime(pTiki, cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index);
+            fCrossblendAmount = cgi.anim->g_iCurrentVMDuration / 1000.0;
 
-        if (fCrossblendAmount < fCrossblendTime && fCrossblendAmount > 0.0) {
-            fCrossblendFrac = fCrossblendAmount / fCrossblendTime;
-            for (i = 0; i < MAX_FRAMEINFOS; ++i) {
-                if (cgi.anim->g_VMFrameInfo[i].weight) {
-                    if (i == cgi.anim->g_iCurrentVMAnimSlot) {
-                        cgi.anim->g_VMFrameInfo[i].weight = fCrossblendFrac;
-                    } else {
-                        cgi.anim->g_VMFrameInfo[i].weight *= (1.0 - fCrossblendFrac);
+            if (fCrossblendAmount < fCrossblendTime && fCrossblendAmount > 0.0) {
+                fCrossblendFrac = fCrossblendAmount / fCrossblendTime;
+                for (i = 0; i < MAX_FRAMEINFOS; ++i) {
+                    if (cgi.anim->g_VMFrameInfo[i].weight) {
+                        if (i == cgi.anim->g_iCurrentVMAnimSlot) {
+                            cgi.anim->g_VMFrameInfo[i].weight = fCrossblendFrac;
+                        } else {
+                            cgi.anim->g_VMFrameInfo[i].weight *= (1.0 - fCrossblendFrac);
+                        }
                     }
                 }
             }
+        } else {
+            fCrossblendTime   = 0;
+            fCrossblendAmount = 0;
+            fCrossblendFrac   = 0;
         }
 
         cgi.anim->g_iCurrentVMAnimSlot = (cgi.anim->g_iCurrentVMAnimSlot + 1) % MAX_FRAMEINFOS;
@@ -450,17 +464,31 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
         cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].weight = 1.0;
         cgi.anim->g_iCurrentVMDuration                                 = 0;
 
-        fCrossblendTime = cgi.Anim_CrossblendTime(pTiki, cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index);
-        if (!fCrossblendTime) {
+        if (!bWeaponChanged) {
+            fCrossblendTime =
+                cgi.Anim_CrossblendTime(pTiki, cgi.anim->g_VMFrameInfo[cgi.anim->g_iCurrentVMAnimSlot].index);
+            if (!fCrossblendTime) {
+                for (i = 0; i < MAX_FRAMEINFOS; ++i) {
+                    if (i != cgi.anim->g_iCurrentVMAnimSlot) {
+                        cgi.anim->g_VMFrameInfo[i].weight = 0.0;
+                    }
+                }
+
+                cgi.anim->g_bCrossblending = qfalse;
+            } else {
+                cgi.anim->g_bCrossblending = qtrue;
+            }
+        } else {
+            // Added in OPM
+            //  If there is a new weapon, don't do any crossblend
+            cgi.anim->g_bCrossblending = qfalse;
+
+            // clear crossblend values
             for (i = 0; i < MAX_FRAMEINFOS; ++i) {
                 if (i != cgi.anim->g_iCurrentVMAnimSlot) {
                     cgi.anim->g_VMFrameInfo[i].weight = 0.0;
                 }
             }
-
-            cgi.anim->g_bCrossblending = qfalse;
-        } else {
-            cgi.anim->g_bCrossblending = qtrue;
         }
     }
 

code/cgame/cg_volumetricsmoke.cpp

@@ -42,7 +42,9 @@ const char *cg_vsstypes[] = {
     "debris"
 };
 
-cvssource_t *vss_sorttable[16384];
+#define MAX_VSS_SORTS 16384
+
+cvssource_t *vss_sorttable[MAX_VSS_SORTS];
 
 static int             lastVSSFrameTime;
 static constexpr float MAX_VSS_COORDS            = 8096.0;
@@ -78,56 +80,57 @@ void VSS_AddRepulsion(cvssource_t *pA, cvssource_t *pB)
 
     VectorSubtract(pA->newOrigin, pB->newOrigin, vPush);
 
-    if (vPush[0] || vPush[1] || vPush[2]) {
-        fDist = VectorNormalize(vPush);
-        f     = fDist - pB->newRadius;
-
-        if (f > 0.0) {
-            f *= pA->ooRadius;
-            if (f > 1.49) {
-                f = 0.0;
-            } else {
-                f = f * (f * 0.0161 + -0.3104) + 1.2887;
-            }
-
-            if (f < 0.0) {
-                f = f * 1.1;
-            }
-
-            fForce = f;
-        } else {
-            fForce = 1.0;
-        }
-
-        f = fDist - pA->newRadius;
-        if (f > 0.0) {
-            f *= pB->ooRadius;
-            if (f > 1.49) {
-                f = 0.0;
-            } else {
-                f = f * (f * 0.0161 + -0.3104) + 1.2887;
-            }
-
-            if (f < 0.0) {
-                f = f * 1.1;
-            }
-
-            fForce += f;
-        } else {
-            fForce += 1.0;
-        }
-
-        if (fForce <= -0.05 && fForce >= 0.05) {
-            fForce = (pA->newRadius + pB->newRadius) * 0.03 * fForce;
-            VectorScale(vPush, fForce, vPush);
-
-            VectorAdd(pA->repulsion, vPush, pA->repulsion);
-            VectorSubtract(pB->repulsion, vPush, pB->repulsion);
-        }
-    } else {
+    if (!vPush[0] && !vPush[1] && !vPush[2]) {
         VectorSet(vPush, crandom(), crandom(), crandom());
         VectorAdd(pA->repulsion, vPush, pA->repulsion);
         VectorSubtract(pB->repulsion, vPush, pB->repulsion);
+        return;
+    }
+
+    fDist = VectorNormalize(vPush);
+    f     = fDist - pB->newRadius;
+
+    if (f > 0.0f) {
+        f *= pA->ooRadius;
+        if (f > 1.49f) {
+            f = 0.0f;
+        } else {
+            f = f * (f * 0.0161f + -0.3104f) + 1.2887f;
+        }
+
+        if (f < 0.0) {
+            f *= 1.1f;
+        }
+
+        fForce = f;
+    } else {
+        fForce = 1.0;
+    }
+
+    f = fDist - pA->newRadius;
+    if (f > 0.0) {
+        f *= pB->ooRadius;
+        if (f > 1.49f) {
+            f = 0.0f;
+        } else {
+            f = f * (f * 0.0161f + -0.3104f) + 1.2887f;
+        }
+
+        if (f < 0.0) {
+            f *= 1.1f;
+        }
+
+        fForce += f;
+    } else {
+        fForce += 1.0f;
+    }
+
+    if (fForce <= -0.05f || fForce >= 0.05f) {
+        fForce = (pA->newRadius + pB->newRadius) * 0.03f * fForce;
+        VectorScale(vPush, fForce, vPush);
+
+        VectorAdd(pA->repulsion, vPush, pA->repulsion);
+        VectorSubtract(pB->repulsion, vPush, pB->repulsion);
     }
 }
 
@@ -206,7 +209,7 @@ void ClientGameCommandManager::ResetVSSSources()
 
 void ClientGameCommandManager::ResetVSSSources(Event *ev)
 {
-    // FIXME: stub??
+    ResetVSSSources();
 }
 
 void CG_ResetVSSSources()
@@ -286,13 +289,13 @@ qboolean VSS_SourcePhysics(cvssource_t *pSource, float ftime)
 
     fWind = 0.0;
 
-    if ((pSource->flags2 & 5) != 0) {
+    if ((pSource->flags2 & (T2_ACCEL | T2_MOVE)) != 0) {
         VectorMA(pSource->velocity, ftime, pSource->repulsion, pSource->velocity);
     }
 
     pSource->lastOrigin = pSource->newOrigin;
 
-    if (pSource->flags & 0x800) {
+    if (pSource->flags & T_COLLISION) {
         trace.allsolid = qfalse;
         CG_ClipMoveToEntities(
             pSource->newOrigin, vec3_origin, vec3_origin, pSource->newOrigin, -1, MASK_VOLUMETRIC_SMOKE, &trace, qfalse
@@ -312,11 +315,11 @@ qboolean VSS_SourcePhysics(cvssource_t *pSource, float ftime)
         }
     }
 
-    if (pSource->flags2 & 5) {
+    if (pSource->flags2 & (T2_ACCEL | T2_MOVE)) {
         VectorMA(pSource->newOrigin, ftime, pSource->velocity, pSource->newOrigin);
     }
 
-    if (pSource->flags & 0x800) {
+    if (pSource->flags & T_COLLISION) {
         CG_Trace(
             &trace,
             pSource->lastOrigin,
@@ -334,6 +337,8 @@ qboolean VSS_SourcePhysics(cvssource_t *pSource, float ftime)
             float  fDot;
             vec3_t vNorm;
 
+            VectorCopy(trace.plane.normal, vNorm);
+
             VectorAdd(trace.endpos, trace.plane.normal, pSource->newOrigin);
             fDot = DotProduct(vNorm, pSource->velocity);
             VectorMA(pSource->velocity, fDot, vNorm, pSource->velocity);
@@ -358,7 +363,7 @@ qboolean VSS_SourcePhysics(cvssource_t *pSource, float ftime)
     }
 
     iSmokeType = abs(pSource->smokeType);
-    if (pSource->flags2 & 5) {
+    if (pSource->flags2 & (T2_ACCEL | T2_MOVE)) {
         VectorCopy(pSource->velocity, vVel);
 
         for (i = 0; i < 3; i++) {
@@ -619,7 +624,7 @@ qboolean VSS_LerpSource(cvssource_t *pCurrent, cvssourcestate_t *pState, float f
 {
     int i;
 
-    if (pCurrent->flags & 0xA0000) {
+    if (pCurrent->flags & (T_HARDLINK | T_PARENTLINK)) {
         Vector parentOrigin;
 
         for (i = 0; i < 3; i++) {
@@ -638,7 +643,7 @@ qboolean VSS_LerpSource(cvssource_t *pCurrent, cvssourcestate_t *pState, float f
 
         parentOrigin = e->origin;
         VectorAdd(pState->origin, parentOrigin, pState->origin);
-    } else if (pCurrent->flags2 & 5) {
+    } else if (pCurrent->flags2 & (T2_ACCEL | T2_MOVE)) {
         for (i = 0; i < 3; i++) {
             pState->origin[i] =
                 (pCurrent->newOrigin[i] - pCurrent->lastOrigin[i]) * fLerpFrac + pCurrent->lastOrigin[i];
@@ -741,9 +746,8 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
 
         pSource->startAlpha = (random() * 0.15 + 0.85) * fDensity;
         pSource->newDensity = 0.0;
-        if (m_spawnthing->cgd.flags & 1) {
+        if (m_spawnthing->cgd.flags & T_RANDSCALE) {
             pSource->newRadius = RandomizeRange(m_spawnthing->cgd.scalemin, m_spawnthing->cgd.scalemax);
-            ;
             if (pSource->newRadius > 32.0) {
                 pSource->newRadius = 32.0;
             }
@@ -772,16 +776,16 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
         pSource->roll      = anglemod(fAngle);
 
         if (random() < 0.5) {
-            pSource->flags |= 0x40000;
+            pSource->flags |= T_RANDOMROLL;
         }
 
         VectorCopy(m_spawnthing->axis[0], vNewForward);
-        if (m_spawnthing->cgd.flags & 4) {
+        if (m_spawnthing->cgd.flags & T_SPHERE) {
             VectorCopy(m_spawnthing->cgd.origin, pSource->newOrigin);
             do {
                 vNewForward = Vector(crandom(), crandom(), crandom());
             } while (Vector::Dot(vNewForward, vNewForward) < 1.0);
-        } else if (m_spawnthing->cgd.flags & 0x10) {
+        } else if (m_spawnthing->cgd.flags & T_CIRCLE) {
             if (m_spawnthing->sphereRadius != 0.0) {
                 Vector dst, end;
 
@@ -794,7 +798,7 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
 
                 fAngle += fAngleStep;
             }
-        } else if (m_spawnthing->cgd.flags & 8) {
+        } else if (m_spawnthing->cgd.flags & T_INWARDSPHERE) {
             Vector dir, end;
             do {
                 dir = Vector(crandom(), crandom(), crandom());
@@ -803,7 +807,7 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
             end = m_spawnthing->cgd.origin + dir * m_spawnthing->sphereRadius;
             VectorCopy(end, pSource->newOrigin);
             vNewForward = dir * -1.0;
-        } else if (m_spawnthing->cgd.flags2 & 0x20000) {
+        } else if (m_spawnthing->cgd.flags2 & T2_CONE) {
             float fHeight, fRadius;
             float fAngle;
             float sina, cosa;
@@ -825,8 +829,6 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
             VectorMA(m_spawnthing->cgd.origin, fRadius * cosa, m_spawnthing->axis[1], pSource->newOrigin);
             VectorMA(m_spawnthing->cgd.origin, fRadius * sina, m_spawnthing->axis[2], pSource->newOrigin);
         } else if (m_spawnthing->sphereRadius) {
-            VectorCopy(m_spawnthing->cgd.origin, pSource->newOrigin);
-        } else {
             Vector dir, end;
             do {
                 dir = Vector(crandom(), crandom(), crandom());
@@ -836,6 +838,8 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
             end = m_spawnthing->cgd.origin + dir * m_spawnthing->sphereRadius;
             VectorCopy(end, pSource->newOrigin);
             vNewForward = dir;
+        } else {
+            VectorCopy(m_spawnthing->cgd.origin, pSource->newOrigin);
         }
 
         for (i = 0; i < 3; i++) {
@@ -869,15 +873,14 @@ void ClientGameCommandManager::SpawnVSSSource(int count, int timealive)
         for (i = 0; i < 3; ++i) {
             float fDist = m_spawnthing->axis_offset_base[i] + random() * m_spawnthing->axis_offset_amplitude[i];
 
-            if (pSource->flags2 & 0x80) {
+            if (pSource->flags2 & T2_PARALLEL) {
                 pSource->newOrigin += Vector(m_spawnthing->axis[i]) * fDist;
             } else {
                 pSource->newOrigin += Vector(m_spawnthing->tag_axis[i]) * fDist;
             }
         }
 
-        pSource->velocity *= pSource->lifeTime / 1000.0;
-        pSource->newOrigin += pSource->velocity;
+        pSource->newOrigin += pSource->velocity * (pSource->lifeTime / 1000.0);
         if (vss_lighting_fps->integer) {
             cgi.R_GetLightingForSmoke(pSource->newLighting, pSource->newOrigin);
         }
@@ -890,251 +893,249 @@ void VSS_CalcRepulsionForces(cvssource_t *pActiveSources)
 {
     cvssource_t *pCurrent;
     cvssource_t *pComp;
+    qboolean     bXUp, bXDown;
+    qboolean     bYUp, bYDown;
+    qboolean     bZDown;
+    int          i;
+    int          iIndex;
+    int          iX, iY, iZ;
+    int          iMinX, iMinY, iMinZ;
+    int          iMaxX, iMaxY, iMaxZ;
+    float        fOfs;
+    cvssource_t *pSTLatch;
 
     pCurrent = pActiveSources->prev;
-    if (pCurrent != pActiveSources) {
-        qboolean     bXUp, bXDown;
-        qboolean     bYUp, bYDown;
-        qboolean     bZDown;
-        int          i;
-        int          iIndex;
-        int          iX, iY, iZ;
-        int          iMinX, iMinY, iMinZ;
-        int          iMaxX, iMaxY, iMaxZ;
-        float        fOfs;
-        cvssource_t *pSTLatch;
+    if (pCurrent == pActiveSources) {
+        return;
+    }
 
-        memset(vss_sorttable, 0, sizeof(vss_sorttable));
+    memset(vss_sorttable, 0, sizeof(vss_sorttable));
 
-        while (pCurrent != pActiveSources) {
-            VectorClear(pCurrent->repulsion);
+    for (pCurrent = pActiveSources->prev; pCurrent != pActiveSources; pCurrent = pCurrent->prev) {
+        VectorClear(pCurrent->repulsion);
 
-            iIndex = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5) / 96) % 32;
-            iIndex |= ((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5) / 96) % 32;
-            iIndex |= (((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5) / 96) % 16) << 10;
+        iIndex = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5) / 96) % 32;
+        iIndex |= (((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5) / 96) % 32) << 5;
+        iIndex |= (((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5) / 96) % 16) << 10;
 
-            pCurrent->stnext      = vss_sorttable[iIndex];
-            vss_sorttable[iIndex] = pCurrent;
-            pCurrent->stindex     = iIndex;
-            pCurrent              = pCurrent->prev;
+        pCurrent->stnext      = vss_sorttable[iIndex];
+        vss_sorttable[iIndex] = pCurrent;
+        pCurrent->stindex     = iIndex;
+    }
+
+    for (pCurrent = pActiveSources->prev; pCurrent != pActiveSources; pCurrent = pCurrent->prev) {
+        if (vss_sorttable[pCurrent->stindex] == pCurrent) {
+            pSTLatch = (cvssource_t *)-1;
+            pComp    = pCurrent->stnext;
+        } else {
+            pSTLatch = 0;
+            pComp    = vss_sorttable[pCurrent->stindex];
         }
 
-        for (pCurrent = pActiveSources->prev; pCurrent != pActiveSources; pCurrent = pCurrent->prev) {
-            if (vss_sorttable[pCurrent->stindex] == pCurrent) {
-                pSTLatch = (cvssource_t *)-1;
-                pComp    = pCurrent->stnext;
-            } else {
-                pSTLatch = 0;
-                pComp    = vss_sorttable[pCurrent->stindex];
+        for(; pComp; pComp = pComp->stnext) {
+            VSS_AddRepulsion(pCurrent, pComp);
+            if (!pSTLatch && pComp->stnext == pCurrent) {
+                pSTLatch = pComp;
+                // skip current
+                pComp    = pComp->stnext;
+            }
+        }
+
+        iX = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5) / 96) % 32;
+        iY = (((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5) / 96) % 32) << 5;
+        iZ = (((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5) / 96) % 16) << 10;
+
+        fOfs  = pCurrent->newRadius + 1.49 + 48.0;
+        iMaxX = ((int)floor(pCurrent->newOrigin[0] + fOfs + 8192.0 + 0.5) / 96) % 32;
+        iMaxY = (((int)floor(pCurrent->newOrigin[1] + fOfs + 8192.0 + 0.5) / 96) % 32) << 5;
+        iMaxZ = (((int)floor(pCurrent->newOrigin[2] + fOfs + 8192.0 + 0.5) / 96) % 16) << 10;
+
+        iMinX = ((int)floor(pCurrent->newOrigin[0] - fOfs + 8192.0 + 0.5) / 96) % 32;
+        iMinY = (((int)floor(pCurrent->newOrigin[1] - fOfs + 8192.0 + 0.5) / 96) % 32) << 5;
+        iMinZ = (((int)floor(pCurrent->newOrigin[2] - fOfs + 8192.0 + 0.5) / 96) % 16) << 10;
+
+        bXUp   = (iMaxX | (pCurrent->stindex & 0xFFFFFFE0)) != pCurrent->stindex;
+        bXDown = (iMinX | (pCurrent->stindex & 0xFFFFFFE0)) != pCurrent->stindex;
+        bYUp   = (iMaxY | (pCurrent->stindex & 0xFFFFFC1F)) != pCurrent->stindex;
+        bYDown = (iMinY | (pCurrent->stindex & 0xFFFFFC1F)) != pCurrent->stindex;
+
+        iIndex = iMinZ | (pCurrent->stindex & 0xFFFFC3FF);
+        bZDown = iIndex != pCurrent->stindex;
+
+        if (iIndex == pCurrent->stindex) {
+            iIndex = iMaxY | (pCurrent->stindex & 0xFFFFFC1F);
+
+            i = 9;
+        } else {
+            i = 0;
+        }
+
+        for (; i < (bZDown ? 26 : 17); i++) {
+            switch (i) {
+            case 0:
+                iIndex = iMaxZ | (pCurrent->stindex & 0xFFFFC3FF);
+                break;
+            case 1:
+                iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
+                if (bXUp) {
+                    break;
+                }
+                continue;
+            case 2:
+                iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
+                if (bXUp && bYUp) {
+                    break;
+                }
+                continue;
+            case 3:
+                iIndex = iMinY | (iIndex & 0xFFFFFC1F);
+                if (bXUp && bYDown) {
+                    break;
+                }
+                continue;
+            case 4:
+                iIndex = iMinY | (iIndex & 0xFFFFFFE0);
+                if (bYDown) {
+                    break;
+                }
+                continue;
+            case 5:
+                iIndex = iMinX | (iIndex & 0xFFFFFFE0);
+                if (bXDown && bYDown) {
+                    break;
+                }
+                continue;
+            case 6:
+                iIndex = iY | (iIndex & 0xFFFFFC1F);
+                if (bXDown) {
+                    break;
+                }
+                continue;
+            case 7:
+                iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
+                if (bXDown && bYUp) {
+                    break;
+                }
+                continue;
+            case 8:
+                iIndex = iX | (iIndex & 0xFFFFFFE0);
+                if (bYUp) {
+                    break;
+                }
+                continue;
+            case 9:
+                iIndex = iZ | (iIndex & 0xFFFFFFC3);
+                if (bYUp) {
+                    break;
+                }
+                continue;
+            case 10:
+                iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
+                if (bXUp && bYUp) {
+                    break;
+                }
+                continue;
+            case 11:
+                iIndex = iMinX | (iIndex & 0xFFFFFFE0);
+                if (bXDown && bYUp) {
+                    break;
+                }
+                continue;
+            case 12:
+                iIndex = iY | (iIndex & 0xFFFFFC1F);
+                if (bXDown) {
+                    break;
+                }
+                continue;
+            case 13:
+                iIndex = iMinY | (iIndex & 0xFFFFFC1F);
+                if (bXDown && bYDown) {
+                    break;
+                }
+                continue;
+            case 14:
+                iIndex = iX | (iIndex & 0xFFFFFFE0);
+                if (bYDown) {
+                    break;
+                }
+                continue;
+            case 15:
+                iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
+                if (bXUp && bYDown) {
+                    break;
+                }
+                continue;
+            case 16:
+                iIndex = iY | (iIndex & 0xFFFFFC1F);
+                if (bXUp) {
+                    break;
+                }
+                continue;
+            case 17:
+                iIndex = iMinZ | (iIndex & 0xFFFFFCC3);
+                if (bXUp) {
+                    break;
+                }
+                continue;
+            case 18:
+                iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
+                if (bXUp && bYUp) {
+                    break;
+                }
+                continue;
+            case 19:
+                iIndex = iMinY | (iIndex & 0xFFFFFC1F);
+                if (bXUp && bYDown) {
+                    break;
+                }
+                continue;
+            case 20:
+                iIndex = iX | (iIndex & 0xFFFFFFE0);
+                if (bYDown) {
+                    break;
+                }
+                continue;
+            case 21:
+                iIndex = iMinX | (iIndex & 0xFFFFFFE0);
+                if (bXDown && bYDown) {
+                    break;
+                }
+                continue;
+            case 22:
+                iIndex = iY | (iIndex & 0xFFFFFC1F);
+                if (bXDown) {
+                    break;
+                }
+                continue;
+            case 23:
+                iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
+                if (bXDown && bYUp) {
+                    break;
+                }
+                continue;
+            case 24:
+                iIndex = iX | (iIndex & 0xFFFFFFE0);
+                if (bYUp) {
+                    break;
+                }
+                continue;
+            case 25:
+                iIndex = iY | (iIndex & 0xFFFFFC1F);
+                break;
+            default:
+                assert(0); // This can't happen
+                break;
             }
 
-            while (pComp) {
+            for (pComp = vss_sorttable[iIndex]; pComp; pComp = pComp->stnext) {
                 VSS_AddRepulsion(pCurrent, pComp);
-                if (!pSTLatch && pComp->stnext == pCurrent) {
-                    pSTLatch = pComp;
-                    pComp    = pComp->stnext;
-                }
-
-                pComp = pComp->stnext;
             }
-            iX = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5) / 96) % 32;
-            iY = ((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5) / 96) % 32;
-            iY *= 2;
-            iZ = ((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5) / 96) % 16;
-            iZ <<= 10;
+        }
 
-            fOfs  = pCurrent->newRadius + 1.49 + 48.0;
-            iMaxX = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5 + fOfs) / 96) % 32;
-            iMaxY = ((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5 + fOfs) / 96) % 32;
-            iMaxY *= 2;
-            iMaxZ = ((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5 + fOfs) / 96) % 16;
-            iMaxZ <<= 10;
-
-            iMinX = ((int)floor(pCurrent->newOrigin[0] + 8192.0 + 0.5 - fOfs) / 96) % 32;
-            iMinY = ((int)floor(pCurrent->newOrigin[1] + 8192.0 + 0.5 - fOfs) / 96) % 32;
-            iMinY *= 2;
-            iMinZ = ((int)floor(pCurrent->newOrigin[2] + 8192.0 + 0.5 - fOfs) / 96) % 16;
-            iMinZ <<= 10;
-
-            bXUp   = (iMaxX | (pCurrent->stindex & 0xFFFFFFE0)) != pCurrent->stindex;
-            bXDown = (iMinX | (pCurrent->stindex & 0xFFFFFFE0)) != pCurrent->stindex;
-            bYUp   = (iMaxY | (pCurrent->stindex & 0xFFFFFC1F)) != pCurrent->stindex;
-            bYDown = (iMinY | (pCurrent->stindex & 0xFFFFFC1F)) != pCurrent->stindex;
-
-            iIndex = iMinZ | (pCurrent->stindex & 0xFFFFFCC3);
-            bZDown = iIndex != pCurrent->stindex;
-
-            if (iIndex == pCurrent->stindex) {
-                iIndex = iMaxY | pCurrent->stindex & 0xFFFFFC1F;
-                i      = 9;
-            } else {
-                i = 0;
-            }
-
-            for(; i < (bZDown ? 26 : 17); i++) {
-                switch (i) {
-                case 0:
-                    iIndex = iMaxZ | (pCurrent->stindex & 0xFFFFFCC3);
-                    break;
-                case 1:
-                    iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
-                    if (bXUp) {
-                        break;
-                    }
-                    continue;
-                case 2:
-                    iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
-                    if (bXUp && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 3:
-                    iIndex = iMinY | (iIndex & 0xFFFFFC1F);
-                    if (bXUp && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 4:
-                    iIndex = iMinY | (iIndex & 0xFFFFFFE0);
-                    if (bYDown) {
-                        break;
-                    }
-                    continue;
-                case 5:
-                    iIndex = iMinX | (iIndex & 0xFFFFFFE0);
-                    if (bXDown && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 6:
-                    iIndex = iY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown) {
-                        break;
-                    }
-                    continue;
-                case 7:
-                    iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 8:
-                    iIndex = iX | (iIndex & 0xFFFFFFE0);
-                    if (bYUp) {
-                        break;
-                    }
-                    continue;
-                case 9:
-                    iIndex = iZ | (iIndex & 0xFFFFFFC3);
-                    if (bYUp) {
-                        break;
-                    }
-                    continue;
-                case 10:
-                    iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
-                    if (bXUp && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 11:
-                    iIndex = iMinX | (iIndex & 0xFFFFFFE0);
-                    if (bXDown && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 12:
-                    iIndex = iY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown) {
-                        break;
-                    }
-                    continue;
-                case 13:
-                    iIndex = iMinY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 14:
-                    iIndex = iX | (iIndex & 0xFFFFFFE0);
-                    if (bYDown) {
-                        break;
-                    }
-                    continue;
-                case 15:
-                    iIndex = iMaxX | (iIndex & 0xFFFFFFE0);
-                    if (bXUp && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 16:
-                    iIndex = iY | (iIndex & 0xFFFFFC1F);
-                    if (bXUp) {
-                        break;
-                    }
-                    continue;
-                case 17:
-                    iIndex = iMinZ | (iIndex & 0xFFFFFCC3);
-                    if (bXUp) {
-                        break;
-                    }
-                    continue;
-                case 18:
-                    iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
-                    if (bXUp && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 19:
-                    iIndex = iMinY | (iIndex & 0xFFFFFC1F);
-                    if (bXUp && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 20:
-                    iIndex = iX | (iIndex & 0xFFFFFFE0);
-                    if (bYDown) {
-                        break;
-                    }
-                    continue;
-                case 21:
-                    iIndex = iMinX | (iIndex & 0xFFFFFFE0);
-                    if (bXDown && bYDown) {
-                        break;
-                    }
-                    continue;
-                case 22:
-                    iIndex = iY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown) {
-                        break;
-                    }
-                    continue;
-                case 23:
-                    iIndex = iMaxY | (iIndex & 0xFFFFFC1F);
-                    if (bXDown && bYUp) {
-                        break;
-                    }
-                    continue;
-                case 24:
-                    iIndex = iX | (iIndex & 0xFFFFFFE0);
-                    if (bYUp) {
-                        break;
-                    }
-                    continue;
-                case 25:
-                    iIndex = iY | (iIndex & 0xFFFFFC1F);
-                    break;
-                }
-
-                for (pComp = vss_sorttable[iIndex]; pComp; pComp = pComp->stnext) {
-                    VSS_AddRepulsion(pCurrent, pComp);
-                }
-            }
-
-            if (pSTLatch == (cvssource_t *)-1) {
-                vss_sorttable[pCurrent->stindex] = pCurrent->stnext;
-            } else {
-                pSTLatch->stnext = pCurrent->stnext;
-            }
+        if (pSTLatch == (cvssource_t *)-1) {
+            vss_sorttable[pCurrent->stindex] = pCurrent->stnext;
+        } else {
+            pSTLatch->stnext = pCurrent->stnext;
         }
     }
 }
@@ -1222,13 +1223,13 @@ void ClientGameCommandManager::AddVSSSources()
         pComp = pCurrent->prev;
 
         newEnt.renderfx = 0;
-        if (pCurrent->flags < 0 && !cg_detail->integer) {
+        if ((pCurrent->flags & T_DETAIL) && !cg_detail->integer) {
             FreeVSSSource(pCurrent);
             continue;
         }
 
-        if ((pCurrent->flags2 & 0x4000) != 0) {
-            newEnt.renderfx = 0x4000000;
+        if ((pCurrent->flags2 & T2_ALWAYSDRAW) != 0) {
+            newEnt.renderfx = RF_ALWAYSDRAW;
         }
 
         if (pCurrent->lastPhysicsTime) {
@@ -1237,8 +1238,8 @@ void ClientGameCommandManager::AddVSSSources()
                 mstime = physics_rate;
             }
 
-            if (mstime >= physics_rate || (pCurrent->flags2 & 0x10) != 0) {
-                if (!VSS_SourcePhysics(pCurrent, (float)mstime * 0.001)) {
+            if (mstime >= physics_rate || (pCurrent->flags2 & T2_PHYSICS_EVERYFRAME) != 0) {
+                if (!VSS_SourcePhysics(pCurrent, (float)mstime / 1000.0)) {
                     FreeVSSSource(pCurrent);
                     continue;
                 }
@@ -1262,26 +1263,18 @@ void ClientGameCommandManager::AddVSSSources()
             }
         }
 
-        fLerpFrac = (cg.time - pCurrent->lastPhysicsTime) / physics_rate;
-        if (fLerpFrac > 1.0) {
-            fLerpFrac = 1.0;
-        } else if (fLerpFrac < 0.0) {
-            fLerpFrac = 0.0;
-        }
+        fLerpFrac = (float)(cg.time - pCurrent->lastPhysicsTime) / (float)physics_rate;
+        fLerpFrac = Q_clamp_float(fLerpFrac, 0, 1);
 
-        fLightingFrac = (cg.time - pCurrent->lastLightingTime) / lighting_rate;
-        if (fLightingFrac > 1.0) {
-            fLightingFrac = 1.0;
-        } else if (fLightingFrac < 0.0) {
-            fLightingFrac = 0.0;
-        }
+        fLightingFrac = (float)(cg.time - pCurrent->lastLightingTime) / (float)lighting_rate;
+        fLightingFrac = Q_clamp_float(fLightingFrac, 0, 1);
 
         if (lastVSSFrameTime) {
             pCurrent->lifeTime += frameTime;
         }
 
         if (!pCurrent->lastValid) {
-            if (!VSS_SourcePhysics(pCurrent, (float)physics_rate * 0.001)) {
+            if (!VSS_SourcePhysics(pCurrent, (float)physics_rate / 1000)) {
                 ClientGameCommandManager::FreeVSSSource(pCurrent);
                 continue;
             }
@@ -1335,12 +1328,12 @@ void ClientGameCommandManager::AddVSSSources()
                         pCurrent->roll -= j;
                     }
 
-                    if ((pCurrent->flags & 0x40000) != 0) {
+                    if ((pCurrent->flags & T_RANDOMROLL) != 0) {
                         newEnt.hModel = hModel;
                     } else {
                         newEnt.hModel = hModel2;
                     }
-                } else if ((pCurrent->flags & 0x40000) != 0) {
+                } else if ((pCurrent->flags & T_RANDOMROLL) != 0) {
                     newEnt.hModel = hModel;
                 } else {
                     newEnt.hModel = hModel2;

code/cgame/memarchiver.cpp

@@ -42,23 +42,23 @@ MemArchiver::~MemArchiver()
 
 void MemArchiver::SetupForWriting(size_t initialSize)
 {
-    state = MEMARC_WRITING;
-    buffer = (byte*)cgi.Malloc(initialSize);
-    allocatedSize = initialSize;
-    bufferSize = 0;
+    this->state = MEMARC_WRITING;
+    this->buffer = (byte*)cgi.Malloc(initialSize);
+    this->allocatedSize = initialSize;
+    this->bufferSize = 0;
 }
 
 void MemArchiver::SetupForReading(byte* buffer, size_t size)
 {
-    state = MEMARC_READING;
-    buffer = buffer;
-    allocatedSize = size;
-    bufferSize = 0;
+    this->state = MEMARC_READING;
+    this->buffer = buffer;
+    this->allocatedSize = size;
+    this->bufferSize = 0;
 }
 
 void MemArchiver::SetBaseTime(unsigned int time)
 {
-    svsTime = time;
+    this->svsTime = time;
 }
 
 size_t MemArchiver::BufferSize() const

code/client/CMakeLists.txt

@@ -1,15 +1,17 @@
 cmake_minimum_required(VERSION 3.5)
 project(omohclient)
 
+option(NO_OPENAL "Use older sound-system" FALSE)
+
 add_subdirectory("../cgame" "./cgame")
 
-file(GLOB_RECURSE SOURCES_CLIENT "./*.c*")
+file(GLOB SOURCES_CLIENT "./*.c*")
 file(GLOB_RECURSE SOURCES_UILIB "../uilib/*.c*")
 
 # Made as an interface and not static, as static only links used methods
 add_library(omohclient INTERFACE)
-target_sources(omohclient INTERFACE ${SOURCES_CLIENT} ${SOURCES_UILIB})
 target_compile_definitions(omohclient INTERFACE APP_MODULE)
+target_compile_definitions(omohclient INTERFACE USE_OPENAL_DLOPEN=1)
 target_compile_features(omohclient INTERFACE cxx_nullptr)
 target_compile_features(omohclient INTERFACE c_variadic_macros)
 target_link_libraries(omohclient INTERFACE omohsdl)
@@ -18,5 +20,56 @@ target_link_libraries(omohclient INTERFACE gcd)
 # Sound stuff
 target_compile_definitions(omohclient INTERFACE USE_CODEC_MP3)
 
-add_subdirectory("../libmad-0.15.1b" "./libmad")
-target_link_libraries(omohclient INTERFACE libmad)
+if (NOT NO_OPENAL)
+	# Use OpenAL
+	find_package(OpenAL REQUIRED)
+
+	if (OPENAL_FOUND)
+		target_compile_definitions(omohclient INTERFACE USE_OPENAL=1 NO_MODERN_DMA=0)
+		if (MSVC)
+			target_include_directories(omohclient INTERFACE ${OPENAL_INCLUDE_DIR}/AL)
+		else()
+			target_include_directories(omohclient INTERFACE ${OPENAL_INCLUDE_DIR})
+		endif()
+		target_link_libraries(omohclient INTERFACE ${OPENAL_LIBRARY})
+	endif()
+
+	list(FILTER SOURCES_CLIENT EXCLUDE REGEX "./snd_([a-zA-Z0-9_]+)\.c$")
+	file(GLOB SOURCES_CLIENT_SND "./snd_*_new.c*" "./snd_codec*.c*")
+	list(APPEND SOURCES_CLIENT ${SOURCES_CLIENT_SND})
+else()
+	#
+	# Fallback to old DMA sound system
+	#
+	message(NOTICE "OpenAL was explicitly disabled - fallback to old SDL sound system")
+	target_compile_definitions(omohclient INTERFACE NO_MODERN_DMA=1)
+	set(NO_MODERN_DMA TRUE)
+
+	list(FILTER SOURCES_CLIENT EXCLUDE REGEX "./snd_([a-zA-Z0-9_]+)\.cpp$")
+	file(GLOB_RECURSE SOURCES_CLIENT_SND "./new/*.c*")
+	list(APPEND SOURCES_CLIENT ${SOURCES_CLIENT_SND})
+endif()
+
+set(OLD_VALUE ${BUILD_SHARED_LIBS})
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+
+if(USE_INTERNAL_MAD)
+	add_subdirectory("../libmad" "./libmad" EXCLUDE_FROM_ALL)
+	target_link_libraries(omohclient INTERFACE mad)
+else()
+	include(FindPackageHandleStandardArgs)
+	find_path(LIBMAD_INCLUDE_DIRS mad.h)
+	find_library(LIBMAD_LIBRARIES mad)
+	find_package_handle_standard_args(
+		LibMad
+		DEFAULT_MSG
+		LIBMAD_LIBRARIES
+		LIBMAD_INCLUDE_DIRS
+	)
+	target_include_directories(omohclient INTERFACE ${LIBMAD_INCLUDE_DIRS})
+	target_link_libraries(omohclient INTERFACE ${LIBMAD_LIBRARIES})
+endif()
+
+set(BUILD_SHARED_LIBS ${OLD_VALUE} CACHE BOOL "" FORCE)
+
+target_sources(omohclient INTERFACE ${SOURCES_CLIENT} ${SOURCES_UILIB})

code/client/cl_avi.cpp

@@ -334,6 +334,9 @@ writing the actual data can begin
 */
 qboolean CL_OpenAVIForWriting( const char *fileName )
 {
+    return qfalse;
+    // Removed in OPM
+#if 0
   if( afd.fileOpen )
     return qfalse;
 
@@ -425,6 +428,7 @@ qboolean CL_OpenAVIForWriting( const char *fileName )
   afd.fileOpen = qtrue;
 
   return qtrue;
+#endif
 }
 
 /*

code/client/cl_cgame.cpp

@@ -211,20 +211,20 @@ qboolean	CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
 	}
 
 	snapshot->numEntities = 0;
-	for ( i = 0 ; i < count ; i++ ) {
+	for(i = 0; i < MAX_ENTITIES_IN_SNAPSHOT; i++) {
+		parents[i] = -1;
+	}
+
+	for (i = 0; i < count; i++) {
 		s1 = &cl.parseEntities[(clSnap->parseEntitiesNum + i) & (MAX_PARSE_ENTITIES - 1)];
 		pnum = s1->parent;
 
 		if (pnum == ENTITYNUM_NONE) {
 			parents[s1->number] = -2;
-		}
-		else
-		{
+		} else {
 			if (parents[pnum] == -2) {
 				parents[s1->number] = -2;
-			}
-			else
-			{
+			} else {
 				// add it later
 				parents[s1->number] = pnum;
 				continue;
@@ -234,33 +234,37 @@ qboolean	CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
 		snapshot->entities[snapshot->numEntities++] = *s1;
 	}
 
-	for(pcount = 0; pcount < 8 && snapshot->numEntities != count; pcount++)
-	{
-		for (i = 0; i < count; i++)
-		{
+	for(pcount = 0; pcount < 8 && snapshot->numEntities != count; pcount++) {
+		for (i = 0; i < count; i++) {
 			s1 = &cl.parseEntities[(clSnap->parseEntitiesNum + i) & (MAX_PARSE_ENTITIES - 1)];
 			pnum = parents[s1->number];
 			if (pnum >= 0 && parents[pnum] == -2) {
+				parents[s1->number] = -2;
 				snapshot->entities[snapshot->numEntities++] = *s1;
 			}
 		}
 	}
 
-	if (pcount >= 8)
-	{
-		for (i = count; i < snapshot->numEntities; i++)
+	if (snapshot->numEntities != count) {
+		Com_DPrintf("CL_GetSnapshot: Not all children could find their parents.\n");
+
+		for (i = snapshot->numEntities; i < count; i++)
 		{
-			s1 = &cl.parseEntities[(clSnap->parseEntitiesNum + i) & (MAX_PARSE_ENTITIES - 1)];
-			if (parents[s1->number] >= 0) {
-				Com_DPrintf(
-					"CL_GetSnapshot: entity %d with parent %d and model '%s' at %.2f %.2f %.2f, could not find parent.\n",
-					s1->number,
-					s1->parent,
-					CL_ConfigString(CS_MODELS + s1->modelindex),
-					s1->origin[0],
-					s1->origin[1],
-					s1->origin[2]
-				);
+			for (pnum = 0; pnum < count; pnum++) {
+				s1 = &cl.parseEntities[(clSnap->parseEntitiesNum + pnum) & (MAX_PARSE_ENTITIES - 1)];
+				if (parents[s1->number] >= 0) {
+					Com_DPrintf(
+						"CL_GetSnapshot: entity %d with parent %d and model '%s' at %.2f %.2f %.2f, could not find parent.\n",
+						s1->number,
+						s1->parent,
+						CL_ConfigString(CS_MODELS + s1->modelindex),
+						s1->origin[0],
+						s1->origin[1],
+						s1->origin[2]
+					);
+
+					parents[s1->number] = -2;
+				}
 			}
 		}
 	}
@@ -358,7 +362,9 @@ qboolean CL_ProcessServerCommand(const char* origString, const char* cmd, qboole
 		// because this function might be called from a module that would be unloaded
 		// inside Com_Error
         UI_ForceMenuOff(1);
-        Cbuf_AddText("disconnect;pushmenu disconnected");
+		// Fixed in OPM
+		//  Added a newline for next commands
+        Cbuf_AddText("disconnect;pushmenu disconnected\n");
         return qtrue;
     }
 
@@ -395,8 +401,8 @@ Set up argc/argv for the given command
 ===================
 */
 qboolean CL_GetServerCommand( int serverCommandNumber, qboolean differentServer ) {
-	char	*s;
-	char	*cmd;
+	char		*s;
+	char		*cmd;
 	static char bigConfigString[BIG_INFO_STRING];
 
 	// if we have irretrievably lost a reliable command, drop the connection
@@ -421,9 +427,39 @@ qboolean CL_GetServerCommand( int serverCommandNumber, qboolean differentServer
 		Com_DPrintf( "serverCommand: %i : %s\n", serverCommandNumber, s );
 	}
 
-	Cmd_TokenizeString( s );
+	Cmd_TokenizeString(s);
 	cmd = Cmd_Argv(0);
 
+	// Readded in OPM (from ioquake)
+	// Configstring big buffer
+	if (!strcmp(cmd, "bcs0")) {
+		Com_sprintf(bigConfigString, BIG_INFO_STRING, "cs %s \"%s", Cmd_Argv(1), Cmd_Argv(2));
+		return qfalse;
+	}
+
+	if (!strcmp(cmd, "bcs1")) {
+		s = Cmd_Argv(2);
+		if (strlen(bigConfigString) + strlen(s) >= BIG_INFO_STRING) {
+			Com_Error(ERR_DROP, "bcs exceeded BIG_INFO_STRING");
+		}
+		strcat(bigConfigString, s);
+		return qfalse;
+	}
+
+	if (!strcmp(cmd, "bcs2")) {
+		s = Cmd_Argv(2);
+		if (strlen(bigConfigString) + strlen(s) + 1 >= BIG_INFO_STRING) {
+			Com_Error(ERR_DROP, "bcs exceeded BIG_INFO_STRING");
+		}
+		strcat(bigConfigString, s);
+		strcat(bigConfigString, "\"");
+		s = bigConfigString;
+
+		// reparse
+		Cmd_TokenizeString(s);
+		cmd = Cmd_Argv(0);
+	}
+
 	return CL_ProcessServerCommand(s, cmd, differentServer);
 }
 
@@ -548,7 +584,7 @@ CL_RestoreSavedCgameState
 */
 void CL_RestoreSavedCgameState() {
 	if (cls.savedCgameState) {
-		cge->CG_LoadStateToBuffer(&cls.savedCgameState, cls.savedCgameStateSize, cl.snap.serverTime);
+		cge->CG_LoadStateToBuffer(cls.savedCgameState, cls.savedCgameStateSize, cl.snap.serverTime);
 	}
 }
 
@@ -591,6 +627,7 @@ void CL_InitCGameDLL( clientGameImport_t *cgi, clientGameExport_t **cge ) {
 	cgi->LV_ConvertString				= Sys_LV_CL_ConvertString;
 
 	cgi->Cvar_Get						= Cvar_Get;
+	cgi->Cvar_Find						= Cvar_FindVar;
 	cgi->Cvar_Set						= Cvar_Set;
 
 	cgi->Argc							= Cmd_Argc;
@@ -735,7 +772,8 @@ void CL_InitCGameDLL( clientGameImport_t *cgi, clientGameExport_t **cge ) {
 
 	cgi->UI_ShowMenu				= UI_ShowMenu;
 	cgi->UI_HideMenu				= UI_HideMenu;
-	cgi->UI_FontStringWidth			= uie.FontStringWidth;
+	cgi->UI_FontStringWidth			= CL_FontStringWidth;
+	cgi->UI_GetObjectivesTop		= UI_GetObjectivesTop;
 	cgi->Key_StringToKeynum			= Key_StringToKeynum;
 	cgi->Key_KeynumToBindString		= Key_KeynumToBindString;
 	cgi->Key_GetKeysForCommand		= Key_GetKeysForCommand;
@@ -783,6 +821,8 @@ void CL_InitCGameDLL( clientGameImport_t *cgi, clientGameExport_t **cge ) {
 	cgi->CL_RestoreSavedCgameState	= CL_RestoreSavedCgameState;
 	cgi->CL_ClearSavedCgameState	= CL_ClearSavedCgameState;
 
+	cgi->getConfigStringIdNormalized = CPT_NormalizeConfigstring;
+
 	cgi->fsDebug					= fs_debug;
 	cgi->HudDrawElements			= cls.HudDrawElements;
 	cgi->anim						= &cls.anim;
@@ -1075,6 +1115,42 @@ void CL_FirstSnapshot( void ) {
 		Cbuf_AddText( cl_activeAction->string );
 		Cvar_Set( "activeAction", "" );
 	}
+
+#ifdef USE_MUMBLE
+	if ((cl_useMumble->integer) && !mumble_islinked()) {
+		int ret = mumble_link(CLIENT_WINDOW_TITLE);
+		Com_Printf("Mumble: Linking to Mumble application %s\n", ret==0?"ok":"failed");
+	}
+#endif
+
+#ifdef USE_VOIP
+	if (!clc.voipCodecInitialized) {
+		int i;
+		int error;
+
+		clc.opusEncoder = opus_encoder_create(48000, 1, OPUS_APPLICATION_VOIP, &error);
+
+		if ( error ) {
+			Com_DPrintf("VoIP: Error opus_encoder_create %d\n", error);
+			return;
+		}
+
+		for (i = 0; i < MAX_CLIENTS; i++) {
+			clc.opusDecoder[i] = opus_decoder_create(48000, 1, &error);
+			if ( error ) {
+				Com_DPrintf("VoIP: Error opus_decoder_create(%d) %d\n", i, error);
+				return;
+			}
+			clc.voipIgnore[i] = qfalse;
+			clc.voipGain[i] = 1.0f;
+		}
+		clc.voipCodecInitialized = qtrue;
+		clc.voipMuteAll = qfalse;
+		Cmd_AddCommand ("voip", CL_Voip_f);
+		Cvar_Set("cl_voipSendTarget", "spatial");
+		Com_Memset(clc.voipTargets, ~0, sizeof(clc.voipTargets));
+	}
+#endif
 }
 
 static int lastSnapFlags;
@@ -1125,7 +1201,12 @@ void CL_SetCGameTime( void ) {
 	// allow pause in single player
 	if ( paused->integer && com_sv_running->integer ) {
 		// paused
-		CL_AdjustTimeDelta();
+		//CL_AdjustTimeDelta();
+		// Fixed in OPM
+		//  Keep in sync with the server time.
+		//  In OG, the game could lag for a short time
+		//  when pausing and unpausing frequently
+		cl.serverTimeDelta = cl.snap.serverTime - cls.realtime;
 		return;
 	}
 

code/client/cl_cin.cpp

@@ -35,6 +35,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "../uilib/ui_public.h"
 #include "snd_local.h"
 
+#include "cl_ui.h"
+
 #define MAXSIZE				8
 #define MINSIZE				4
 
@@ -55,6 +57,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 
 static void RoQ_init( void );
+static void CL_FinishedCinematic();
 
 /******************************************************************************
 *
@@ -126,6 +129,10 @@ typedef struct {
 	int					playonwalls;
 	byte*				buf;
 	long				drawX, drawY;
+
+	long realTime;
+	long currTime;
+	long soundTime;
 } cin_cache;
 
 static cinematics_t		cin;
@@ -133,6 +140,10 @@ static cin_cache		cinTable[MAX_VIDEO_HANDLES];
 static int				currentHandle = -1;
 static int				CL_handle = -1;
 
+static connstate_t		oldClientState;
+
+static int				audioStartTime = 0;
+
 extern "C" int				s_soundtime;		// sample PAIRS
 
 
@@ -160,7 +171,7 @@ static int CIN_HandleForVideo(void) {
 }
 
 
-extern "C" int CL_ScaledMilliseconds(void);
+extern "C" int Com_Milliseconds(void);
 
 //-----------------------------------------------------------------------------
 // RllSetupTable
@@ -1142,24 +1153,20 @@ redump:
 		case	ZA_SOUND_MONO:
 			if (!cinTable[currentHandle].silent) {
 				ssize = RllDecodeMonoToStereo( framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags);
-                                S_RawSamples(0, ssize, 22050, 2, 1, (byte *)sbuf, 1.0f, -1);
+                //                S_RawSamples(0, ssize, 22050, 2, 1, (byte *)sbuf, 1.0f, -1);
 			}
 			break;
 		case	ZA_SOUND_STEREO:
 			if (!cinTable[currentHandle].silent) {
-				if (cinTable[currentHandle].numQuads == -1) {
-					S_Update();
-					s_rawend[0] = s_soundtime;
-				}
 				ssize = RllDecodeStereoToStereo( framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags);
-                                S_RawSamples(0, ssize, 22050, 2, 2, (byte *)sbuf, 1.0f, -1);
+                //                S_RawSamples(0, ssize, 22050, 2, 2, (byte *)sbuf, 1.0f, -1);
 			}
 			break;
 		case	ROQ_QUAD_INFO:
 			if (cinTable[currentHandle].numQuads == -1) {
 				readQuadInfo( framedata );
 				setupQuad( 0, 0 );
-				cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds();
+				cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Com_Milliseconds();
 			}
 			if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
 			break;
@@ -1226,7 +1233,10 @@ redump:
 
 static void RoQ_init( void )
 {
-	cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds();
+	cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Com_Milliseconds();
+	cinTable[currentHandle].realTime = Com_Milliseconds();
+	cinTable[currentHandle].currTime = 0;
+	cinTable[currentHandle].soundTime = 0;
 
 	cinTable[currentHandle].RoQPlayed = 24;
 
@@ -1273,8 +1283,10 @@ static void RoQShutdown( void ) {
 		cinTable[currentHandle].iFile = 0;
 	}
 
+	S_StopMovieAudio();
+
 	if (cinTable[currentHandle].alterGameState) {
-		clc.state = CA_DISCONNECTED;
+		clc.state = oldClientState;
 		// we can't just do a vstr nextmap, because
 		// if we are aborting the intro cinematic with
 		// a devmap command, nextmap would be valid by
@@ -1286,8 +1298,29 @@ static void RoQShutdown( void ) {
 		}
 		CL_handle = -1;
 	}
+
 	cinTable[currentHandle].fileName[0] = 0;
 	currentHandle = -1;
+
+	CL_FinishedCinematic();
+}
+
+static void CL_FinishedCinematic()
+{
+	const  char* s;
+
+	if (!CL_FinishedIntro())
+	{
+		CL_FinishedStartStage();
+		return;
+	}
+
+    s = Cvar_VariableString("nextmap");
+    if (*s)
+    {
+        Cbuf_ExecuteText(EXEC_APPEND, va("%s\n", s));
+        Cvar_Set("nextmap", "");
+    }
 }
 
 /*
@@ -1328,8 +1361,11 @@ Fetch and decompress the pending frame
 
 e_status CIN_RunCinematic (int handle)
 {
-	int	start = 0;
-	int     thisTime = 0;
+	int deltaTime;
+	int frameTime;
+	int soundTime;
+	int newTime;
+	long tfps;
 
 	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
 
@@ -1357,24 +1393,46 @@ e_status CIN_RunCinematic (int handle)
 		return cinTable[currentHandle].status;
 	}
 
-	thisTime = CL_ScaledMilliseconds();
-	if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) {
-		cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
+	frameTime = Com_Milliseconds();
+	deltaTime = frameTime - cinTable[currentHandle].realTime;
+	if (deltaTime > 100) {
+		deltaTime = 100;
 	}
-	cinTable[currentHandle].tfps = (((CL_ScaledMilliseconds() - cinTable[currentHandle].startTime)*3)/100);
 
-	start = cinTable[currentHandle].startTime;
-	while(  (cinTable[currentHandle].tfps != cinTable[currentHandle].numQuads)
+	newTime = cinTable[currentHandle].currTime + deltaTime;
+	if (cl_movieaudio->integer) {
+		soundTime = S_CurrentMoviePosition();
+		if (soundTime > cinTable[currentHandle].currTime || soundTime > cinTable[currentHandle].soundTime) {
+			cinTable[currentHandle].currTime = newTime + (deltaTime * (soundTime - newTime)) / 100;
+		}
+		else {
+			cinTable[currentHandle].currTime = newTime;
+		}
+
+        cinTable[currentHandle].soundTime = soundTime;
+	} else {
+		//
+		// Fixed in OPM
+		//
+		cinTable[currentHandle].currTime = newTime;
+	}
+
+	cinTable[currentHandle].realTime = frameTime;
+
+	tfps = (cinTable[currentHandle].currTime * 3) / 100;
+
+	while(  (tfps != cinTable[currentHandle].numQuads)
 		&& (cinTable[currentHandle].status == FMV_PLAY) ) 
 	{
 		RoQInterrupt();
-		if (start != cinTable[currentHandle].startTime) {
-			cinTable[currentHandle].tfps = (((CL_ScaledMilliseconds() - cinTable[currentHandle].startTime)*3)/100);
-			start = cinTable[currentHandle].startTime;
+
+		cinTable[currentHandle].realTime = Com_Milliseconds();
+		if (cinTable[currentHandle].realTime > frameTime + 66) {
+			break;
 		}
 	}
 
-	cinTable[currentHandle].lastTime = thisTime;
+	cinTable[currentHandle].lastTime = frameTime;
 
 	if (cinTable[currentHandle].status == FMV_LOOPED) {
 		cinTable[currentHandle].status = FMV_PLAY;
@@ -1422,7 +1480,7 @@ int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBi
 
 	cin.currentHandle = currentHandle;
 
-	strcpy(cinTable[currentHandle].fileName, name);
+	Q_strncpyz(cinTable[currentHandle].fileName, name, sizeof(cinTable[currentHandle].fileName));
 
 	cinTable[currentHandle].ROQSize = 0;
 	cinTable[currentHandle].ROQSize = FS_FOpenFileRead (cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, qtrue, qtrue);
@@ -1468,10 +1526,6 @@ int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBi
 			clc.state = CA_CINEMATIC;
 		}
 
-		if (!cinTable[currentHandle].silent) {
-			s_rawend[0] = s_soundtime;
-		}
-
 		return currentHandle;
 	}
 	Com_DPrintf("trFMV::play(), invalid RoQ ID\n");
@@ -1593,33 +1647,96 @@ void CIN_DrawCinematic (int handle) {
 	cinTable[handle].dirty = qfalse;
 }
 
+static unsigned short CL_PlayRoQ(const char* name, const char* arg, const char* s) {
+	unsigned short RoQID;
+
+	Com_Memset(&cin, 0, sizeof(cinematics_t) );
+	currentHandle = CIN_HandleForVideo();
+
+	cin.currentHandle = currentHandle;
+
+	Q_strncpyz(cinTable[currentHandle].fileName, name, sizeof(cinTable[currentHandle].fileName));
+
+	cinTable[currentHandle].ROQSize = 0;
+	cinTable[currentHandle].ROQSize = FS_FOpenFileRead (cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, qtrue, qtrue);
+
+	if (cinTable[currentHandle].ROQSize<=0) {
+		Com_DPrintf("Can not find RoQ cinematic '%s'\n", name);
+		CL_FinishedCinematic();
+		return -1;
+	}
+
+	if ((s && s[0] == '1') || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) {
+		cinTable[currentHandle].holdAtEnd = qtrue;
+    }
+
+    CIN_SetExtents(currentHandle, 0, 0, 640, 480);
+    cinTable[currentHandle].alterGameState = qtrue;
+
+    initRoQ();
+
+	FS_Read (cin.file, 16, cinTable[currentHandle].iFile);
+
+	RoQID = (unsigned short)(cin.file[0]) + (unsigned short)(cin.file[1])*256;
+	if (RoQID == 0x1084)
+	{
+		RoQ_init();
+//		FS_Read (cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile);
+
+		cinTable[currentHandle].status = FMV_PLAY;
+        Com_DPrintf("trFMV::play(), playing %s\n", arg);
+
+        if (cl_movieaudio->integer) {
+			audioStartTime = Com_Milliseconds();
+            S_SetupMovieAudio(name);
+        }
+
+		oldClientState = clc.state;
+        clc.state = CA_CINEMATIC;
+
+		if (cls.glconfig.maxTextureSize <= 256 || s && *s == '2') {
+			//cinTable[currentHandle].interlaced = qtrue;
+		}
+
+		CL_handle = currentHandle;
+
+		do {
+			SCR_RunCinematic();
+		} while (!cinTable[currentHandle].buf && cinTable[currentHandle].status == FMV_PLAY);
+
+		UI_CloseConsole();
+
+		return currentHandle;
+	}
+	Com_DPrintf("trFMV::play(), invalid RoQ ID\n");
+
+	RoQShutdown();
+	return -1;
+}
+
 void CL_PlayCinematic_f(void) {
 	char	*arg, *s;
-	int bits = CIN_system;
+	char	name[256];
 
-	Com_DPrintf("CL_PlayCinematic_f\n");
 	if (clc.state == CA_CINEMATIC) {
 		SCR_StopCinematic();
 	}
 
 	arg = Cmd_Argv( 1 );
+	Com_DPrintf("CL_PlayCinematic( %s )\n", arg);
 	s = Cmd_Argv(2);
 
-	if ((s && s[0] == '1') || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) {
-		bits |= CIN_hold;
-	}
-	if (s && s[0] == '2') {
-		bits |= CIN_loop;
+	CL_StartHunkUsers(qfalse);
+    S_StopAllSounds2(qtrue);
+
+	Com_sprintf(name, sizeof(name), "video/%s", arg);
+
+	if (Q_stricmp(&name[strlen(name) - 4], ".roq")) {
+		Com_Printf("Bad or missing cinematic extension.\n");
+		return;
 	}
 
-	S_StopAllSounds2( qtrue );
-
-	CL_handle = CIN_PlayCinematic( arg, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, bits );
-	if (CL_handle >= 0) {
-		do {
-			SCR_RunCinematic();
-		} while (cinTable[currentHandle].buf == NULL && cinTable[currentHandle].status == FMV_PLAY);		// wait for first frame (load codebook and sound)
-	}
+    CL_PlayRoQ(name, arg, s);
 }
 
 
@@ -1639,7 +1756,5 @@ void SCR_RunCinematic (void)
 void SCR_StopCinematic(void) {
 	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
 		CIN_StopCinematic(CL_handle);
-		S_StopAllSounds2( qtrue );
-		CL_handle = -1;
 	}
 }

code/client/cl_input.cpp

@@ -56,6 +56,10 @@ qboolean	in_guimouse;
 
 kbutton_t	in_up, in_down;
 
+#ifdef USE_VOIP
+kbutton_t	in_voiprecord;
+#endif
+
 kbutton_t	in_buttons[16];
 
 qboolean	in_mlooking;
@@ -258,6 +262,20 @@ void IN_SpeedUp(void) {IN_KeyUp(&in_speed);}
 void IN_StrafeDown(void) {IN_KeyDown(&in_strafe);}
 void IN_StrafeUp(void) {IN_KeyUp(&in_strafe);}
 
+#ifdef USE_VOIP
+void IN_VoipRecordDown(void)
+{
+	IN_KeyDown(&in_voiprecord);
+	Cvar_Set("cl_voipSend", "1");
+}
+
+void IN_VoipRecordUp(void)
+{
+	IN_KeyUp(&in_voiprecord);
+	Cvar_Set("cl_voipSend", "0");
+}
+#endif
+
 void IN_Button0Down(void) {IN_KeyDown(&in_buttons[0]);}
 void IN_Button0Up(void) {IN_KeyUp(&in_buttons[0]);}
 void IN_Button1Down(void) {IN_KeyDown(&in_buttons[1]);}
@@ -432,7 +450,7 @@ void CL_MouseEvent( int dx, int dy, int time ) {
 		if( cl.mousey > cls.glconfig.vidHeight )
 			cl.mousey = cls.glconfig.vidHeight;
 	}
-	else
+	else if ( !paused->integer )
 	{
 		cl.mouseDx[cl.mouseIndex] += dx;
 		cl.mouseDy[cl.mouseIndex] += dy;
@@ -461,6 +479,16 @@ CL_JoystickMove
 void CL_JoystickMove( usercmd_t *cmd ) {
 	float	anglespeed;
 
+	float yaw     = j_yaw->value     * cl.joystickAxis[j_yaw_axis->integer];
+	float right   = j_side->value    * cl.joystickAxis[j_side_axis->integer];
+	float forward = j_forward->value * cl.joystickAxis[j_forward_axis->integer];
+	float pitch   = j_pitch->value   * cl.joystickAxis[j_pitch_axis->integer];
+	float up      = j_up->value      * cl.joystickAxis[j_up_axis->integer];
+
+	if ( in_speed.active ^ cl_run->integer ) {
+		cmd->buttons |= BUTTON_RUN;
+	}
+
 	if ( in_speed.active ) {
 		anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
 	} else {
@@ -468,18 +496,22 @@ void CL_JoystickMove( usercmd_t *cmd ) {
 	}
 
 	if ( !in_strafe.active ) {
-		cl.viewangles[YAW] += anglespeed * cl_yawspeed->value * cl.joystickAxis[AXIS_SIDE];
+		cl.viewangles[YAW] += anglespeed * yaw;
+		cmd->rightmove = ClampChar( cmd->rightmove + (int)right );
 	} else {
-		cmd->rightmove = ClampChar( cmd->rightmove + cl.joystickAxis[AXIS_SIDE] );
+		cl.viewangles[YAW] += anglespeed * right;
+		cmd->rightmove = ClampChar( cmd->rightmove + (int)yaw );
 	}
 
 	if ( in_mlooking ) {
-		cl.viewangles[PITCH] += anglespeed * cl_pitchspeed->value * cl.joystickAxis[AXIS_FORWARD];
+		cl.viewangles[PITCH] += anglespeed * forward;
+		cmd->forwardmove = ClampChar( cmd->forwardmove + (int)pitch );
 	} else {
-		cmd->forwardmove = ClampChar( cmd->forwardmove + cl.joystickAxis[AXIS_FORWARD] );
+		cl.viewangles[PITCH] += anglespeed * pitch;
+		cmd->forwardmove = ClampChar( cmd->forwardmove + (int)forward );
 	}
 
-	cmd->upmove = ClampChar( cmd->upmove + cl.joystickAxis[AXIS_UP] );
+	cmd->upmove = ClampChar( cmd->upmove + (int)up );
 }
 
 /*
@@ -565,6 +597,8 @@ void CL_MouseMove( usercmd_t *cmd ) {
 	mx *= cgameSensitivity;
 	my *= cgameSensitivity;
 
+	cmd->buttons |= BUTTON_ANY;
+
 	// add mouse X/Y movement to cmd
 	if(in_strafe.active)
 		cmd->rightmove = ClampChar(cmd->rightmove + m_side->value * mx);
@@ -575,6 +609,14 @@ void CL_MouseMove( usercmd_t *cmd ) {
 		cl.viewangles[PITCH] += m_pitch->value * my;
 	else
 		cmd->forwardmove = ClampChar(cmd->forwardmove - m_forward->value * my);
+
+	if (!isfinite(cl.viewangles[PITCH]) || !isfinite(cl.viewangles[YAW])) {
+		Com_DPrintf("Invalid client viewangles encountered (view pitch: %f, view yaw: %f)!\n", cl.viewangles[PITCH], cl.viewangles[YAW]);
+		Com_DPrintf("cgameSensitivity: %f | mx: %f | my: %f | m_pitch: %f | m_yaw: %f\n", cgameSensitivity, mx, my, m_pitch->value, m_yaw->value);
+		Com_DPrintf("Resetting client viewangles\n");
+		cl.viewangles[PITCH] = 0;
+		cl.viewangles[YAW] = 0;
+	}
 }
 
 /*
@@ -609,8 +651,8 @@ void CL_CmdButtons( usercmd_t *cmd ) {
 	if (UI_MenuActive() || UI_ConsoleIsOpen()) {
 		cmd->buttons |= BUTTON_TALK;
 	}
-
-	if (in_speed.active == !cl_run->integer) {
+	
+	if ( in_speed.active ^ cl_run->integer ) {
 		cmd->buttons |= BUTTON_RUN;
 	}
 
@@ -718,6 +760,12 @@ void CL_CreateNewCommands( void ) {
 
 	frame_msec = com_frameTime - old_com_frameTime;
 
+	// if running over 1000fps, act as if each frame is 1ms
+	// prevents divisions by zero
+	if ( frame_msec < 1 ) {
+		frame_msec = 1;
+	}
+
 	// if running less than 5fps, truncate the extra time to prevent
 	// unexpected moves after a hitch
 	if ( frame_msec > 200 ) {
@@ -909,6 +957,58 @@ void CL_WritePacket( void ) {
 		count = MAX_PACKET_USERCMDS;
 		Com_Printf("MAX_PACKET_USERCMDS\n");
 	}
+
+#ifdef USE_VOIP
+	if (clc.voipOutgoingDataSize > 0)
+	{
+		if((clc.voipFlags & VOIP_SPATIAL) || Com_IsVoipTarget(clc.voipTargets, sizeof(clc.voipTargets), -1))
+		{
+			MSG_WriteByte (&buf, clc_voipOpus);
+			MSG_WriteByte (&buf, clc.voipOutgoingGeneration);
+			MSG_WriteLong (&buf, clc.voipOutgoingSequence);
+			MSG_WriteByte (&buf, clc.voipOutgoingDataFrames);
+			MSG_WriteData (&buf, clc.voipTargets, sizeof(clc.voipTargets));
+			MSG_WriteByte(&buf, clc.voipFlags);
+			MSG_WriteShort (&buf, clc.voipOutgoingDataSize);
+			MSG_WriteData (&buf, clc.voipOutgoingData, clc.voipOutgoingDataSize);
+
+			// If we're recording a demo, we have to fake a server packet with
+			//  this VoIP data so it gets to disk; the server doesn't send it
+			//  back to us, and we might as well eliminate concerns about dropped
+			//  and misordered packets here.
+			if(clc.demorecording && !clc.demowaiting)
+			{
+				const int voipSize = clc.voipOutgoingDataSize;
+				msg_t fakemsg;
+				byte fakedata[MAX_MSGLEN];
+				MSG_Init (&fakemsg, fakedata, sizeof (fakedata));
+				MSG_Bitstream (&fakemsg);
+				MSG_WriteLong (&fakemsg, clc.reliableAcknowledge);
+				MSG_WriteByte (&fakemsg, svc_voipOpus);
+				MSG_WriteShort (&fakemsg, clc.clientNum);
+				MSG_WriteByte (&fakemsg, clc.voipOutgoingGeneration);
+				MSG_WriteLong (&fakemsg, clc.voipOutgoingSequence);
+				MSG_WriteByte (&fakemsg, clc.voipOutgoingDataFrames);
+				MSG_WriteShort (&fakemsg, clc.voipOutgoingDataSize );
+				MSG_WriteBits (&fakemsg, clc.voipFlags, VOIP_FLAGCNT);
+				MSG_WriteData (&fakemsg, clc.voipOutgoingData, voipSize);
+				MSG_WriteByte (&fakemsg, svc_EOF);
+				CL_WriteDemoMessage (&fakemsg, 0);
+			}
+
+			clc.voipOutgoingSequence += clc.voipOutgoingDataFrames;
+			clc.voipOutgoingDataSize = 0;
+			clc.voipOutgoingDataFrames = 0;
+		}
+		else
+		{
+			// We have data, but no targets. Silently discard all data
+			clc.voipOutgoingDataSize = 0;
+			clc.voipOutgoingDataFrames = 0;
+		}
+	}
+#endif
+
 	if ( count >= 1 ) {
 		if ( cl_showSend->integer ) {
 			Com_Printf( "(%i)", count );
@@ -965,16 +1065,6 @@ void CL_WritePacket( void ) {
 	}
 
 	CL_Netchan_Transmit (&clc.netchan, &buf);
-
-	// clients never really should have messages large enough
-	// to fragment, but in case they do, fire them all off
-	// at once
-	// TTimo: this causes a packet burst, which is bad karma for winsock
-	// added a WARNING message, we'll see if there are legit situations where this happens
-	while ( clc.netchan.unsentFragments ) {
-		Com_DPrintf( "WARNING: #462 unsent fragments (not supposed to happen!)\n" );
-		CL_Netchan_TransmitNextFragment( &clc.netchan );
-	}
 }
 
 /*
@@ -991,7 +1081,7 @@ void CL_SendCmd( void ) {
 	}
 
 	// don't send commands if paused
-	if ( com_sv_running->integer && paused->integer && paused->integer ) {
+	if ( com_sv_running->integer && paused->integer  ) {
 		return;
 	}
 
@@ -1086,6 +1176,85 @@ void CL_InitInput( void ) {
 	Cmd_AddCommand("+mlook", IN_MLookDown);
 	Cmd_AddCommand("-mlook", IN_MLookUp);
 
+#ifdef USE_VOIP
+	Cmd_AddCommand ("+voiprecord", IN_VoipRecordDown);
+	Cmd_AddCommand ("-voiprecord", IN_VoipRecordUp);
+#endif
+
 	cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0);
 	cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0);
 }
+
+/*
+============
+CL_ShutdownInput
+============
+*/
+void CL_ShutdownInput(void)
+{
+	Cmd_RemoveCommand("centerview");
+
+	Cmd_RemoveCommand("+moveup");
+	Cmd_RemoveCommand("-moveup");
+	Cmd_RemoveCommand("+movedown");
+	Cmd_RemoveCommand("-movedown");
+	Cmd_RemoveCommand("+left");
+	Cmd_RemoveCommand("-left");
+	Cmd_RemoveCommand("+right");
+	Cmd_RemoveCommand("-right");
+	Cmd_RemoveCommand("+forward");
+	Cmd_RemoveCommand("-forward");
+	Cmd_RemoveCommand("+back");
+	Cmd_RemoveCommand("-back");
+	Cmd_RemoveCommand("+lookup");
+	Cmd_RemoveCommand("-lookup");
+	Cmd_RemoveCommand("+lookdown");
+	Cmd_RemoveCommand("-lookdown");
+	Cmd_RemoveCommand("+strafe");
+	Cmd_RemoveCommand("-strafe");
+	Cmd_RemoveCommand("+moveleft");
+	Cmd_RemoveCommand("-moveleft");
+	Cmd_RemoveCommand("+moveright");
+	Cmd_RemoveCommand("-moveright");
+	Cmd_RemoveCommand("+speed");
+	Cmd_RemoveCommand("-speed");
+	Cmd_RemoveCommand("+attack");
+	Cmd_RemoveCommand("-attack");
+	Cmd_RemoveCommand("+button0");
+	Cmd_RemoveCommand("-button0");
+	Cmd_RemoveCommand("+button1");
+	Cmd_RemoveCommand("-button1");
+	Cmd_RemoveCommand("+button2");
+	Cmd_RemoveCommand("-button2");
+	Cmd_RemoveCommand("+button3");
+	Cmd_RemoveCommand("-button3");
+	Cmd_RemoveCommand("+button4");
+	Cmd_RemoveCommand("-button4");
+	Cmd_RemoveCommand("+button5");
+	Cmd_RemoveCommand("-button5");
+	Cmd_RemoveCommand("+button6");
+	Cmd_RemoveCommand("-button6");
+	Cmd_RemoveCommand("+button7");
+	Cmd_RemoveCommand("-button7");
+	Cmd_RemoveCommand("+button8");
+	Cmd_RemoveCommand("-button8");
+	Cmd_RemoveCommand("+button9");
+	Cmd_RemoveCommand("-button9");
+	Cmd_RemoveCommand("+button10");
+	Cmd_RemoveCommand("-button10");
+	Cmd_RemoveCommand("+button11");
+	Cmd_RemoveCommand("-button11");
+	Cmd_RemoveCommand("+button12");
+	Cmd_RemoveCommand("-button12");
+	Cmd_RemoveCommand("+button13");
+	Cmd_RemoveCommand("-button13");
+	Cmd_RemoveCommand("+button14");
+	Cmd_RemoveCommand("-button14");
+	Cmd_RemoveCommand("+mlook");
+	Cmd_RemoveCommand("-mlook");
+
+#ifdef USE_VOIP
+	Cmd_RemoveCommand("+voiprecord");
+	Cmd_RemoveCommand("-voiprecord");
+#endif
+}

code/client/cl_inv.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,175 +20,198 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_INV_H__
-#define __CL_INV_H__
+#pragma once
 
-typedef enum { INV_MOVE_NONE, INV_MOVE_BOB, INV_MOVE_SPIN } inv_move_type;
-typedef enum { INV_CASCADE_LEFT, INV_CASCADE_RIGHT } inv_cascade_type;
-typedef enum { INV_HUDANGLES_BASE, INV_HUDANGLES_COMPASS, INV_HUDANGLES_COMPASS_NEEDLE } inv_hudangles_type;
+typedef enum {
+    INV_MOVE_NONE,
+    INV_MOVE_BOB,
+    INV_MOVE_SPIN
+} inv_move_type;
 
-class item_properties_t : public Class {
-public:
-	float scale;
-	Vector angles;
-	Vector angledeltas;
-	Vector rotateoffset;
-	Vector offset;
-	inv_move_type move;
-	str model;
-	str anim;
-};
+typedef enum {
+    INV_ALIGN_NONE,
+    INV_ALIGN_LEFT,
+    INV_ALIGN_RIGHT
+} inv_align_type;
 
-class inventory_item_t : public Class {
-public:
-	str name;
-	str ammoname;
-	int equip;
-	int width;
-	int height;
-	int barwidth;
-	int barheight;
-	int baroffsetY;
-	int baroffsetX;
-	float modelWindowX;
-	float modelWindowY;
-	float modelWindowWidth;
-	float modelWindowHeight;
-	bool selShaderOnTop;
-	bool checkammo;
-	str command;
-	inv_hudangles_type anglesType;
-	item_properties_t hudprops;
-	item_properties_t invprops;
-	UIReggedMaterial *bgshader;
-	UIReggedMaterial *barshader;
-	UIReggedMaterial *selshader;
-};
+typedef enum {
+    INV_CASCADE_LEFT,
+    INV_CASCADE_RIGHT
+} inv_cascade_type;
 
-class inventory_type_t {
-public:
-	str name;
-	bool bg_tile;
-	UIReggedMaterial *texture;
-	UIReggedMaterial *bg;
-	UIReggedMaterial *hoverTexture;
-	UIReggedMaterial *selTexture;
-	Container<inventory_item_t *> items;
+typedef enum {
+    INV_HUDANGLES_BASE,
+    INV_HUDANGLES_COMPASS,
+    INV_HUDANGLES_COMPASS_NEEDLE
+} inv_hudangles_type;
 
-	int IndexOfItemPtr( inventory_item_t *item );
-};
-
-inline
-int inventory_type_t::IndexOfItemPtr( inventory_item_t *item )
+class item_properties_t : public Class
 {
-	for( int i = items.NumObjects(); i > 0; i-- )
-	{
-		if( items.ObjectAt( i ) == item )
-		{
-			return i;
-		}
-	}
+public:
+    float         scale;
+    Vector        angles;
+    Vector        angledeltas;
+    Vector        rotateoffset;
+    Vector        offset;
+    inv_move_type move;
+    str           model;
+    str           anim;
+};
 
-	return 0;
+class inventory_item_t : public Class
+{
+public:
+    str                name;
+    str                ammoname;
+    int                equip;
+    int                width;
+    int                height;
+    int                barwidth;
+    int                barheight;
+    int                baroffsetY;
+    int                baroffsetX;
+    float              modelWindowX;
+    float              modelWindowY;
+    float              modelWindowWidth;
+    float              modelWindowHeight;
+    bool               selShaderOnTop;
+    bool               checkammo;
+    str                command;
+    inv_hudangles_type anglesType;
+    item_properties_t  hudprops;
+    item_properties_t  invprops;
+    UIReggedMaterial  *bgshader;
+    UIReggedMaterial  *barshader;
+    UIReggedMaterial  *selshader;
+};
+
+class inventory_type_t
+{
+public:
+    str                           name;
+    bool                          bg_tile;
+    UIReggedMaterial             *texture;
+    UIReggedMaterial             *bg;
+    UIReggedMaterial             *hoverTexture;
+    UIReggedMaterial             *selTexture;
+    Container<inventory_item_t *> items;
+
+    int IndexOfItemPtr(inventory_item_t *item);
+};
+
+inline int inventory_type_t::IndexOfItemPtr(inventory_item_t *item)
+{
+    for (int i = items.NumObjects(); i > 0; i--) {
+        if (items.ObjectAt(i) == item) {
+            return i;
+        }
+    }
+
+    return 0;
 }
 
-class inventory_t {
+class inventory_t
+{
 public:
-	int typewidth;
-	int typeheight;
-	int horizoffset;
-	int vertoffset;
-	int align;
-	inv_cascade_type cascade;
-	str selectsound;
-	str rejectsound;
-	str changesound;
-	Container<inventory_type_t *> types;
+    int                           typewidth;
+    int                           typeheight;
+    int                           horizoffset;
+    int                           vertoffset;
+    inv_align_type                align;
+    inv_cascade_type              cascade;
+    str                           selectsound;
+    str                           rejectsound;
+    str                           changesound;
+    Container<inventory_type_t *> types;
 
-	void Clear() { types.ClearObjectList(); }
+public:
+    inventory_t();
+    ~inventory_t();
+    inventory_t(const inventory_t& other);
+    inventory_t& operator=(const inventory_t& other);
+    void Clear();
 };
 
-class invlistener : public Listener {
+class invlistener : public Listener
+{
 protected:
-	inventory_t *inv;
-	inventory_type_t *curtype;
-	inventory_item_t *curitem;
-	int defaultWidth;
-	int defaultHeight;
-	int defaultBarWidth;
-	int defaultBarHeight;
-	int defaultBarOffsetX;
-	int defaultBarOffsetY;
+    inventory_t      *inv;
+    inventory_type_t *curtype;
+    inventory_item_t *curitem;
+    int               defaultWidth;
+    int               defaultHeight;
+    int               defaultBarWidth;
+    int               defaultBarHeight;
+    int               defaultBarOffsetX;
+    int               defaultBarOffsetY;
 
 public:
-	CLASS_PROTOTYPE( invlistener );
+    CLASS_PROTOTYPE(invlistener);
 
 protected:
-	void	verify_curitem( void );
-	void	verify_curtype( void );
-	void	verify_one_arg( Event *ev );
+    void verify_curitem(void);
+    void verify_curtype(void);
+    void verify_one_arg(Event *ev);
 
 public:
-	invlistener( inventory_t *i );
-	invlistener();
+    invlistener(inventory_t *i);
+    invlistener();
 
-	bool		Load( Script& script );
-	void		InvSelectSound( Event *ev );
-	void		InvRejectSound( Event *ev );
-	void		InvChangeSound( Event *ev );
-	void		InvWidth( Event *ev );
-	void		InvHeight( Event *ev );
-	void		InvHorizOffset( Event *ev );
-	void		InvVertOffset( Event *ev );
-	void		InvAlign( Event *ev );
-	void		InvCascade( Event *ev );
-	void		Typedef( Event *ev );
-	void		OpenBrace( Event *ev );
-	void		CloseBrace( Event *ev );
-	void		ButtonShader( Event *ev );
-	void		HoverShader( Event *ev );
-	void		SelShader( Event *ev );
-	void		Background( Event *ev );
-	void		BackgroundTile( Event *ev );
-	void		Width( Event *ev );
-	void		Height( Event *ev );
-	void		BarWidth( Event *ev );
-	void		BarHeight( Event *ev );
-	void		BarOffsetX( Event *ev );
-	void		BarOffsetY( Event *ev );
-	void		Item( Event *ev );
-	void		Ammo( Event *ev );
-	void		Equip( Event *ev );
-	void		CheckAmmo( Event *ev );
-	void		Command( Event *ev );
-	void		BGShader( Event *ev );
-	void		BarShader( Event *ev );
-	void		SelItemShader( Event *ev );
-	void		SelItemShaderOnTop( Event *ev );
-	void		RotateOffset( Event *ev );
-	void		Offset( Event *ev );
-	void		Model( Event *ev );
-	void		Anim( Event *ev );
-	void		Scale( Event *ev );
-	void		Angles( Event *ev );
-	void		AngleDeltas( Event *ev );
-	void		Move( Event *ev );
-	void		ModelWindow( Event *ev );
-	void		HudRotateOffset( Event *ev );
-	void		HudOffset( Event *ev );
-	void		HudModel( Event *ev );
-	void		HudAnim( Event *ev );
-	void		HudScale( Event *ev );
-	void		HudAngles( Event *ev );
-	void		HudAngleDeltas( Event *ev );
-	void		HudMove( Event *ev );
-	void		HudCompassAngles( Event *ev );
-	void		HudCompassNeedleAngles( Event *ev );
+    bool Load(Script& script);
+    void InvSelectSound(Event *ev);
+    void InvRejectSound(Event *ev);
+    void InvChangeSound(Event *ev);
+    void InvWidth(Event *ev);
+    void InvHeight(Event *ev);
+    void InvHorizOffset(Event *ev);
+    void InvVertOffset(Event *ev);
+    void InvAlign(Event *ev);
+    void InvCascade(Event *ev);
+    void Typedef(Event *ev);
+    void OpenBrace(Event *ev);
+    void CloseBrace(Event *ev);
+    void ButtonShader(Event *ev);
+    void HoverShader(Event *ev);
+    void SelShader(Event *ev);
+    void Background(Event *ev);
+    void BackgroundTile(Event *ev);
+    void Width(Event *ev);
+    void Height(Event *ev);
+    void BarWidth(Event *ev);
+    void BarHeight(Event *ev);
+    void BarOffsetX(Event *ev);
+    void BarOffsetY(Event *ev);
+    void Item(Event *ev);
+    void Ammo(Event *ev);
+    void Equip(Event *ev);
+    void CheckAmmo(Event *ev);
+    void Command(Event *ev);
+    void BGShader(Event *ev);
+    void BarShader(Event *ev);
+    void SelItemShader(Event *ev);
+    void SelItemShaderOnTop(Event *ev);
+    void RotateOffset(Event *ev);
+    void Offset(Event *ev);
+    void Model(Event *ev);
+    void Anim(Event *ev);
+    void Scale(Event *ev);
+    void Angles(Event *ev);
+    void AngleDeltas(Event *ev);
+    void Move(Event *ev);
+    void ModelWindow(Event *ev);
+    void HudRotateOffset(Event *ev);
+    void HudOffset(Event *ev);
+    void HudModel(Event *ev);
+    void HudAnim(Event *ev);
+    void HudScale(Event *ev);
+    void HudAngles(Event *ev);
+    void HudAngleDeltas(Event *ev);
+    void HudMove(Event *ev);
+    void HudCompassAngles(Event *ev);
+    void HudCompassNeedleAngles(Event *ev);
 };
 
-bool CL_LoadInventory( const char *filename, inventory_t *inv );
-inventory_item_t *CL_GetInvItemByName( inventory_t *inv, const char *name );
-qboolean CL_HasInventoryItem( const char *name );
-void CL_AmmoCount( const char *name, int *ammo_count, int *max_ammo_count );
-
-#endif // __CL_INV_H__
+bool              CL_LoadInventory(const char *filename, inventory_t *inv);
+inventory_item_t *CL_GetInvItemByName(inventory_t *inv, const char *name);
+qboolean          CL_HasInventoryItem(const char *name);
+void              CL_AmmoCount(const char *name, int *ammo_count, int *max_ammo_count);

code/client/cl_invrender.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,79 +20,102 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_INVRENDER_H__
-#define __CL_INVRENDER_H__
+#pragma once
 
 class FakkInventory;
 
-typedef enum { selectsound, rejectsound, changesound } invsound_t;
-class FakkItemList : public UIWidget {
+typedef enum {
+    selectsound,
+    rejectsound,
+    changesound
+} invsound_t;
+
+class FakkItemList : public UIWidget
+{
 protected:
-	inventory_type_t *type;
-	uipopup_describe m_describe[ 10 ];
-	inventory_item_t *m_hoveritem;
-	inventory_item_t *m_lastmenuitem;
-	FakkInventory *m_parent;
-	float m_hovertop;
+    inventory_type_t *type;
+    uipopup_describe  m_describe[10];
+    inventory_item_t *m_hoveritem;
+    inventory_item_t *m_lastmenuitem;
+    FakkInventory    *m_parent;
+    float             m_hovertop;
 
 public:
-	CLASS_PROTOTYPE( FakkItemList );
+    CLASS_PROTOTYPE(FakkItemList);
 
-	FakkItemList();
-	~FakkItemList();
+    FakkItemList();
+    ~FakkItemList();
 
-	void	VerifyItemUp( inventory_item_t *item, qboolean warpmouse );
-	void	setType( inventory_type_t *t );
-	void	Create( float x, float y, FakkInventory *parent );
-	bool	HasAnyItems( void );
-	void	Draw( void ) override;
-	void	OnLeftMouseDown( Event *ev );
-	void	OnRightMouseDown( Event *ev );
-	void	OnLeftMouseUp( Event *ev );
-	void	OnRightMouseUp( Event *ev );
-	void	OnMouseMove( Event *ev );
-	void	OnMouseEnter( Event *ev );
-	void	OnMouseLeave( Event *ev );
-	void	OnMenuKilled( Event *ev );
-	void	EquipItem( Event *ev );
+    void VerifyItemUp(inventory_item_t *item, qboolean warpmouse);
+    void setType(inventory_type_t *t);
+    void Create(float x, float y, FakkInventory *parent);
+    bool HasAnyItems(void);
+    void Draw(void) override;
+    void OnLeftMouseDown(Event *ev);
+    void OnRightMouseDown(Event *ev);
+    void OnLeftMouseUp(Event *ev);
+    void OnRightMouseUp(Event *ev);
+    void OnMouseMove(Event *ev);
+    void OnMouseEnter(Event *ev);
+    void OnMouseLeave(Event *ev);
+    void OnMenuKilled(Event *ev);
+    void EquipItem(Event *ev);
+
+    inventory_item_t *getHoverItem() const;
 };
 
-class FakkInventory : public UIWidget {
+class FakkInventory : public UIWidget
+{
 protected:
-	inventory_t *m_inv;
-	SafePtr<FakkItemList> m_currentlist;
-	inventory_type_t *m_currenttype;
-	int m_currentitemnum;
+    inventory_t          *m_inv;
+    SafePtr<FakkItemList> m_currentlist;
+    inventory_type_t     *m_currenttype;
+    int                   m_currentitemnum;
 
 public:
-	CLASS_PROTOTYPE( FakkInventory );
-
-protected:
-	void		VerifyItemUp( inventory_item_t *item, qboolean warpmouse );
+    CLASS_PROTOTYPE(FakkInventory);
 
 public:
-	FakkInventory();
-	~FakkInventory();
+    qboolean m_mouse_active;
 
-	void		setInventory( inventory_t *i );
-	void		Draw( void ) override;
-	void		OnMouseMove( Event *ev );
-	void		OnMouseLeave( Event *ev );
-	void		OnMouseEnter( Event *ev );
-	void		OnMouseDown( Event *ev );
-	void		WarpTo( const char *name );
-	void		WarpTo( int slotnum );
-	void		NextItem( void );
-	void		PrevItem( void );
-	qboolean	isDying( void );
-	qboolean	KeyEvent( int key, unsigned int time ) override;
-	void		PlaySound( invsound_t type );
-	void		Timeout( Event *ev );
-	void		ChangeItem( int sign );
-	int			FindFirstItem( int itemindex, int sign );
+protected:
+    void VerifyTypeUp(inventory_type_t *t, qboolean warpmouse);
+
+public:
+    FakkInventory();
+    ~FakkInventory();
+
+    void     setInventory(inventory_t *i);
+    void     Draw(void) override;
+    void     OnMouseMove(Event *ev);
+    void     OnMouseLeave(Event *ev);
+    void     OnMouseEnter(Event *ev);
+    void     OnMouseDown(Event *ev);
+    void     WarpTo(const char *name);
+    void     WarpTo(int slotnum);
+    void     NextItem(void);
+    void     PrevItem(void);
+    qboolean isDying(void);
+    qboolean KeyEvent(int key, unsigned int time) override;
+    void     PlaySound(invsound_t type);
+    void     Timeout(Event *ev);
+    void     ChangeItem(int sign);
+    int      FindFirstItem(int itemindex, int sign);
 };
 
-void CL_Draw3DModel( float x, float y, float w, float h, qhandle_t model, vec3_t origin, vec3_t rotateoffset, vec3_t offset, vec3_t angle, vec3_t color, str anim );
-qboolean UI_CloseInventory( void );
+void CL_Draw3DModel(
+    float     x,
+    float     y,
+    float     w,
+    float     h,
+    qhandle_t model,
+    vec3_t    origin,
+    vec3_t    rotateoffset,
+    vec3_t    offset,
+    vec3_t    angle,
+    vec3_t    color,
+    str       anim
+);
 
-#endif // __CL_INVRENDER_H__
+void     UI_DoInventory(qboolean activate_mouse);
+qboolean UI_CloseInventory(void);

code/client/cl_net_chan.cpp

@@ -132,7 +132,7 @@ CL_Netchan_TransmitNextFragment
 =================
 */
 void CL_Netchan_TransmitNextFragment( netchan_t *chan ) {
-	Netchan_TransmitNextFragment( chan );
+	Netchan_TransmitNextFragment( chan, cl_netprofile->integer ? &cls.netprofile.inPackets : NULL );
 }
 
 /*
@@ -144,7 +144,7 @@ void CL_Netchan_Transmit( netchan_t *chan, msg_t* msg ) {
 	MSG_WriteByte( msg, clc_EOF );
 
 	CL_Netchan_Encode( msg );
-	Netchan_Transmit( chan, msg->cursize, msg->data );
+	Netchan_Transmit( chan, msg->cursize, msg->data, cl_netprofile->integer ? &cls.netprofile.inPackets : NULL );
 }
 
 extern 	int oldsize;
@@ -158,10 +158,30 @@ CL_Netchan_Process
 qboolean CL_Netchan_Process( netchan_t *chan, msg_t *msg ) {
 	int ret;
 
-	ret = Netchan_Process( chan, msg );
+	ret = Netchan_Process( chan, msg, cl_netprofile->integer ? &cls.netprofile.outPackets : NULL );
 	if (!ret)
 		return qfalse;
 	CL_Netchan_Decode( msg );
 	newsize += msg->cursize;
 	return qtrue;
 }
+
+/*
+=================
+CL_NET_OutOfBandPrint
+=================
+*/
+void CL_NET_OutOfBandPrint(netadr_t adr, const char* format, ...) {
+    va_list	argptr;
+    char	string[MAX_MSGLEN];
+
+    va_start(argptr, format);
+    Q_vsnprintf(string, sizeof(string), format, argptr);
+    va_end(argptr);
+
+	NET_OutOfBandPrint(NS_CLIENT, adr, "%s", string);
+
+	if (cl_netprofile->integer) {
+		NetProfileAddPacket(&cls.netprofile.inPackets, strlen(string), NETPROF_PACKET_MESSAGE);
+	}
+}

code/client/cl_parse.cpp

@@ -223,13 +223,13 @@ qboolean CL_UnpackNonPVSClient(int* packed, radarUnpacked_t* unpacked) {
 		range = 0;
 	}
 
-	unpacked->x = x * range / 63.f;
-	unpacked->y = y * range / 63.f;
+	unpacked->x = x * range / (MAX_CLIENTS - 1);
+	unpacked->y = y * range / (MAX_CLIENTS - 1);
 
 	if (!bValid)
 	{
-		unpacked->x = x * range / 63.f * 1024;
-		unpacked->y = y * range / 63.f * 1024;
+		unpacked->x = x * range / (MAX_CLIENTS - 1) * 1024.0;
+		unpacked->y = y * range / (MAX_CLIENTS - 1) * 1024.0;
 	}
 
 	unpacked->yaw = yaw * 11.25f;
@@ -429,12 +429,24 @@ void CL_SystemInfoChanged( void ) {
 	// in some cases, outdated cp commands might get sent with this news serverId
 	cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) );
 
+#ifdef USE_VOIP
+#ifdef LEGACY_PROTOCOL
+	if(clc.compat)
+		clc.voipEnabled = qfalse;
+	else
+#endif
+	{
+		s = Info_ValueForKey( systemInfo, "sv_voipProtocol" );
+		clc.voipEnabled = !Q_stricmp(s, "opus");
+	}
+#endif
+
 	// don't set any vars when playing a demo
 	if ( clc.demoplaying ) {
 		return;
 	}
 
-	s = Info_ValueForKey( systemInfo, "sv_cheats" );
+	s = Info_ValueForKey( systemInfo, "cheats" );
 	cl_connectedToCheatServer = atoi( s );
 	if ( !cl_connectedToCheatServer ) {
 		Cvar_SetCheatState();
@@ -784,6 +796,178 @@ void CL_ParseDownload ( msg_t *msg ) {
 	}
 }
 
+#ifdef USE_VOIP
+static
+qboolean CL_ShouldIgnoreVoipSender(int sender)
+{
+	if (!cl_voip->integer)
+		return qtrue;  // VoIP is disabled.
+	else if ((sender == clc.clientNum) && (!clc.demoplaying))
+		return qtrue;  // ignore own voice (unless playing back a demo).
+	else if (clc.voipMuteAll)
+		return qtrue;  // all channels are muted with extreme prejudice.
+	else if (clc.voipIgnore[sender])
+		return qtrue;  // just ignoring this guy.
+	else if (clc.voipGain[sender] == 0.0f)
+		return qtrue;  // too quiet to play.
+
+	return qfalse;
+}
+
+/*
+=====================
+CL_PlayVoip
+
+Play raw data
+=====================
+*/
+
+static void CL_PlayVoip(int sender, int samplecnt, const byte *data, int flags)
+{
+	if(flags & VOIP_DIRECT)
+	{
+		S_RawSamples(sender + 1, samplecnt, 48000, 2, 1,
+	             data, clc.voipGain[sender], -1);
+	}
+
+	if(flags & VOIP_SPATIAL)
+	{
+		S_RawSamples(sender + MAX_CLIENTS + 1, samplecnt, 48000, 2, 1,
+	             data, 1.0f, sender);
+	}
+}
+
+/*
+=====================
+CL_ParseVoip
+
+A VoIP message has been received from the server
+=====================
+*/
+static
+void CL_ParseVoip ( msg_t *msg, qboolean ignoreData ) {
+	static short decoded[VOIP_MAX_PACKET_SAMPLES*4]; // !!! FIXME: don't hard code
+
+	const int sender = MSG_ReadShort(msg);
+	const int generation = MSG_ReadByte(msg);
+	const int sequence = MSG_ReadLong(msg);
+	const int frames = MSG_ReadByte(msg);
+	const int packetsize = MSG_ReadShort(msg);
+	const int flags = MSG_ReadBits(msg, VOIP_FLAGCNT);
+	unsigned char encoded[4000];
+	int	numSamples;
+	int seqdiff;
+	int written = 0;
+	int i;
+
+	Com_DPrintf("VoIP: %d-byte packet from client %d\n", packetsize, sender);
+
+	if (sender < 0)
+		return;   // short/invalid packet, bail.
+	else if (generation < 0)
+		return;   // short/invalid packet, bail.
+	else if (sequence < 0)
+		return;   // short/invalid packet, bail.
+	else if (frames < 0)
+		return;   // short/invalid packet, bail.
+	else if (packetsize < 0)
+		return;   // short/invalid packet, bail.
+
+	if (packetsize > sizeof (encoded)) {  // overlarge packet?
+		int bytesleft = packetsize;
+		while (bytesleft) {
+			int br = bytesleft;
+			if (br > sizeof (encoded))
+				br = sizeof (encoded);
+			MSG_ReadData(msg, encoded, br);
+			bytesleft -= br;
+		}
+		return;   // overlarge packet, bail.
+	}
+
+	MSG_ReadData(msg, encoded, packetsize);
+
+	if (ignoreData) {
+		return; // just ignore legacy speex voip data
+	} else if (!clc.voipCodecInitialized) {
+		return;   // can't handle VoIP without libopus!
+	} else if (sender >= MAX_CLIENTS) {
+		return;   // bogus sender.
+	} else if (CL_ShouldIgnoreVoipSender(sender)) {
+		return;   // Channel is muted, bail.
+	}
+
+	// !!! FIXME: make sure data is narrowband? Does decoder handle this?
+
+	Com_DPrintf("VoIP: packet accepted!\n");
+
+	seqdiff = sequence - clc.voipIncomingSequence[sender];
+
+	// This is a new "generation" ... a new recording started, reset the bits.
+	if (generation != clc.voipIncomingGeneration[sender]) {
+		Com_DPrintf("VoIP: new generation %d!\n", generation);
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		clc.voipIncomingGeneration[sender] = generation;
+		seqdiff = 0;
+	} else if (seqdiff < 0) {   // we're ahead of the sequence?!
+		// This shouldn't happen unless the packet is corrupted or something.
+		Com_DPrintf("VoIP: misordered sequence! %d < %d!\n",
+		            sequence, clc.voipIncomingSequence[sender]);
+		// reset the decoder just in case.
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		seqdiff = 0;
+	} else if (seqdiff * VOIP_MAX_PACKET_SAMPLES*2 >= sizeof (decoded)) { // dropped more than we can handle?
+		// just start over.
+		Com_DPrintf("VoIP: Dropped way too many (%d) frames from client #%d\n",
+		            seqdiff, sender);
+		opus_decoder_ctl(clc.opusDecoder[sender], OPUS_RESET_STATE);
+		seqdiff = 0;
+	}
+
+	if (seqdiff != 0) {
+		Com_DPrintf("VoIP: Dropped %d frames from client #%d\n",
+		            seqdiff, sender);
+		// tell opus that we're missing frames...
+		for (i = 0; i < seqdiff; i++) {
+			assert((written + VOIP_MAX_PACKET_SAMPLES) * 2 < sizeof (decoded));
+			numSamples = opus_decode(clc.opusDecoder[sender], NULL, 0, decoded + written, VOIP_MAX_PACKET_SAMPLES, 0);
+			if ( numSamples <= 0 ) {
+				Com_DPrintf("VoIP: Error decoding frame %d from client #%d\n", i, sender);
+				continue;
+			}
+			written += numSamples;
+		}
+	}
+
+	numSamples = opus_decode(clc.opusDecoder[sender], encoded, packetsize, decoded + written, ARRAY_LEN(decoded) - written, 0);
+
+	if ( numSamples <= 0 ) {
+		Com_DPrintf("VoIP: Error decoding voip data from client #%d\n", sender);
+		numSamples = 0;
+	}
+
+	#if 0
+	static FILE *encio = NULL;
+	if (encio == NULL) encio = fopen("voip-incoming-encoded.bin", "wb");
+	if (encio != NULL) { fwrite(encoded, packetsize, 1, encio); fflush(encio); }
+	static FILE *decio = NULL;
+	if (decio == NULL) decio = fopen("voip-incoming-decoded.bin", "wb");
+	if (decio != NULL) { fwrite(decoded+written, numSamples*2, 1, decio); fflush(decio); }
+	#endif
+
+	written += numSamples;
+
+	Com_DPrintf("VoIP: playback %d bytes, %d samples, %d frames\n",
+	            written * 2, written, frames);
+
+	if(written > 0)
+		CL_PlayVoip(sender, written, (const byte *) decoded, flags);
+
+	clc.voipIncomingSequence[sender] = sequence + frames;
+}
+#endif
+
+
 /*
 =====================
 CL_ParseCommandString
@@ -932,8 +1116,16 @@ void CL_ParseServerMessage( msg_t *msg ) {
 			}
 			CL_ParseCGMessage( msg );
 			break;
+		case svc_voipSpeex:
+#ifdef USE_VOIP
+			CL_ParseVoip( msg, qtrue );
+#endif
+			break;
+		case svc_voipOpus:
+#ifdef USE_VOIP
+			CL_ParseVoip( msg, !clc.voipEnabled );
+#endif
+			break;
 		}
 	}
 }
-
-

code/client/cl_scrn.cpp

@@ -343,7 +343,7 @@ void SCR_DrawDemoRecording( void ) {
 	}
 
 	pos = FS_FTell( clc.demofile );
-	sprintf( string, "RECORDING %s: %ik", clc.demoName, pos / 1024 );
+	Com_sprintf( string, sizeof( string ), "RECORDING %s: %ik", clc.demoName, pos / 1024 );
 
 	SCR_DrawStringExt( 320 - strlen( string ) * 4, 20, 8, string, g_color_table[7], qtrue, qfalse );
 }
@@ -520,16 +520,18 @@ text to the screen.
 ==================
 */
 void SCR_UpdateScreen( void ) {
-	static int	recursive;
+	static qboolean screen_recursive;
 
 	if ( !scr_initialized ) {
 		return;				// not initialized yet
 	}
 
-	if ( ++recursive > 2 ) {
-		Com_Error( ERR_FATAL, "SCR_UpdateScreen: recursively called" );
+	if (screen_recursive) {
+		// already called
+		return;
 	}
-	recursive = 1;
+
+	screen_recursive = qtrue;
 	
 	CL_StartHunkUsers(qfalse);
 	SCR_SimpleUpdateScreen();
@@ -553,6 +555,6 @@ void SCR_UpdateScreen( void ) {
 		}
 	}
 
-	recursive = 0;
+	screen_recursive = qfalse;
 }
 

code/client/cl_ui.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2023-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -35,6 +35,7 @@ typedef struct {
 extern cvar_t *ui_health_start;
 extern cvar_t *ui_health_end;
 extern cvar_t *sound_overlay;
+extern cvar_t *cl_movieaudio;
 
 //
 // initialization
@@ -49,11 +50,13 @@ void CL_ShutdownUI(void);
 extern inventory_t client_inv;
 extern bind_t      client_bind;
 extern cvar_t     *cl_greenfps;
+extern qboolean    server_loading;
 
 const char *CvarGetForUI(const char *name, const char *defval);
 void        UI_ClearState(void);
 void        CL_BeginRegistration(void);
 void        CL_EndRegistration(void);
+float       UI_GetObjectivesTop(void);
 
 //
 // menu
@@ -110,6 +113,7 @@ void UI_DeleteScoreBoardItems(int iMaxIndex);
 void     UI_BeginLoad(const char *pszMapName);
 void     UI_EndLoad(void);
 void     UI_AbortLoad(void);
+int      CL_FontStringWidth(fontheader_t* pFont, const char* pszString, int iMaxLen);
 void     UI_BeginLoadResource(void);
 void     UI_EndLoadResource(void);
 void     UI_EndLoadResource(const char *name);

code/client/cl_uibind.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -24,281 +24,529 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 bind_t::bind_t()
 {
-	// FIXME: stub
+    int i;
+
+    commandwidth       = 100;
+    commandheight      = 20;
+    primarykeywidth    = 100;
+    primarykeyheight   = 20;
+    alternatekeywidth  = 100;
+    alternatekeyheight = 20;
+    fillwidth          = 16;
+    fillmaterial       = NULL;
+
+    for (i = 0; i < ARRAY_LEN(headermats); i++) {
+        headermats[i] = NULL;
+    }
 }
 
 bind_t::~bind_t()
 {
-	Clear();
+    Clear();
 }
 
-void bind_t::Clear
-	(
-	void
-	)
-
+void bind_t::Clear(void)
 {
-	// FIXME: stub
+    for (int i = binds.NumObjects(); i > 0; i--) {
+        bind_item_t *bi;
+
+        bi = binds.ObjectAt(i);
+        binds.RemoveObjectAt(i);
+
+        if (bi) {
+            delete bi;
+        }
+    }
 }
 
-CLASS_DECLARATION( Listener, bindlistener, NULL )
-{
-	{ NULL, NULL }
+Event EV_Bind_Header
+(
+    "header",
+    EV_DEFAULT,
+    "iss",
+    "column_num name material",
+    "Set the header of each column"
+);
+Event EV_Bind_Width
+(
+    "bind_width",
+    EV_DEFAULT,
+    "i",
+    "width",
+    "Width of the bind menu"
+);
+Event EV_Bind_Height
+(
+    "bind_height",
+    EV_DEFAULT,
+    "i",
+    "height",
+    "Height of the bind menu"
+);
+Event EV_Bind_FillWidth
+(
+    "bind_fillwidth",
+    EV_DEFAULT,
+    "iS",
+    "width material",
+    "Width of the filling between widgets"
+);
+Event EV_Bind_CommandWidth
+(
+    "bind_commandwidth",
+    EV_DEFAULT,
+    "i",
+    "width",
+    "Width of the command item"
+);
+Event EV_Bind_CommandHeight
+(
+    "bind_commandheight",
+    EV_DEFAULT,
+    "i",
+    "height",
+    "Height of the command item"
+);
+Event EV_Bind_PrimaryKeyWidth
+(
+    "bind_primarykeywidth",
+    EV_DEFAULT,
+    "i",
+    "width",
+    "Width of the primary key item"
+);
+Event EV_Bind_PrimaryKeyHeight
+(
+    "bind_primarykeyheight",
+    EV_DEFAULT,
+    "i",
+    "height",
+    "Height of the primary key item"
+);
+Event EV_Bind_AlternateKeyWidth
+(
+    "bind_alternatekeywidth",
+    EV_DEFAULT,
+    "i",
+    "width",
+    "Width of the alternate key item"
+);
+Event EV_Bind_AlternateKeyHeight
+(
+    "bind_alternatekeyheight",
+    EV_DEFAULT,
+    "i",
+    "height",
+    "Height of the alternate key item"
+);
+Event EV_Bind_NewItem
+(
+    "binditem",
+    EV_DEFAULT,
+    "ss",
+    "name command",
+    "Create a new bind item in the interface"
+);
+Event EV_Bind_Align
+(
+    "align",
+    EV_DEFAULT,
+    "sSSSSS",
+    "arg1 arg2 arg3 arg4 arg5 arg6",
+    "Set the alignment on the bind menu"
+);
+Event EV_Bind_TitleForegroundColor
+(
+    "titleforegroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the title foreground"
+);
+Event EV_Bind_TitleBackgroundColor
+(
+    "titlebackgroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the title background"
+);
+Event EV_Bind_InactiveForegroundColor
+(
+    "inactiveforegroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the inactive button foreground"
+);
+Event EV_Bind_InactiveBackgroundColor
+(
+    "inactivebackgroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the inactive button background"
+);
+Event EV_Bind_ActiveForegroundColor
+(
+    "activeforegroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the active button foreground"
+);
+Event EV_Bind_ActiveBackgroundColor
+(
+    "activebackgroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the active button background"
+);
+Event EV_Bind_ActiveBorderColor
+(
+    "activebordercolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the active button border"
+);
+Event EV_Bind_HighlightForegroundColor
+(
+    "highlightforegroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the highlighted button foreground"
+);
+Event EV_Bind_HighlightBackgroundColor
+(
+    "highlightbackgroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the highlighted button background"
+);
+Event EV_Bind_SelectForegroundColor
+(
+    "selectforegroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the selected button foreground"
+);
+Event EV_Bind_SelectBackgroundColor
+(
+    "selectbackgroundcolor",
+    EV_DEFAULT,
+    "ffff",
+    "r g b a",
+    "Set the color for the selected button background"
+);
+Event EV_Bind_ChangeSound
+(
+    "changesound",
+    EV_DEFAULT,
+    "s",
+    "soundname",
+    "Set the name of the sound to play when the highlighted item changes"
+);
+Event EV_Bind_ActiveSound
+(
+    "activesound",
+    EV_DEFAULT,
+    "s",
+    "soundname",
+    "Set the name of the sound to play when the item is made active"
+);
+Event EV_Bind_EnterSound
+(
+    "entersound",
+    EV_DEFAULT,
+    "s",
+    "soundname",
+    "Set the name of the sound to play when the key is entered"
+);
+
+CLASS_DECLARATION(Listener, bindlistener, NULL) {
+    {&EV_Bind_Width,                    &bindlistener::Width                   },
+    {&EV_Bind_Height,                   &bindlistener::Height                  },
+    {&EV_Bind_FillWidth,                &bindlistener::FillWidth               },
+    {&EV_Bind_CommandWidth,             &bindlistener::CommandWidth            },
+    {&EV_Bind_CommandHeight,            &bindlistener::CommandHeight           },
+    {&EV_Bind_PrimaryKeyWidth,          &bindlistener::PrimaryKeyWidth         },
+    {&EV_Bind_PrimaryKeyHeight,         &bindlistener::PrimaryKeyHeight        },
+    {&EV_Bind_AlternateKeyWidth,        &bindlistener::AlternateKeyWidth       },
+    {&EV_Bind_AlternateKeyHeight,       &bindlistener::AlternateKeyHeight      },
+    {&EV_Bind_Header,                   &bindlistener::Header                  },
+    {&EV_Bind_NewItem,                  &bindlistener::NewItem                 },
+    {&EV_Bind_Align,                    &bindlistener::Align                   },
+    {&EV_Bind_TitleForegroundColor,     &bindlistener::TitleForegroundColor    },
+    {&EV_Bind_TitleBackgroundColor,     &bindlistener::TitleBackgroundColor    },
+    {&EV_Bind_InactiveForegroundColor,  &bindlistener::InactiveForegroundColor },
+    {&EV_Bind_InactiveBackgroundColor,  &bindlistener::InactiveBackgroundColor },
+    {&EV_Bind_ActiveForegroundColor,    &bindlistener::ActiveForegroundColor   },
+    {&EV_Bind_ActiveBackgroundColor,    &bindlistener::ActiveBackgroundColor   },
+    {&EV_Bind_ActiveBorderColor,        &bindlistener::ActiveBorderColor       },
+    {&EV_Bind_HighlightForegroundColor, &bindlistener::HighlightForegroundColor},
+    {&EV_Bind_HighlightBackgroundColor, &bindlistener::HighlightBackgroundColor},
+    {&EV_Bind_SelectForegroundColor,    &bindlistener::SelectForegroundColor   },
+    {&EV_Bind_SelectBackgroundColor,    &bindlistener::SelectBackgroundColor   },
+    {&EV_Bind_ChangeSound,              &bindlistener::ChangeSound             },
+    {&EV_Bind_ActiveSound,              &bindlistener::ActiveSound             },
+    {&EV_Bind_EnterSound,               &bindlistener::EnterSound              },
+    {NULL,                              NULL                                   }
 };
 
-bindlistener::bindlistener()
+bindlistener::bindlistener() {}
+
+bindlistener::bindlistener(bind_t *b)
 {
+    bind = b;
 }
 
-bindlistener::bindlistener
-	(
-	bind_t *b
-	)
-
+void bindlistener::Header(Event *ev)
 {
-	bind = b;
+    int num;
+
+    num = ev->GetInteger(1) - 1;
+    if (num > ARRAY_LEN(bind_t::headers)) {
+        return;
+    }
+
+    bind->headers[num] = ev->GetString(2);
+    if (ev->NumArgs() > 2) {
+        bind->headermats[num] = uWinMan.RegisterShader(ev->GetString(3));
+    }
 }
 
-bool bindlistener::Load
-	(
-	Script& script
-	)
-
+void bindlistener::ChangeSound(Event *ev)
 {
-	// FIXME: stub
-	return false;
+    bind->changesound = ev->GetString(1);
 }
 
-void bindlistener::Header
-	(
-	Event *ev
-	)
-
+void bindlistener::ActiveSound(Event *ev)
 {
-	// FIXME: stub
+    bind->activesound = ev->GetString(1);
 }
 
-void bindlistener::Width
-	(
-	Event *ev
-	)
-
+void bindlistener::EnterSound(Event *ev)
 {
-	// FIXME: stub
+    bind->entersound = ev->GetString(1);
 }
 
-void bindlistener::FillWidth
-	(
-	Event *ev
-	)
-
+void bindlistener::SelectForegroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->selectfgcolor.r = ev->GetFloat(1);
+    bind->selectfgcolor.g = ev->GetFloat(2);
+    bind->selectfgcolor.b = ev->GetFloat(3);
+    bind->selectfgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::Height
-	(
-	Event *ev
-	)
-
+void bindlistener::SelectBackgroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->selectbgcolor.r = ev->GetFloat(1);
+    bind->selectbgcolor.g = ev->GetFloat(2);
+    bind->selectbgcolor.b = ev->GetFloat(3);
+    bind->selectbgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::CommandWidth
-	(
-	Event *ev
-	)
-
+void bindlistener::TitleForegroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->titlefgcolor.r = ev->GetFloat(1);
+    bind->titlefgcolor.g = ev->GetFloat(2);
+    bind->titlefgcolor.b = ev->GetFloat(3);
+    bind->titlefgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::CommandHeight
-	(
-	Event *ev
-	)
-
+void bindlistener::TitleBackgroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->titlebgcolor.r = ev->GetFloat(1);
+    bind->titlebgcolor.g = ev->GetFloat(2);
+    bind->titlebgcolor.b = ev->GetFloat(3);
+    bind->titlebgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::PrimaryKeyWidth
-	(
-	Event *ev
-	)
-
+void bindlistener::ActiveBorderColor(Event *ev)
 {
-	// FIXME: stub
+    bind->activebordercolor.r = ev->GetFloat(1);
+    bind->activebordercolor.g = ev->GetFloat(2);
+    bind->activebordercolor.b = ev->GetFloat(3);
+    bind->activebordercolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::PrimaryKeyHeight
-	(
-	Event *ev
-	)
-
+void bindlistener::ActiveForegroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->activefgcolor.r = ev->GetFloat(1);
+    bind->activefgcolor.g = ev->GetFloat(2);
+    bind->activefgcolor.b = ev->GetFloat(3);
+    bind->activefgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::AlternateKeyWidth
-	(
-	Event *ev
-	)
-
+void bindlistener::ActiveBackgroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->activebgcolor.r = ev->GetFloat(1);
+    bind->activebgcolor.g = ev->GetFloat(2);
+    bind->activebgcolor.b = ev->GetFloat(3);
+    bind->activebgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::AlternateKeyHeight
-	(
-	Event *ev
-	)
-
+void bindlistener::InactiveForegroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->inactivefgcolor.r = ev->GetFloat(1);
+    bind->inactivefgcolor.g = ev->GetFloat(2);
+    bind->inactivefgcolor.b = ev->GetFloat(3);
+    bind->inactivefgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::NewItem
-	(
-	Event *ev
-	)
-
+void bindlistener::InactiveBackgroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->inactivebgcolor.r = ev->GetFloat(1);
+    bind->inactivebgcolor.g = ev->GetFloat(2);
+    bind->inactivebgcolor.b = ev->GetFloat(3);
+    bind->inactivebgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::Align
-	(
-	Event *ev
-	)
-
+void bindlistener::HighlightForegroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->highlightfgcolor.r = ev->GetFloat(1);
+    bind->highlightfgcolor.g = ev->GetFloat(2);
+    bind->highlightfgcolor.b = ev->GetFloat(3);
+    bind->highlightfgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::TitleForegroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::HighlightBackgroundColor(Event *ev)
 {
-	// FIXME: stub
+    bind->highlightbgcolor.r = ev->GetFloat(1);
+    bind->highlightbgcolor.g = ev->GetFloat(2);
+    bind->highlightbgcolor.b = ev->GetFloat(3);
+    bind->highlightbgcolor.a = ev->GetFloat(4);
 }
 
-void bindlistener::TitleBackgroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::Align(Event *ev)
 {
-	// FIXME: stub
+    int i;
+
+    for (i = 1; i <= ev->NumArgs(); i++) {
+        str align = ev->GetString(i);
+
+        if (!str::icmp(align, "left")) {
+            bind->align |= WA_LEFT;
+        } else if (!str::icmp(align, "right")) {
+            bind->align |= WA_RIGHT;
+        } else if (!str::icmp(align, "top")) {
+            bind->align |= WA_TOP;
+        } else if (!str::icmp(align, "bottom")) {
+            bind->align |= WA_BOTTOM;
+        } else if (!str::icmp(align, "centerx")) {
+            bind->align |= WA_CENTERX;
+        } else if (!str::icmp(align, "centery")) {
+            bind->align |= WA_CENTERY;
+        }
+    }
 }
 
-void bindlistener::InactiveForegroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::NewItem(Event *ev)
 {
-	// FIXME: stub
+    bind_item_t      *bt;
+    UIReggedMaterial *mat = NULL;
+
+    if (ev->NumArgs() > 2) {
+        mat = uWinMan.RegisterShader(ev->GetString(3));
+    }
+
+    str n = ev->GetString(1);
+    str c = ev->GetString(2);
+
+    bt               = new bind_item_t;
+    bt->name         = n;
+    bt->command      = c;
+    bt->nameMaterial = mat;
+
+    bind->binds.AddObject(bt);
 }
 
-void bindlistener::InactiveBackgroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::Width(Event *ev)
 {
-	// FIXME: stub
+    bind->width = ev->GetInteger(1);
 }
 
-void bindlistener::ActiveForegroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::Height(Event *ev)
 {
-	// FIXME: stub
+    bind->height = ev->GetInteger(1);
 }
 
-void bindlistener::ActiveBackgroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::FillWidth(Event *ev)
 {
-	// FIXME: stub
+    bind->fillwidth = ev->GetInteger(1);
+
+    if (ev->NumArgs() > 1) {
+        bind->fillmaterial = uWinMan.RegisterShader(ev->GetString(2));
+    }
 }
 
-void bindlistener::ActiveBorderColor
-	(
-	Event *ev
-	)
-
+void bindlistener::CommandWidth(Event *ev)
 {
-	// FIXME: stub
+    bind->commandwidth = ev->GetInteger(1);
 }
 
-void bindlistener::HighlightForegroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::CommandHeight(Event *ev)
 {
-	// FIXME: stub
+    bind->commandheight = ev->GetInteger(1);
 }
 
-void bindlistener::HighlightBackgroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::PrimaryKeyWidth(Event *ev)
 {
-	// FIXME: stub
+    bind->primarykeywidth = ev->GetInteger(1);
 }
 
-void bindlistener::SelectForegroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::PrimaryKeyHeight(Event *ev)
 {
-	// FIXME: stub
+    bind->primarykeyheight = ev->GetInteger(1);
 }
 
-void bindlistener::SelectBackgroundColor
-	(
-	Event *ev
-	)
-
+void bindlistener::AlternateKeyWidth(Event *ev)
 {
-	// FIXME: stub
+    bind->alternatekeywidth = ev->GetInteger(1);
 }
 
-void bindlistener::ChangeSound
-	(
-	Event *ev
-	)
-
+void bindlistener::AlternateKeyHeight(Event *ev)
 {
-	// FIXME: stub
+    bind->alternatekeyheight = ev->GetInteger(1);
 }
 
-void bindlistener::ActiveSound
-	(
-	Event *ev
-	)
-
+bool bindlistener::Load(Script& script)
 {
-	// FIXME: stub
+    str token;
+    str errortext;
+
+    while (script.TokenAvailable(true)) {
+        token = script.GetToken(true);
+
+        if (!token.length() || !ValidEvent(token)) {
+            throw "invalid token";
+        }
+
+        Event *event = new Event(token);
+
+        while (script.TokenAvailable(false)) {
+            event->AddToken(script.GetToken(false));
+        }
+
+        ProcessEvent(event);
+    }
+
+    return true;
 }
 
-void bindlistener::EnterSound
-	(
-	Event *ev
-	)
-
+bool CL_LoadBind(const char *filename, bind_t *bind)
 {
-	// FIXME: stub
+    Script script;
+
+    bind->Clear();
+
+    bindlistener listener(bind);
+    script.LoadFile(filename);
+    // Load the bind file
+    return listener.Load(script);
 }

code/client/cl_uibind.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,115 +20,109 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIBIND_H__
-#define __CL_UIBIND_H__
+#pragma once
 
-class bind_item_t {
+class bind_item_t
+{
 public:
-	str name;
-	str command;
-	UIReggedMaterial *nameMaterial;
+    str               name;
+    str               command;
+    UIReggedMaterial *nameMaterial;
 
-	bind_item_t();
-	bind_item_t( str name, str command, UIReggedMaterial *nameMaterial );
+    bind_item_t();
+    bind_item_t(str name, str command, UIReggedMaterial *nameMaterial);
 };
 
-inline
-bind_item_t::bind_item_t()
+inline bind_item_t::bind_item_t()
 {
-	nameMaterial = NULL;
+    nameMaterial = NULL;
 }
 
-inline
-bind_item_t::bind_item_t
-	(
-	str name,
-	str command,
-	UIReggedMaterial *nameMaterial
-	)
-
+inline bind_item_t::bind_item_t(str name, str command, UIReggedMaterial *nameMaterial)
 {
-	this->name = name;
-	this->command = command;
-	this->nameMaterial = nameMaterial;
+    this->name         = name;
+    this->command      = command;
+    this->nameMaterial = nameMaterial;
 }
 
-class bind_t {
+class bind_t
+{
 public:
-	int width;
-	int height;
-	int fillwidth;
-	int commandwidth;
-	int commandheight;
-	int primarykeywidth;
-	int primarykeyheight;
-	int alternatekeywidth;
-	int alternatekeyheight;
-	int align;
-	UColor titlebgcolor;
-	UColor titlefgcolor;
-	UColor activefgcolor;
-	UColor activebgcolor;
-	UColor activebordercolor;
-	UColor inactivefgcolor;
-	UColor inactivebgcolor;
-	UColor highlightfgcolor;
-	UColor highlightbgcolor;
-	UColor selectfgcolor;
-	UColor selectbgcolor;
-	str changesound;
-	str activesound;
-	str entersound;
-	str headers[ 3 ];
-	UIReggedMaterial *headermats[ 3 ];
-	UIReggedMaterial *fillmaterial;
-	Container<bind_item_t *> binds;
+    int                      width;
+    int                      height;
+    int                      fillwidth;
+    int                      commandwidth;
+    int                      commandheight;
+    int                      primarykeywidth;
+    int                      primarykeyheight;
+    int                      alternatekeywidth;
+    int                      alternatekeyheight;
+    int                      align;
+    UColor                   titlebgcolor;
+    UColor                   titlefgcolor;
+    UColor                   activefgcolor;
+    UColor                   activebgcolor;
+    UColor                   activebordercolor;
+    UColor                   inactivefgcolor;
+    UColor                   inactivebgcolor;
+    UColor                   highlightfgcolor;
+    UColor                   highlightbgcolor;
+    UColor                   selectfgcolor;
+    UColor                   selectbgcolor;
+    str                      changesound;
+    str                      activesound;
+    str                      entersound;
+    str                      headers[3];
+    UIReggedMaterial        *headermats[3];
+    UIReggedMaterial        *fillmaterial;
+    Container<bind_item_t *> binds;
 
 public:
-	bind_t();
-	~bind_t();
+    bind_t();
+    ~bind_t();
 
-	void Clear( void );
+    void Clear(void);
 };
 
-class bindlistener : public Listener {
+class bindlistener : public Listener
+{
 protected:
-	bind_t *bind;
+    bind_t *bind;
 
 public:
-	CLASS_PROTOTYPE( bindlistener );
+    CLASS_PROTOTYPE(bindlistener);
 
 public:
-	bindlistener();
-	bindlistener( bind_t *b );
+    bindlistener();
+    bindlistener(bind_t *b);
 
-	bool	Load( Script& script );
-	void	Header( Event *ev );
-	void	Width( Event *ev );
-	void	FillWidth( Event *ev );
-	void	Height( Event *ev );
-	void	CommandWidth( Event *ev );
-	void	CommandHeight( Event *ev );
-	void	PrimaryKeyWidth( Event *ev );
-	void	PrimaryKeyHeight( Event *ev );
-	void	AlternateKeyWidth( Event *ev );
-	void	AlternateKeyHeight( Event *ev );
-	void	NewItem( Event *ev );
-	void	Align( Event *ev );
-	void	TitleForegroundColor( Event *ev );
-	void	TitleBackgroundColor( Event *ev );
-	void	InactiveForegroundColor( Event *ev );
-	void	InactiveBackgroundColor( Event *ev );
-	void	ActiveForegroundColor( Event *ev );
-	void	ActiveBackgroundColor( Event *ev );
-	void	ActiveBorderColor( Event *ev );
-	void	HighlightForegroundColor( Event *ev );
-	void	HighlightBackgroundColor( Event *ev );
-	void	SelectForegroundColor( Event *ev );
-	void	SelectBackgroundColor( Event *ev );
-	void	ChangeSound( Event *ev );
-	void	ActiveSound( Event *ev );
-	void	EnterSound( Event *ev );
+    bool Load(Script& script);
+    void Header(Event *ev);
+    void Width(Event *ev);
+    void FillWidth(Event *ev);
+    void Height(Event *ev);
+    void CommandWidth(Event *ev);
+    void CommandHeight(Event *ev);
+    void PrimaryKeyWidth(Event *ev);
+    void PrimaryKeyHeight(Event *ev);
+    void AlternateKeyWidth(Event *ev);
+    void AlternateKeyHeight(Event *ev);
+    void NewItem(Event *ev);
+    void Align(Event *ev);
+    void TitleForegroundColor(Event *ev);
+    void TitleBackgroundColor(Event *ev);
+    void InactiveForegroundColor(Event *ev);
+    void InactiveBackgroundColor(Event *ev);
+    void ActiveForegroundColor(Event *ev);
+    void ActiveBackgroundColor(Event *ev);
+    void ActiveBorderColor(Event *ev);
+    void HighlightForegroundColor(Event *ev);
+    void HighlightBackgroundColor(Event *ev);
+    void SelectForegroundColor(Event *ev);
+    void SelectBackgroundColor(Event *ev);
+    void ChangeSound(Event *ev);
+    void ActiveSound(Event *ev);
+    void EnterSound(Event *ev);
 };
 
-#endif
+bool CL_LoadBind(const char* filename, bind_t* bind);

code/client/cl_uidmbox.cpp

@@ -61,6 +61,7 @@ UIDMBox::UIDMBox()
 	m_iBeginDecay = 0;
 	m_boxtime = uid.time;
 	m_movespeed = 500;
+	m_drawoutline = com_target_game->integer >= target_game_e::TG_MOHTA;
 }
 
 void UIDMBox::VerifyBoxOut( void )
@@ -278,6 +279,28 @@ float UIDMBox::PrintWrap( UIFont *font, float x, float y, str text )
 
 float UIDMBox::DrawItem( item_t *in, float x, float y, float alpha )
 {
+	if (m_drawoutline) {
+		//
+		// Draw an outline
+		//
+
+		in->font->setColor(UBlack);
+		in->font->setAlpha(alpha);
+
+		PrintWrap(in->font, x + 1, y + 2, in->string);
+		PrintWrap(in->font, x + 2, y + 1, in->string);
+		PrintWrap(in->font, x - 1, y + 2, in->string);
+		PrintWrap(in->font, x - 2, y + 1, in->string);
+		PrintWrap(in->font, x - 1, y - 2, in->string);
+		PrintWrap(in->font, x - 2, y - 1, in->string);
+		PrintWrap(in->font, x + 1, y - 2, in->string);
+		PrintWrap(in->font, x + 2, y - 1, in->string);
+		PrintWrap(in->font, x + 2, y, in->string);
+		PrintWrap(in->font, x - 2, y, in->string);
+		PrintWrap(in->font, x, y + 2, in->string);
+		PrintWrap(in->font, x, y - 2, in->string);
+	}
+
 	in->font->setColor(in->color);
 	in->font->setAlpha(alpha);
 
@@ -316,7 +339,11 @@ void UIDMBox::Print( const char *text )
 	}
 	else if (*text == MESSAGE_CHAT_GREEN)
 	{
-		m_items[m_numitems].color = UGreen;
+		if (com_target_game->integer >= TG_MOHTA) {
+			m_items[m_numitems].color = ULightGreen;
+		} else {
+			m_items[m_numitems].color = UGreen;
+		}
         m_items[m_numitems].font = m_fontbold;
         m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_DEATH;
 

code/client/cl_uidmbox.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2015-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,8 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIDMBOX_H__
-#define __CL_UIDMBOX_H__
+#pragma once
 
 static constexpr unsigned int DMBOX_ITEM_FLAG_BOLD = 2u;
 static constexpr unsigned int DMBOX_ITEM_FLAG_DEATH = 4u;
@@ -47,6 +46,8 @@ protected:
 	int m_movespeed;
 	int m_iBeginDecay;
 	int m_iEndDecay;
+	// Added in OPM
+	bool m_drawoutline;
 
 public:
 	CLASS_PROTOTYPE( UIDMBox );
@@ -75,5 +76,3 @@ public:
 	void		setRealShow( bool b );
 	void		Clear( void );
 };
-
-#endif /* __CL_UIDMBOX_H__ */

code/client/cl_uifilepicker.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -22,72 +22,256 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-CLASS_DECLARATION( USignal, FilePickerClass, NULL )
+class FilePickerItem : public UIListCtrlItem
 {
-	{ NULL, NULL }
+    str strings[3];
+
+public:
+    FilePickerItem(const str& fileName, const str& date, const str& size);
+    int            getListItemValue(int which) const override;
+    griditemtype_t getListItemType(int which) const override;
+    str            getListItemString(int which) const override;
+    void           DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) override;
+    qboolean       IsHeaderEntry() const override;
+};
+
+CLASS_DECLARATION(USignal, FilePickerClass, NULL) {
+    {&EV_UIListBase_ItemSelected,      &FilePickerClass::FileSelected },
+    {&EV_UIListBase_ItemDoubleClicked, &FilePickerClass::FileChosen   },
+    {&W_Deactivated,                   &FilePickerClass::OnDeactivated},
+    {NULL,                             NULL                           }
 };
 
 FilePickerClass::FilePickerClass()
 {
-	// FIXME: stub
+    window = new UIFloatingWindow();
+    window->Create(
+        NULL,
+        UIRect2D((cls.glconfig.vidWidth - 400) / 2, (cls.glconfig.vidHeight - 300) / 2, 400, 300),
+        "File Picker",
+        UColor(0.15f, 0.195f, 0.278f),
+        UHudColor
+    );
+    window->Connect(this, W_Deactivated, W_Deactivated);
+    listbox = new UIListCtrl();
+    listbox->InitFrame(window->getChildSpace(), window->getChildSpace()->getClientFrame(), 0);
+    listbox->setBackgroundColor(UColor(0.02f, 0.07f, 0.005f), true);
+    listbox->setForegroundColor(UHudColor);
+    listbox->AddColumn("File Name", 0, 175, false, false);
+    listbox->AddColumn("Date", 1, 125, false, false);
+    listbox->AddColumn("Size", 2, 100, true, false);
+
+    listbox->Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
+    listbox->Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
+    listbox->AllowActivate(true);
+
+    // Added in 2.0
+    //  Don't localize elements
+    listbox->SetDontLocalize();
 }
 
 FilePickerClass::~FilePickerClass()
 {
-	// FIXME: stub
+    if (listbox) {
+        delete listbox;
+        listbox = NULL;
+    }
+
+    if (window) {
+        delete window;
+        window = NULL;
+    }
 }
 
-void FilePickerClass::SetupFiles( void )
+void FilePickerClass::Setup(
+    const char *root_directory, const char *current_directory, const char *ext, const char *ignore_files
+)
 {
-	// FIXME: stub
+    Initialize(root_directory, current_directory, ext, ignore_files);
 }
 
-void FilePickerClass::GotoParentDirectory( void )
+void FilePickerClass::Initialize(
+    const char *root_directory, const char *current_directory, const char *ext, const char *ignore_files
+)
 {
-	// FIXME: stub
+    rootDirectory = root_directory;
+    if (rootDirectory.length() > 1 && rootDirectory[rootDirectory.length() - 1] != '/') {
+        rootDirectory += "/";
+    }
+
+    currentDirectory = current_directory;
+    if (currentDirectory.length() > 1 && currentDirectory[currentDirectory.length() - 1] != '/') {
+        currentDirectory += "/";
+    }
+
+    extension = ext;
+    if (ignore_files) {
+        ignoredFiles = ignore_files;
+    }
+
+    SetupFiles();
 }
 
-void FilePickerClass::GotoSubDirectory( str subdir )
+void FilePickerClass::GotoParentDirectory(void)
 {
-	// FIXME: stub
+    int i;
+
+    if (currentDirectory == rootDirectory) {
+        return;
+    }
+
+    for (i = currentDirectory.length() - 2; i > 0; i--) {
+        if (currentDirectory[i] == '/') {
+            break;
+        }
+    }
+
+    if (currentDirectory[i] == '/') {
+        i++;
+    }
+
+    currentDirectory = str(currentDirectory, 0, i);
+
+    // refresh files
+    SetupFiles();
 }
 
-void FilePickerClass::Initialize( const char *root_directory, const char *current_directory, const char *ext )
+void FilePickerClass::GotoSubDirectory(str subdir)
 {
-	// FIXME: stub
+    currentDirectory += subdir + "/";
+
+    // refresh files
+    SetupFiles();
 }
 
-void FilePickerClass::CloseWindow( void )
+void FilePickerClass::SetupFiles(void)
 {
-	// FIXME: stub
+    str    mappath;
+    str    work;
+    char **filenames;
+    int    numfiles;
+    int    i;
+    char   date[128];
+    char   size[128];
+
+    listbox->DeleteAllItems();
+
+    if (currentDirectory != rootDirectory) {
+        // create the parent directory item
+        listbox->AddItem(new FilePickerItem("..", "", ""));
+    }
+
+    // retrieve directories
+    filenames = FS_ListFiles(currentDirectory, "/", qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        const char *filename = filenames[i];
+
+        if (filename[0] == '.' || !strlen(filename)) {
+            continue;
+        }
+
+        work = "[";
+        work += filename;
+        work += "]";
+
+        FS_FileTime(currentDirectory + filename, date, size);
+
+        listbox->AddItem(new FilePickerItem(work, date, size));
+    }
+
+    FS_FreeFileList(filenames);
+
+    filenames = FS_ListFiles(currentDirectory, extension, qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        const char *filename = filenames[i];
+
+        if (ignoredFiles.length() && strstr(filename, ignoredFiles)) {
+            // Added in 2.0
+            //  Check for ignored files
+            continue;
+        }
+
+        work = filename;
+
+        FS_FileTime(currentDirectory + work, date, size);
+
+        listbox->AddItem(new FilePickerItem(work, date, size));
+    }
+
+    FS_FreeFileList(filenames);
+
+    window->setTitle(currentDirectory);
 }
 
-void FilePickerClass::FileSelected( Event *ev )
+void FilePickerClass::FileSelected(const str& currentDirectory, const str& partialName, const str& fullname) {}
+
+void FilePickerClass::FileSelected(Event *ev)
 {
-	// FIXME: stub
+    str name = listbox->GetItem(listbox->getCurrentItem())->getListItemString(0);
+
+    if (*name != '[' && *name != '.') {
+        FileSelected(currentDirectory, name, currentDirectory + name);
+    }
+
+    uii.Snd_PlaySound("sound/menu/scroll.wav");
 }
 
-void FilePickerClass::FileSelected( str &currentDirectory, str &partialName, str &fullname )
+void FilePickerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) {}
+
+void FilePickerClass::FileChosen(Event *ev)
 {
-	// FIXME: stub
+    str filename = listbox->GetItem(listbox->getCurrentItem())->getListItemString(0);
+
+    if (*filename == '[') {
+        uii.Snd_PlaySound("sound/menu/scroll.wav");
+
+        GotoSubDirectory(str(filename, 1, filename.length() - 1));
+    } else if (*filename == '.') {
+        GotoParentDirectory();
+    } else {
+        uii.Snd_PlaySound("sound/menu/apply.wav");
+
+        FileChosen(currentDirectory, filename, currentDirectory + filename);
+    }
 }
 
-void FilePickerClass::FileChosen( Event *ev )
+void FilePickerClass::CloseWindow(void)
 {
-	// FIXME: stub
+    PostEvent(EV_Remove, 0);
 }
 
-void FilePickerClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+void FilePickerClass::OnDeactivated(Event *ev)
 {
-	// FIXME: stub
+    CloseWindow();
 }
 
-void FilePickerClass::OnDeactivated( Event  *ev )
+FilePickerItem::FilePickerItem(const str& fileName, const str& date, const str& size)
 {
-	// FIXME: stub
+    strings[0] = fileName;
+    strings[1] = date;
+    strings[2] = size;
 }
 
-void FilePickerClass::Setup( const char *root_directory, const char *current_directory, const char *ext )
+int FilePickerItem::getListItemValue(int which) const
 {
-	// FIXME: stub
+    return atoi(strings[which]);
+}
+
+griditemtype_t FilePickerItem::getListItemType(int which) const
+{
+    return griditemtype_t::TYPE_STRING;
+}
+
+str FilePickerItem::getListItemString(int which) const
+{
+    return strings[which];
+}
+
+void FilePickerItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) {}
+
+qboolean FilePickerItem::IsHeaderEntry() const
+{
+    return qfalse;
 }

code/client/cl_uifilepicker.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,40 +20,41 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIFILEPICKER_H__
-#define __CL_UIFILEPICKER_H__
+#pragma once
 
 class UIListCtrl;
 
-class FilePickerClass : public USignal {
-	UIFloatingWindow *window;
-	UIListCtrl *listbox;
-	str currentDirectory;
-	str rootDirectory;
-	str extension;
+class FilePickerClass : public USignal
+{
+    UIFloatingWindow *window;
+    UIListCtrl       *listbox;
+    str               currentDirectory;
+    str               rootDirectory;
+    str               extension;
+    // Added in 2.0
+    str               ignoredFiles;
 
 public:
-	CLASS_PROTOTYPE( FilePickerClass );
+    CLASS_PROTOTYPE(FilePickerClass);
 
 private:
-	void		SetupFiles( void );
-	void		GotoParentDirectory( void );
-	void		GotoSubDirectory( str subdir );
-	void		Initialize( const char *root_directory, const char *current_directory, const char *ext );
+    void SetupFiles(void);
+    void GotoParentDirectory(void);
+    void GotoSubDirectory(str subdir);
+    // ignore_files parameter, added in 2.0
+    void Initialize(const char *root_directory, const char *current_directory, const char *ext, const char* ignore_files);
 
 protected:
-	void			CloseWindow( void );
-	void			FileSelected( Event *ev );
-	virtual void	FileSelected( str &currentDirectory, str &partialName, str &fullname );
-	void			FileChosen( Event *ev );
-	virtual void	FileChosen( str &currentDirectory, str &partialName, str &fullname );
-	void			OnDeactivated( Event  *ev );
+    void         CloseWindow(void);
+    void         FileSelected(Event *ev);
+    virtual void FileSelected(const str& currentDirectory, const str& partialName, const str& fullname);
+    void         FileChosen(Event *ev);
+    virtual void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname);
+    void         OnDeactivated(Event *ev);
 
 public:
-	FilePickerClass();
-	~FilePickerClass();
+    FilePickerClass();
+    ~FilePickerClass();
 
-	void Setup( const char *root_directory, const char *current_directory, const char *ext );
+    void Setup(const char *root_directory, const char *current_directory, const char *ext, const char* ignore_files = NULL);
 };
-
-#endif /* __CL_UIFILEPICKER_H__ */

code/client/cl_uigmbox.cpp

@@ -61,6 +61,7 @@ UIGMBox::UIGMBox()
 	m_iBeginDecay = 0;
 	m_boxtime = uid.time;
 	m_movespeed = 500;
+	m_drawoutline = com_target_game->integer >= target_game_e::TG_MOHTA;
 }
 
 void UIGMBox::VerifyBoxOut( void )
@@ -272,6 +273,28 @@ float UIGMBox::PrintWrap( UIFont *font, float x, float y, str text )
 
 float UIGMBox::DrawItem( item_t *in, float x, float y, float alpha )
 {
+	if (m_drawoutline) {
+		//
+		// Draw an outline
+		//
+
+		in->font->setColor(UBlack);
+		in->font->setAlpha(alpha);
+
+		PrintWrap(in->font, x + 1, y + 2, in->string);
+		PrintWrap(in->font, x + 2, y + 1, in->string);
+		PrintWrap(in->font, x - 1, y + 2, in->string);
+		PrintWrap(in->font, x - 2, y + 1, in->string);
+		PrintWrap(in->font, x - 1, y - 2, in->string);
+		PrintWrap(in->font, x - 2, y - 1, in->string);
+		PrintWrap(in->font, x + 1, y - 2, in->string);
+		PrintWrap(in->font, x + 2, y - 1, in->string);
+		PrintWrap(in->font, x + 2, y, in->string);
+		PrintWrap(in->font, x - 2, y, in->string);
+		PrintWrap(in->font, x, y + 2, in->string);
+		PrintWrap(in->font, x, y - 2, in->string);
+	}
+
 	in->font->setColor(in->color);
 	in->font->setAlpha(alpha);
 

code/client/cl_uigmbox.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2015-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,8 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIGMBOX_H__
-#define __CL_UIGMBOX_H__
+#pragma once
 
 static constexpr unsigned int GMBOX_ITEM_FLAG_BOLD = 1u;
 
@@ -44,6 +43,8 @@ protected:
 	int m_movespeed;
 	int m_iBeginDecay;
 	int m_iEndDecay;
+	// Added in OPM
+	bool m_drawoutline;
 
 public:
 	CLASS_PROTOTYPE( UIGMBox );
@@ -72,5 +73,3 @@ public:
 	void		setRealShow( bool b );
 	void		Clear( void );
 };
-
-#endif

code/client/cl_uilangame.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -21,44 +21,224 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "cl_ui.h"
+#include "../qcommon/localization.h"
 
-CLASS_DECLARATION( UIListCtrl, UILANGameClass, NULL )
+class LANGameItem : public UIListCtrlItem
 {
-	{ NULL, NULL }
+    str strings[6];
+
+public:
+    LANGameItem();
+    LANGameItem(
+        const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping, const str& ipAddress
+    );
+
+    int            getListItemValue(int which) const override;
+    griditemtype_t getListItemType(int which) const override;
+    str            getListItemString(int which) const override;
+    void           DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) override;
+    qboolean       IsHeaderEntry() const override;
+};
+
+Event EV_LANGame_JoinGame
+(
+    "joingame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Join the currently selected server"
+);
+
+CLASS_DECLARATION(UIListCtrl, UILANGameClass, NULL) {
+    {&EV_UIListBase_ItemSelected,      &UILANGameClass::SelectServer},
+    {&EV_UIListBase_ItemDoubleClicked, &UILANGameClass::JoinServer  },
+    {&EV_LANGame_JoinGame,             &UILANGameClass::JoinServer  },
+    {NULL,                             NULL                         }
 };
 
 UILANGameClass::UILANGameClass()
 {
-	// FIXME: stub
+    Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
+    Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
+    AllowActivate(true);
+    setHeaderFont("facfont-20");
+
+    m_iLastUpdateTime = 0;
+    m_noservers_mat   = uWinMan.RegisterShader("textures/menu/noservers");
+
+    //
+    // Added in OPM
+    //
+    m_bVirtual = false;
 }
 
-void UILANGameClass::SetupServers( void )
+void UILANGameClass::Draw(void)
 {
-	// FIXME: stub
+    if (cls.bNewLocalServerInfo) {
+        SetupServers();
+    }
+
+    UIListCtrl::Draw();
+
+    if (!getNumItems() && m_noservers_mat) {
+        float x, y, w, h;
+
+        w = re.GetShaderWidth(m_noservers_mat->GetMaterial()) * m_vVirtualScale[0];
+        h = re.GetShaderHeight(m_noservers_mat->GetMaterial()) * m_vVirtualScale[1];
+
+        UIRect2D frame = getClientFrame();
+        x              = (frame.size.width - w) * 0.5f;
+        y              = (frame.size.height - h) * 0.5f;
+
+        re.DrawStretchPic(x, y, w, h, 0, 0, 1, 1, m_noservers_mat->GetMaterial());
+    }
+
+    if (m_iLastUpdateTime && m_iLastUpdateTime < cls.realtime) {
+        Cvar_Set("cl_langamerefreshstatus", "Ready");
+        m_iLastUpdateTime = 0;
+    }
 }
 
-void UILANGameClass::Draw( void )
+void UILANGameClass::UpdateUIElement(void)
 {
-	// FIXME: stub
+    float width;
+
+    RemoveAllColumns();
+
+    width = getClientFrame().size.width - 16.f;
+
+    AddColumn(Sys_LV_CL_ConvertString("Server Name"), 0, width * 0.27f, false, false); // was 0.4
+    AddColumn(Sys_LV_CL_ConvertString("Map"), 1, width * 0.12f, false, false); // was 0.15
+    AddColumn(Sys_LV_CL_ConvertString("Players"), 2, width * 0.08f, true, true); // was 0.165
+    AddColumn(Sys_LV_CL_ConvertString("GameType"), 3, width * 0.118f, false, false); // was 0.22
+    AddColumn(Sys_LV_CL_ConvertString("Ping"), 4, width * 0.052f, true, false); // was 0.065
+    AddColumn(Sys_LV_CL_ConvertString("IP"), 5, width * 0.36f, false, false); // Added in OPM
+
+    uWinMan.ActivateControl(this);
+
+    SetupServers();
 }
 
-void UILANGameClass::SelectServer( Event *ev )
+void UILANGameClass::SetupServers(void)
 {
-	// FIXME: stub
+    int                 i;
+    LANGameItem        *pItem;
+    const serverInfo_t *pServerInfo;
+
+    for (i = 1; i <= cls.numlocalservers; i++) {
+        pServerInfo = &cls.localServers[i - 1];
+
+        if (i > getNumItems()) {
+            pItem = new LANGameItem();
+            AddItem(pItem);
+        } else {
+            pItem = static_cast<LANGameItem *>(GetItem(i));
+        }
+
+        *pItem = LANGameItem(
+            pServerInfo->hostName,
+            pServerInfo->mapName,
+            va("%02i/%02i", pServerInfo->clients, pServerInfo->maxClients),
+            pServerInfo->gameTypeString,
+            str(pServerInfo->ping),
+            // Added in OPM
+            NET_AdrToStringwPort(pServerInfo->adr)
+        );
+    }
+
+    while (cls.numlocalservers < getNumItems()) {
+        DeleteItem(getNumItems());
+    }
+
+    cls.bNewLocalServerInfo = false;
+    m_iLastUpdateTime       = 0;
 }
 
-void UILANGameClass::JoinServer( Event *ev )
+void UILANGameClass::SelectServer(Event *ev)
 {
-	// FIXME: stub
+    const serverInfo_t& serverInfo = cls.localServers[getCurrentItem() - 1];
+    static const char   info[]     = "\xFF\xFF\xFF\xFF\x02getinfo xxx";
+
+    Com_Printf("Requesting updated info from server...\n");
+    Cvar_Set("cl_langamerefreshstatus", "Requesting updated info from server...");
+
+    NET_SendPacket(NS_CLIENT, sizeof(info), info, serverInfo.adr);
+    m_iLastUpdateTime = cls.realtime + 3000;
 }
 
-qboolean UILANGameClass::KeyEvent( int key, unsigned int time )
+void UILANGameClass::JoinServer(Event *ev)
 {
-	// FIXME: stub
-	return qfalse;
+    if (!getCurrentItem()) {
+        return;
+    }
+
+    const serverInfo_t& serverInfo = cls.localServers[getCurrentItem() - 1];
+
+    UI_SetReturnMenuToCurrent();
+    CL_Connect(NET_AdrToStringwPort(serverInfo.adr), netadrtype_t::NA_UNSPEC);
 }
 
-void UILANGameClass::UpdateUIElement( void )
+qboolean UILANGameClass::KeyEvent(int key, unsigned int time)
 {
-	// FIXME: stub
+    switch (key) {
+    case K_ENTER:
+    case K_KP_ENTER:
+        JoinServer(NULL);
+        return true;
+    case K_UPARROW:
+        if (getCurrentItem() > 1) {
+            TrySelectItem(getCurrentItem() - 1);
+            SelectServer(NULL);
+        }
+        return false;
+    case K_DOWNARROW:
+        if (getCurrentItem() < getNumItems()) {
+            TrySelectItem(getCurrentItem() + 1);
+            SelectServer(NULL);
+        }
+        return false;
+    }
+
+    return UIListBase::KeyEvent(key, time);
+}
+
+LANGameItem::LANGameItem() {}
+
+LANGameItem::LANGameItem(
+    const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping, const str& ipAddress
+)
+{
+    strings[0] = hostName;
+    strings[1] = mapName;
+    strings[2] = players;
+    strings[3] = gameTypeString;
+    strings[4] = ping;
+
+    //
+    // Added in OPM
+    //
+
+    strings[5] = ipAddress;
+}
+
+int LANGameItem::getListItemValue(int which) const
+{
+    return atoi(strings[which]);
+}
+
+griditemtype_t LANGameItem::getListItemType(int which) const
+{
+    return griditemtype_t::TYPE_STRING;
+}
+
+str LANGameItem::getListItemString(int which) const
+{
+    return strings[which];
+}
+
+void LANGameItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) {}
+
+qboolean LANGameItem::IsHeaderEntry() const
+{
+    return qfalse;
 }

code/client/cl_uilangame.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,29 +20,27 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UILANGAME_H__
-#define __CL_UILANGAME_H__
+#pragma once
 
-class UILANGameClass : public UIListCtrl {
+class UILANGameClass : public UIListCtrl
+{
 protected:
-	int m_iLastUpdateTime;
-	UIReggedMaterial *m_noservers_mat;
+    int               m_iLastUpdateTime;
+    UIReggedMaterial *m_noservers_mat;
 
 public:
-	CLASS_PROTOTYPE( UILANGameClass );
+    CLASS_PROTOTYPE(UILANGameClass);
 
 private:
-	void		SetupServers( void );
+    void SetupServers(void);
 
 protected:
-	void		Draw( void ) override;
-	void		SelectServer( Event *ev );
-	void		JoinServer( Event *ev );
-	qboolean	KeyEvent( int key, unsigned int time ) override;
-	void		UpdateUIElement( void ) override;
+    void     Draw(void) override;
+    void     SelectServer(Event *ev);
+    void     JoinServer(Event *ev);
+    qboolean KeyEvent(int key, unsigned int time) override;
+    void     UpdateUIElement(void) override;
 
 public:
-	UILANGameClass();
+    UILANGameClass();
 };
-
-#endif /* __CL_UILANGAME_H__ */

code/client/cl_uiloadsave.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -21,63 +21,357 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "cl_ui.h"
+#include "../qcommon/localization.h"
 
-CLASS_DECLARATION( UIListCtrl, UIFAKKLoadGameClass, NULL )
+class FAKKLoadGameItem : public UIListCtrlItem
 {
-	{ NULL, NULL }
+    str strings[4];
+
+public:
+    FAKKLoadGameItem(const str& missionName, const str& elapsedTime, const str& dateTime, const str& fileName);
+
+    int            getListItemValue(int which) const override;
+    griditemtype_t getListItemType(int which) const override;
+    str            getListItemString(int which) const override;
+    void           DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) override;
+    qboolean       IsHeaderEntry() const override;
+};
+
+static UIFAKKLoadGameClass *loadgame_ui = NULL;
+
+Event EV_FAKKLoadGame_LoadGame
+(
+    "loadgame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Load the currently selected game"
+);
+Event EV_FAKKLoadGame_RemoveGame
+(
+    "removegame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Delete the currently selected game"
+);
+Event EV_FAKKLoadGame_DeleteGame
+(
+    "deletegame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Delete the currently selected game... for real"
+);
+Event EV_FAKKLoadGame_NoDeleteGame
+(
+    "nodeletegame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Delete the currently selected game... for real"
+);
+Event EV_FAKKLoadGame_SaveGame
+(
+    "savegame",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Save the currently selected game"
+);
+
+CLASS_DECLARATION(UIListCtrl, UIFAKKLoadGameClass, NULL) {
+    {&EV_UIListBase_ItemSelected,      &UIFAKKLoadGameClass::SelectGame  },
+    {&EV_UIListBase_ItemDoubleClicked, &UIFAKKLoadGameClass::LoadGame    },
+    {&EV_FAKKLoadGame_RemoveGame,      &UIFAKKLoadGameClass::RemoveGame  },
+    {&EV_FAKKLoadGame_DeleteGame,      &UIFAKKLoadGameClass::DeleteGame  },
+    {&EV_FAKKLoadGame_NoDeleteGame,    &UIFAKKLoadGameClass::NoDeleteGame},
+    {&EV_FAKKLoadGame_LoadGame,        &UIFAKKLoadGameClass::LoadGame    },
+    {&EV_FAKKLoadGame_SaveGame,        &UIFAKKLoadGameClass::SaveGame    },
+    {NULL,                             NULL                              }
 };
 
 UIFAKKLoadGameClass::UIFAKKLoadGameClass()
 {
-	// FIXME: stub
+    Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
+    Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
+    AllowActivate(true);
+    m_bRemovePending = false;
+
+    setHeaderFont("facfont-20");
+    loadgame_ui = this;
 }
 
-void UIFAKKLoadGameClass::SelectGame( Event *ev )
+UIFAKKLoadGameClass::~UIFAKKLoadGameClass()
 {
-	// FIXME: stub
+    loadgame_ui = NULL;
 }
 
-void UIFAKKLoadGameClass::LoadGame( Event *ev )
+void UIFAKKLoadGameClass::UpdateUIElement(void)
 {
-	// FIXME: stub
+    float width;
+
+    RemoveAllColumns();
+
+    width = getClientFrame().size.width;
+    AddColumn(Sys_LV_CL_ConvertString("Mission"), 0, width * 0.555, false, false);
+    AddColumn(Sys_LV_CL_ConvertString("Elapsed Time"), 1, width * 0.17f, true, true);
+    AddColumn(Sys_LV_CL_ConvertString("Date & Time Logged"), 2, width * 0.275f, true, true);
+
+    uWinMan.ActivateControl(this);
+
+    SetupFiles();
 }
 
-void UIFAKKLoadGameClass::SaveGame( Event *ev )
+void UIFAKKLoadGameClass::SetupFiles(void)
 {
-	// FIXME: stub
+    char      **filenames;
+    int         numfiles;
+    int         i;
+    const char *searchFolder = Com_GetArchiveFolder();
+
+    // cleanup
+    DeleteAllItems();
+
+    filenames = FS_ListFiles(searchFolder, "ssv", qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        const char      *filename;
+        str              work;
+        str              gametime;
+        str              date;
+        fileHandle_t     f;
+        savegamestruct_t save;
+
+        filename = filenames[i];
+        work     = searchFolder;
+        work += "/";
+        work += filename;
+
+        FS_FOpenFileRead(work, &f, qfalse, qtrue);
+        if (!f) {
+            continue;
+        }
+
+        FS_Read(&save, sizeof(savegamestruct_t), f);
+        FS_FCloseFile(f);
+        Com_SwapSaveStruct(&save);
+
+        if (save.version != SAVEGAME_STRUCT_VERSION) {
+            // wrong save game version
+            continue;
+        }
+
+        if (save.type != com_target_game->integer) {
+            continue;
+        }
+
+        gametime = (save.mapTime / 1000);
+        date     = save.time;
+
+        AddItem(new FAKKLoadGameItem(save.comment, gametime, date, save.saveName));
+    }
+
+    FS_FreeFileList(filenames);
+
+    // sort by date
+    SortByColumn(2);
+
+    // select the first item
+    TrySelectItem(1);
+    SelectGame(NULL);
 }
 
-void UIFAKKLoadGameClass::RemoveGame( Event *ev )
+void UIFAKKLoadGameClass::SelectGame(Event *ev)
 {
-	// FIXME: stub
+    UIWidget   *wid;
+    const char *shotName;
+
+    if (getCurrentItem() > 0) {
+        shotName = Com_GetArchiveFileName(GetItem(getCurrentItem())->getListItemString(3), "tga");
+    } else {
+        shotName = "textures/menu/no_saved_games.tga";
+    }
+
+    wid = findSibling("LoadSaveShot");
+    if (!wid) {
+        return;
+    }
+
+    wid->setMaterial(uWinMan.RefreshShader(shotName));
 }
 
-void UIFAKKLoadGameClass::DeleteGame( Event *ev )
+void UIFAKKLoadGameClass::RemoveGame(Event *ev)
 {
-	// FIXME: stub
+    if (m_bRemovePending || getCurrentItem() <= 0) {
+        return;
+    }
+
+    Cbuf_ExecuteText(
+        EXEC_NOW,
+        "dialog \"\" \"\" \"widgetcommand LoadSaveList deletegame\" \"widgetcommand LoadSaveList nodeletegame\" 256 64 "
+        "confirm_delete menu_button_trans menu_button_trans\n"
+    );
+    m_bRemovePending = true;
 }
 
-void UIFAKKLoadGameClass::NoDeleteGame( Event *ev )
+void UIFAKKLoadGameClass::NoDeleteGame(Event *ev)
 {
-	// FIXME: stub
+    m_bRemovePending = false;
 }
 
-qboolean UIFAKKLoadGameClass::KeyEvent( int key, unsigned int time )
+void UIFAKKLoadGameClass::DeleteGame(Event *ev)
 {
-	// FIXME: stub
-	return qfalse;
+    str     name;
+    cvar_t *var;
+    m_bRemovePending = false;
+
+    if (getCurrentItem() <= 0) {
+        return;
+    }
+
+    name = GetItem(getCurrentItem())->getListItemString(3);
+    var  = Cvar_Get("g_lastsave", "", 0);
+
+    if (!strcmp(name, var->string)) {
+        // Make sure the last save is not the save being deleted
+        Cvar_Set("g_lastsave", "");
+    }
+
+    Com_WipeSavegame(name);
+    SetupFiles();
 }
 
-void UIFAKKLoadGameClass::UpdateUIElement( void )
+void UIFAKKLoadGameClass::LoadGame(Event *ev)
 {
-	// FIXME: stub
+    char cmdString[266];
+    str  name;
+
+    if (getCurrentItem() <= 0) {
+        return;
+    }
+
+    name = GetItem(getCurrentItem())->getListItemString(3);
+    // Execute the command
+    Com_sprintf(cmdString, sizeof(cmdString), "loadgame %s\n", name.c_str());
+    Cbuf_AddText(cmdString);
 }
 
-void UIFAKKLoadGameClass::SetupFiles( void )
+void UIFAKKLoadGameClass::SaveGame(Event *ev)
 {
-	// FIXME: stub
+    Cbuf_ExecuteText(EXEC_NOW, "savegame");
 }
 
-void UI_SetupFiles( void ) {
-	// FIXME: stub
+qboolean UIFAKKLoadGameClass::KeyEvent(int key, unsigned int time)
+{
+    switch (key) {
+    case K_DEL:
+        RemoveGame(NULL);
+        return qtrue;
+    case K_ENTER:
+    case K_KP_ENTER:
+        LoadGame(NULL);
+        return qtrue;
+    case K_UPARROW:
+        if (getCurrentItem() > 1) {
+            TrySelectItem(getCurrentItem() - 1);
+            SelectGame(NULL);
+            return qtrue;
+        }
+        break;
+    case K_DOWNARROW:
+        if (getCurrentItem() < getNumItems()) {
+            TrySelectItem(getCurrentItem() + 1);
+            SelectGame(NULL);
+            return qtrue;
+        }
+        break;
+    default:
+        return UIListCtrl::KeyEvent(key, time);
+    }
+
+    return qfalse;
+}
+
+void UI_SetupFiles(void)
+{
+    if (loadgame_ui && loadgame_ui->getShow()) {
+        loadgame_ui->SetupFiles();
+    }
+}
+
+FAKKLoadGameItem::FAKKLoadGameItem(
+    const str& missionName, const str& elapsedTime, const str& dateTime, const str& fileName
+)
+{
+    strings[0] = missionName;
+    strings[1] = elapsedTime;
+    strings[2] = dateTime;
+    strings[3] = fileName;
+}
+
+int FAKKLoadGameItem::getListItemValue(int which) const
+{
+    return atoi(strings[which]);
+}
+
+griditemtype_t FAKKLoadGameItem::getListItemType(int which) const
+{
+    return griditemtype_t::TYPE_STRING;
+}
+
+str FAKKLoadGameItem::getListItemString(int which) const
+{
+    str itemstring;
+
+    switch (which) {
+    case 0:
+    case 3:
+        itemstring = strings[which];
+        break;
+    case 1:
+        {
+            int numseconds;
+            int numseconds_hours;
+
+            // hours
+            numseconds = atol(strings[1]);
+            itemstring += (numseconds / 3600);
+            itemstring += ":";
+
+            // minutes
+            numseconds_hours = numseconds % 3600;
+            if (numseconds_hours / 60 <= 9) {
+                itemstring += "0";
+            }
+            itemstring += (numseconds_hours / 60);
+            itemstring += ":";
+
+            // seconds
+            if (numseconds_hours / 60 <= 9) {
+                itemstring += "0";
+            }
+            itemstring += (numseconds_hours % 60);
+        }
+        break;
+    case 2:
+        {
+            time_t time;
+            char   buffer[2048];
+
+            time = atol(strings[2]);
+            strftime(buffer, sizeof(buffer), "%a %b %d %H:%M:%S %Y", localtime(&time));
+            itemstring = buffer;
+        }
+        break;
+    }
+
+    return itemstring;
+}
+
+void FAKKLoadGameItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) {}
+
+qboolean FAKKLoadGameItem::IsHeaderEntry() const
+{
+    return qfalse;
 }

code/client/cl_uiloadsave.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -22,23 +22,26 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #pragma once
 
-class UIFAKKLoadGameClass : public UIListCtrl { 
-	bool m_bRemovePending; 
+class UIFAKKLoadGameClass : public UIListCtrl
+{
+    bool m_bRemovePending;
 
 public:
-	CLASS_PROTOTYPE( UIFAKKLoadGameClass );
+    CLASS_PROTOTYPE(UIFAKKLoadGameClass);
 
 protected:
-	void		SelectGame( Event *ev );
-	void		LoadGame( Event *ev );
-	void		SaveGame( Event *ev );
-	void		RemoveGame( Event *ev );
-	void		DeleteGame( Event *ev );
-	void		NoDeleteGame( Event *ev );
-	qboolean	KeyEvent( int key, unsigned int time ) override;
-	void		UpdateUIElement( void ) override;
-public:
-	UIFAKKLoadGameClass();
+    void     SelectGame(Event *ev);
+    void     LoadGame(Event *ev);
+    void     SaveGame(Event *ev);
+    void     RemoveGame(Event *ev);
+    void     DeleteGame(Event *ev);
+    void     NoDeleteGame(Event *ev);
+    qboolean KeyEvent(int key, unsigned int time) override;
+    void     UpdateUIElement(void) override;
 
-	void	SetupFiles( void );
+public:
+    UIFAKKLoadGameClass();
+    ~UIFAKKLoadGameClass();
+
+    void SetupFiles(void);
 };

code/client/cl_uimaprotationsetup.cpp

@@ -0,0 +1,457 @@
+/*
+===========================================================================
+Copyright (C) 2023 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+#include "cl_ui.h"
+#include "cl_uimaprotationsetup.h"
+
+Event EV_MapListBox_RefreshMapList
+(
+    "RefreshMapList",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Refreshes the map list."
+);
+
+Event EV_MapRotationListBox_RefreshRotationList
+(
+    "RefreshRotationList",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Refreshed the map rotation list."
+);
+
+CLASS_DECLARATION(UIListBox, UIMapRotationListBox, NULL) {
+    {&EV_MapRotationListBox_RefreshRotationList, &UIMapRotationListBox::RefreshRotationList},
+    {NULL,                                       NULL                                      }
+};
+
+UIMapRotationListBox::UIMapRotationListBox() {}
+
+void UIMapRotationListBox::RefreshRotationList(Event *ev)
+{
+    DeleteAllItems();
+    PopulateRotationList();
+}
+
+void UIMapRotationListBox::PopulateRotationList()
+{
+    cvar_t     *filter;
+    cvar_t     *maplistVar;
+    const char *token;
+    char        mapBuffer[1024];
+
+    filter = Cvar_Get("g_maprotation_filter", "ffa", 0);
+    if (!Q_stricmp(filter->string, "obj")) {
+        maplistVar = Cvar_Get("ui_maplist_obj", "", 0);
+    } else if (!Q_stricmp(filter->string, "tow")) {
+        maplistVar = Cvar_Get("ui_maplist_tow", "", 0);
+    } else if (!Q_stricmp(filter->string, "lib")) {
+        maplistVar = Cvar_Get("ui_maplist_lib", "", 0);
+    } else if (!Q_stricmp(filter->string, "team")) {
+        maplistVar = Cvar_Get("ui_maplist_team", "", 0);
+    } else if (!Q_stricmp(filter->string, "round")) {
+        maplistVar = Cvar_Get("ui_maplist_round", "", 0);
+    } else {
+        maplistVar = Cvar_Get("ui_maplist_ffa", "", 0);
+    }
+
+    Q_strncpyz(mapBuffer, maplistVar->string, sizeof(mapBuffer));
+
+    for (token = strtok(mapBuffer, " /"); token; token = strtok(NULL, " /")) {
+        if (!Q_stricmp(token, "dm")) {
+            continue;
+        }
+        if (!Q_stricmp(token, "obj")) {
+            continue;
+        }
+        if (!Q_stricmp(token, "lib")) {
+            continue;
+        }
+
+        AddItem(token, NULL);
+    }
+}
+
+CLASS_DECLARATION(UIListBox, UIMapListBox, NULL) {
+    {&EV_MapListBox_RefreshMapList, &UIMapListBox::RefreshMapList},
+    {NULL,                          NULL                         }
+};
+
+UIMapListBox::UIMapListBox() {}
+
+void UIMapListBox::RefreshMapList(Event *ev)
+{
+    DeleteAllItems();
+    PopulateMapList();
+}
+
+void UIMapListBox::PopulateMapList()
+{
+    cvar_t *filter;
+    char  **filenames;
+    int     numfiles;
+    str     path;
+    int     i;
+    bool    bTugOfWar   = false;
+    bool    bObjective  = false;
+    bool    bLiberation = false;
+
+    filter = Cvar_Get("g_maprotation_filter", "ffa", 0);
+    if (!Q_stricmp(filter->string, "lib")) {
+        path        = "maps/lib/";
+        bLiberation = true;
+    } else if (!Q_stricmp(filter->string, "obj") || !Q_stricmp(filter->string, "tow")) {
+        path = "maps/obj/";
+        if (!Q_stricmp(filter->string, "tow")) {
+            bTugOfWar = true;
+        } else {
+            bObjective = true;
+        }
+    } else {
+        path = "maps/dm/";
+    }
+
+    filenames = FS_ListFiles(path, ".bsp", qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        const char *filename = filenames[i];
+        const char *token;
+        char        mapName[256];
+        char        tokenized[256];
+        bool        bHasMP  = false;
+        bool        bHasTOW = false;
+        bool        bHasLib = false;
+
+        Q_strncpyz(mapName, filename, sizeof(mapName));
+        mapName[strlen(mapName) - 4] = 0;
+
+        if (!COM_IsMapValid(mapName)) {
+            continue;
+        }
+
+        if (bTugOfWar || bLiberation) {
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
+
+            for (token = strtok(tokenized, "_"); token; token = strtok(NULL, "_")) {
+                if (bLiberation) {
+                    if (!Q_stricmp(token, "MP")) {
+                        bHasMP = true;
+                    }
+                    if (!Q_stricmp(token, "LIB")) {
+                        bHasLib = true;
+                    }
+                    if (bHasMP && bHasLib) {
+                        AddItem(mapName, NULL);
+                        break;
+                    }
+                }
+
+                if (bTugOfWar) {
+                    if (!Q_stricmp(token, "MP")) {
+                        bHasMP = true;
+                    }
+                    if (!Q_stricmp(token, "TOW")) {
+                        bHasTOW = true;
+                    }
+                    if (bHasMP && bHasTOW) {
+                        AddItem(mapName, NULL);
+                        break;
+                    }
+                }
+            }
+        } else if (bObjective) {
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
+
+            for (token = strtok(tokenized, "_"); token; token = strtok(NULL, "_")) {
+                if (!Q_stricmp(token, "obj")) {
+                    AddItem(mapName, NULL);
+                    break;
+                }
+            }
+
+            if (!Q_stricmp(mapName, "mp_ship_lib")) {
+                AddItem(mapName, NULL);
+            }
+        } else {
+            AddItem(mapName, NULL);
+        }
+    }
+
+    if (bObjective) {
+        path = "maps/lib/";
+
+        filenames = FS_ListFiles(path, ".bsp", qfalse, &numfiles);
+
+        for (i = 0; i < numfiles; i++) {
+            const char *filename = filenames[i];
+            const char *token;
+            char        mapName[256];
+            char        tokenized[256];
+
+            Q_strncpyz(mapName, filename, sizeof(mapName));
+            mapName[strlen(mapName) - 4] = 0;
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
+
+            token = strtok(tokenized, "_");
+            if (!Q_stricmp(token, "obj") || !Q_stricmp(mapName, "mp_ship_lib")) {
+                AddItem(mapName, NULL);
+                break;
+            }
+        }
+    }
+
+    if (!bTugOfWar && !bObjective && !bLiberation) {
+        int type;
+
+        for (type = 0; type < 2; type++) {
+            if (type == 0) {
+                path = "maps/obj/";
+            } else {
+                path = "maps/lib/";
+            }
+
+            filenames = FS_ListFiles(path, ".bsp", qfalse, &numfiles);
+
+            for (i = 0; i < numfiles; i++) {
+                const char *filename = filenames[i];
+                char        mapName[256];
+
+                Q_strncpyz(mapName, filename, sizeof(mapName));
+                mapName[strlen(mapName) - 4] = 0;
+
+                if (!COM_IsMapValid(mapName)) {
+                    continue;
+                }
+
+                if (!Q_stricmp(mapName, "obj_team2") || !Q_stricmp(mapName, "obj_team4")) {
+                    continue;
+                }
+
+                AddItem(mapName, NULL);
+            }
+        }
+    }
+}
+
+CLASS_DECLARATION(UIButton, UIAddToRotationButton, NULL) {
+    {&W_LeftMouseUp, &UIAddToRotationButton::Released},
+    {NULL,           NULL                            }
+};
+
+void UIAddToRotationButton::Released(Event *ev)
+{
+    UIListBox *mapList;
+    UIListBox *rotationList;
+    size_t     prefixLength;
+    int        i;
+
+    mapList      = static_cast<UIListBox *>(uWinMan.FindWidget("Map List"));
+    rotationList = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
+
+    if (Cvar_Get("g_maprotation_filter", "ffa", 0)) {
+        prefixLength = strlen("obj/") + 1;
+    } else {
+        prefixLength = 1;
+    }
+
+    if (mapList && rotationList) {
+        size_t mapLength = 0;
+        int item = mapList->getCurrentItem();
+        str currentItemText;
+        
+        if (item) {
+            currentItemText = mapList->getItemText(item);
+        }
+
+        for (i = 1; i <= rotationList->getNumItems(); i++) {
+            str text = rotationList->getItemText(i);
+            if (text == currentItemText) {
+                // Added in OPM
+                //  Prevent adding duplicates
+                item = 0;
+                break;
+            }
+
+            mapLength += text.length();
+        }
+
+        if (item && prefixLength + mapLength + currentItemText.length() < 256) {
+            rotationList->AddItem(currentItemText, NULL);
+        }
+    }
+
+    UIButtonBase::Released(ev);
+}
+
+CLASS_DECLARATION(UIButton, UIRemoveFromRotationButton, NULL) {
+    {&W_LeftMouseUp, &UIRemoveFromRotationButton::Released},
+    {NULL,           NULL                                 }
+};
+
+void UIRemoveFromRotationButton::Released(Event *ev)
+{
+    UIListBox *list;
+
+    list = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
+    if (list) {
+        list->DeleteItem(list->getCurrentItem());
+    }
+
+    UIButtonBase::Released(ev);
+}
+
+CLASS_DECLARATION(UIButton, UIRotationApplyButton, NULL) {
+    {&W_LeftMouseUp, &UIRotationApplyButton::Released},
+    {NULL,           NULL                            }
+};
+
+void UIRotationApplyButton::Released(Event *ev)
+{
+    UIListBox *list;
+    cvar_t    *filter;
+    str        cvarName;
+    str        maplistStr;
+    int        i;
+    bool       bObjective  = false;
+    bool       bLiberation = false;
+
+    filter = Cvar_Get("g_maprotation_filter", "ffa", 0);
+    if (!Q_stricmp(filter->string, "obj")) {
+        cvarName   = "ui_maplist_obj";
+        bObjective = true;
+    } else if (!Q_stricmp(filter->string, "tow")) {
+        cvarName   = "ui_maplist_obj";
+        bObjective = true;
+    } else if (!Q_stricmp(filter->string, "lib")) {
+        cvarName    = "ui_maplist_lib";
+        bLiberation = true;
+    } else if (!Q_stricmp(filter->string, "team")) {
+        cvarName = "ui_maplist_team";
+    } else if (!Q_stricmp(filter->string, "round")) {
+        cvarName = "ui_maplist_round";
+    } else {
+        cvarName = "ui_maplist_ffa";
+    }
+    Cvar_Set(cvarName, "");
+
+    list = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
+    if (list) {
+        for (i = 1; i <= list->getNumItems(); i++) {
+            const char *token;
+            str         text = list->getItemText(i);
+            char        map[256];
+            bool        bHasTOW = false, bHasObj = false, bHasLib = false, bHasShip = false;
+
+            Q_strncpyz(map, text, sizeof(map));
+            for (token = strtok(map, "_"); token; token = strtok(NULL, "_")) {
+                if (!Q_stricmp(token, "TOW")) {
+                    bHasTOW = true;
+                    break;
+                }
+                if (!Q_stricmp(token, "obj")) {
+                    bHasObj = true;
+                    break;
+                }
+                if (!Q_stricmp(token, "lib")) {
+                    bHasLib = true;
+                    break;
+                }
+                if (!Q_stricmp(token, "ship")) {
+                    bHasShip = true;
+                    break;
+                }
+            }
+
+            if (bHasShip) {
+                maplistStr += "lib/";
+            } else if (bObjective || bHasTOW || bHasObj) {
+                maplistStr += "obj/";
+            } else if (bHasLib || bLiberation) {
+                maplistStr += "lib/";
+            } else {
+                maplistStr += "dm/";
+            }
+
+            maplistStr += text;
+
+            if (i == 1) {
+                Cvar_Set("ui_dmmap", maplistStr);
+            }
+
+            maplistStr += " ";
+        }
+    }
+
+    Cvar_Set(cvarName, maplistStr);
+
+    UIButtonBase::Released(ev);
+}
+
+CLASS_DECLARATION(UIButton, UIRotationMoveItemUpButton, NULL) {
+    {&W_LeftMouseUp, &UIRotationMoveItemUpButton::Released},
+    {NULL,           NULL                                 }
+};
+
+void UIRotationMoveItemUpButton::Released(Event *ev)
+{
+    UIListBox *list;
+    int        item;
+
+    list = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
+    item = list->getCurrentItem();
+
+    if (item > 1 && list->getNumItems() > 1) {
+        str text = list->getItemText(item - 1);
+
+        list->DeleteItem(item - 1);
+        list->InsertItem(text, item);
+        list->setCurrentItem(item - 1);
+    }
+
+    UIButtonBase::Released(ev);
+}
+
+CLASS_DECLARATION(UIButton, UIRotationMoveItemDownButton, NULL) {
+    {&W_LeftMouseUp, &UIRotationMoveItemDownButton::Released},
+    {NULL,           NULL                                   }
+};
+
+void UIRotationMoveItemDownButton::Released(Event *ev)
+{
+    UIListBox *list;
+    int        item;
+
+    list = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
+    item = list->getCurrentItem();
+
+    if (item < list->getNumItems() && list->getNumItems() > 1) {
+        str text = list->getItemText(item + 1);
+
+        list->DeleteItem(item + 1);
+        list->InsertItem(text, item);
+        list->setCurrentItem(item + 1);
+    }
+
+    UIButtonBase::Released(ev);
+}

code/client/cl_uimaprotationsetup.h

@@ -0,0 +1,87 @@
+/*
+===========================================================================
+Copyright (C) 2023 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+#pragma once
+
+#include "../uilib/uilistbox.h"
+
+class UIMapRotationListBox : public UIListBox
+{
+    CLASS_PROTOTYPE(UIMapRotationListBox);
+
+public:
+    UIMapRotationListBox();
+
+    void RefreshRotationList(Event *ev);
+    void PopulateRotationList();
+};
+
+class UIMapListBox : public UIListBox
+{
+    CLASS_PROTOTYPE(UIMapListBox);
+
+public:
+    UIMapListBox();
+
+    void RefreshMapList(Event *ev);
+    void PopulateMapList();
+};
+
+class UIAddToRotationButton : public UIButton
+{
+    CLASS_PROTOTYPE(UIAddToRotationButton);
+
+public:
+    void Released(Event *ev);
+};
+
+class UIRemoveFromRotationButton : public UIButton
+{
+    CLASS_PROTOTYPE(UIRemoveFromRotationButton);
+
+public:
+    void Released(Event *ev);
+};
+
+class UIRotationApplyButton : public UIButton
+{
+    CLASS_PROTOTYPE(UIRotationApplyButton);
+
+public:
+    void Released(Event *ev);
+};
+
+class UIRotationMoveItemUpButton : public UIButton
+{
+    CLASS_PROTOTYPE(UIRotationMoveItemUpButton);
+
+public:
+    void Released(Event *ev);
+};
+
+class UIRotationMoveItemDownButton : public UIButton
+{
+    CLASS_PROTOTYPE(UIRotationMoveItemDownButton);
+
+public:
+    void Released(Event *ev);
+};

code/client/cl_uimaprunner.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -22,47 +22,107 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-CLASS_DECLARATION( FilePickerClass, MapRunnerClass, NULL )
-{
-	{ NULL, NULL }
+CLASS_DECLARATION(FilePickerClass, MapRunnerClass, NULL) {
+    {NULL, NULL}
 };
 
-void MapRunnerClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+void MapRunnerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-	// FIXME: stub
+    str newName;
+
+    newName = "spmap " + str(fullname, 5, fullname.length() - 4) + "\n";
+    // insert the command
+    Cbuf_AddText(newName);
+
+    CloseWindow();
 }
 
-CLASS_DECLARATION( FilePickerClass, ViewSpawnerClass, NULL )
-{
-	{ NULL, NULL }
+CLASS_DECLARATION(FilePickerClass, UIPickFileClass, NULL) {
+    {NULL, NULL}
 };
 
-void ViewSpawnerClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+UIPickFileClass::UIPickFileClass()
 {
-	// FIXME: stub
+    retobj   = NULL;
+    retevent = NULL;
 }
 
-CLASS_DECLARATION( FilePickerClass, LODSpawnerClass, NULL )
+UIPickFileClass::~UIPickFileClass()
 {
-	{ NULL, NULL }
+    if (retevent) {
+        delete retevent;
+    }
+}
+
+void UIPickFileClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
+{
+    if (!retobj || !retevent) {
+        CloseWindow();
+        return;
+    }
+
+    retevent->AddString(fullname);
+    retobj->ProcessEvent(retevent);
+
+    retevent = NULL;
+    retobj   = NULL;
+
+    CloseWindow();
+}
+
+void PickFile(const char *name, Listener *obj, Event& event)
+{
+    UIPickFileClass *picker;
+    str              currentpath;
+    int              i;
+
+    picker           = new UIPickFileClass();
+    picker->retevent = new Event(event);
+    picker->retobj   = obj;
+
+    if (name && *name && strchr(name, '/')) {
+        currentpath = name;
+
+        for (i = currentpath.length() - 1; i > 0; i--) {
+            if (currentpath[i] == '/') {
+                break;
+            }
+        }
+
+        currentpath = str(currentpath, 0, i + 1);
+    } else {
+        currentpath = "";
+    }
+
+    picker->Setup("", currentpath, ".*", "");
+}
+
+CLASS_DECLARATION(FilePickerClass, ViewSpawnerClass, NULL) {
+    {NULL, NULL}
 };
 
-void LODSpawnerClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+void ViewSpawnerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-	// FIXME: stub
+    str newName;
+
+    newName = "viewspawn " + fullname + "\n";
+    // insert the command
+    Cbuf_AddText(newName);
+
+    CloseWindow();
 }
 
-CLASS_DECLARATION( FilePickerClass, UIPickFileClass, NULL )
-{
-	{ NULL, NULL }
+CLASS_DECLARATION(FilePickerClass, LODSpawnerClass, NULL) {
+    {NULL, NULL}
 };
 
-void UIPickFileClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+void LODSpawnerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-	// FIXME: stub
-}
+    str newName;
 
-void PickFile( const char *name, Listener *obj, Event& event  )
-{
-	// FIXME: stub
+    newName = "lod_spawn " + fullname + "\n";
+    // insert the command
+    Cbuf_AddText(newName);
+
+    CloseWindow();
 }

code/client/cl_uimaprunner.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,40 +20,44 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIMAPRUNNER_H__
-#define __CL_UIMAPRUNNER_H__
+#pragma once
 
-class MapRunnerClass : public FilePickerClass {
+class MapRunnerClass : public FilePickerClass
+{
 public:
-	CLASS_PROTOTYPE( MapRunnerClass );
+    CLASS_PROTOTYPE(MapRunnerClass);
 
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
+    void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) override;
 };
 
-class ViewSpawnerClass : public FilePickerClass {
+class ViewSpawnerClass : public FilePickerClass
+{
 public:
-	CLASS_PROTOTYPE( ViewSpawnerClass );
+    CLASS_PROTOTYPE(ViewSpawnerClass);
 
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
+    void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) override;
 };
 
-class LODSpawnerClass : public FilePickerClass {
+class LODSpawnerClass : public FilePickerClass
+{
 public:
-	CLASS_PROTOTYPE( LODSpawnerClass );
+    CLASS_PROTOTYPE(LODSpawnerClass);
 
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
+    void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) override;
 };
 
-class UIPickFileClass : public FilePickerClass {
+class UIPickFileClass : public FilePickerClass
+{
 public:
-	Listener *retobj;
-	Event *retevent;
+    Listener *retobj;
+    Event    *retevent;
 
-	CLASS_PROTOTYPE( UIPickFileClass );
+    CLASS_PROTOTYPE(UIPickFileClass);
 
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
+    UIPickFileClass();
+    ~UIPickFileClass();
+
+    void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) override;
 };
 
-void PickFile( const char *name, Listener *obj, Event& event );
-
-#endif /* __CL_UIMAPRUNNER_H__ */
+void PickFile(const char *name, Listener *obj, Event& event);

code/client/cl_uiminicon.cpp

@@ -22,68 +22,179 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-CLASS_DECLARATION( UIWidget, FakkMiniconsole, NULL )
-{
-	{ NULL, NULL }
+Event EV_Minicon_Goin("_minicon_goin", EV_DEFAULT, NULL, NULL, "Event to make the miniconsole disappear");
+
+CLASS_DECLARATION(UIWidget, FakkMiniconsole, NULL) {
+    {&W_SizeChanged,   &FakkMiniconsole::OnSizeChanged},
+    {&EV_Minicon_Goin, &FakkMiniconsole::MoveInEvent  },
+    {NULL,             NULL                           }
 };
 
 FakkMiniconsole::FakkMiniconsole()
 {
-	// FIXME: stub
+    m_maxlines    = 0;
+    m_reallyshown = true;
+    m_boxstate    = boxstate_t::box_in;
+    m_boxtime     = uid.time;
+    m_movespeed   = 500;
 }
 
-
-void FakkMiniconsole::VerifyBoxOut( void )
+void FakkMiniconsole::setShowState(void)
 {
-	// FIXME: stub
+    if (m_reallyshown) {
+        setShow(m_boxstate != boxstate_t::box_in);
+    } else {
+        setShow(false);
+    }
 }
 
-void FakkMiniconsole::ChangeBoxState( boxstate_t state )
+void FakkMiniconsole::setRealShow(bool b)
 {
-	// FIXME: stub
+    m_reallyshown = b;
+    setShowState();
 }
 
-void FakkMiniconsole::HandleBoxMoving( void )
+void FakkMiniconsole::VerifyBoxOut(void)
 {
-	// FIXME: stub
+    PostMoveinEvent();
+
+    if (m_boxstate && m_boxstate != boxstate_t::box_out) {
+        ChangeBoxState(box_moving_out);
+    }
 }
 
-void FakkMiniconsole::PostMoveinEvent( void )
+void FakkMiniconsole::Print(const char *text)
 {
-	// FIXME: stub
+    str        *lastline;
+    const char *p;
+
+    if (!m_lines.NumObjects()) {
+        m_lines.AddObject({});
+    }
+
+    lastline = &m_lines.ObjectAt(m_lines.NumObjects());
+
+    if (*text) {
+        for (p = text; *p; p++) {
+            if (*p != '\n') {
+                *lastline += *p;
+            } else {
+                m_lines.AddObject({});
+                lastline = &m_lines.ObjectAt(m_lines.NumObjects());
+            }
+        }
+    }
+
+    if (lastline && lastline->length() > 128) {
+        Print("\n");
+    }
+
+    if (m_maxlines < 0) {
+        m_maxlines = 1;
+    }
+
+    while (m_lines.NumObjects() > this->m_maxlines) {
+        m_lines.RemoveObjectAt(1);
+    }
+
+    VerifyBoxOut();
 }
 
-void FakkMiniconsole::setShowState( void )
+void FakkMiniconsole::PostMoveinEvent(void)
 {
-	// FIXME: stub
+    if (m_boxstate != boxstate_t::box_out) {
+        return;
+    }
+
+    CancelEventsOfType(EV_Minicon_Goin);
+    PostEvent(new Event(EV_Minicon_Goin), 5.f);
 }
 
-void FakkMiniconsole::OnSizeChanged( Event *ev )
+void FakkMiniconsole::OnSizeChanged(Event *ev)
 {
-	// FIXME: stub
+    m_maxlines = m_frame.size.height / m_font->getHeight(false);
 }
 
-void FakkMiniconsole::Print( const char *text )
+void FakkMiniconsole::MoveInEvent(Event *ev)
 {
-	// FIXME: stub
+    ChangeBoxState(boxstate_t::box_moving_in);
 }
 
-void FakkMiniconsole::Create( const UISize2D& size, const UColor& fore, const UColor& back, float alpha )
+void FakkMiniconsole::HandleBoxMoving(void)
 {
-	// FIXME: stub
+    int      delta;
+    UIRect2D newRect;
+
+    if (m_boxstate == boxstate_t::box_out || m_boxstate == boxstate_t::box_in) {
+        return;
+    }
+
+    delta     = m_movespeed * (uid.time - m_boxtime) / 1000;
+    m_boxtime = 1000 * delta / m_movespeed + m_boxtime;
+
+    switch (m_boxstate) {
+    case boxstate_t::box_moving_in:
+        newRect = UIRect2D(delta + m_frame.pos.x, m_frame.pos.y, m_frame.size.width, m_frame.size.height);
+        if (newRect.pos.x >= uid.vidWidth) {
+            newRect.pos.x = uid.vidWidth;
+            ChangeBoxState(boxstate_t::box_in);
+        }
+        break;
+    case boxstate_t::box_moving_out:
+        newRect = UIRect2D(-delta + m_frame.pos.x, m_frame.pos.y, m_frame.size.width, m_frame.size.height);
+        if (newRect.pos.x <= uid.vidWidth - newRect.size.width) {
+            newRect.pos.x = uid.vidWidth - newRect.size.width;
+            ChangeBoxState(boxstate_t::box_out);
+        }
+        break;
+    default:
+        ChangeBoxState(boxstate_t::box_in);
+        break;
+    }
+
+    setFrame(newRect);
 }
 
-void FakkMiniconsole::MoveInEvent( Event *ev )
+void FakkMiniconsole::Draw(void)
 {
-	// FIXME: stub
+    float aty;
+    int   i;
+
+    HandleBoxMoving();
+
+    m_font->setColor(m_foreground_color);
+    aty = m_frame.size.height - m_font->getHeight(false);
+    for (i = m_lines.NumObjects(); i > 0; i--) {
+        if (-m_font->getHeight(false) >= aty) {
+            break;
+        }
+
+        m_font->Print(0, aty, m_lines.ObjectAt(i), -1, false);
+        aty -= m_font->getHeight(false);
+    }
 }
 
-void FakkMiniconsole::Draw( void )
+void FakkMiniconsole::Create(const UISize2D& size, const UColor& fore, const UColor& back, float alpha)
 {
-	// FIXME: stub
+    InitFrame(NULL, uid.vidWidth, 0, size.width, size.height, 0);
+
+    setBackgroundColor(back, true);
+    setForegroundColor(fore);
+    setBackgroundAlpha(alpha);
+    Connect(this, W_SizeChanged, W_SizeChanged);
+    OnSizeChanged(NULL);
+
+    m_movespeed = size.width * 3;
+
+    setShowState();
 }
 
-void FakkMiniconsole::setRealShow( bool b )
+void FakkMiniconsole::ChangeBoxState(boxstate_t state)
 {
-	// FIXME: stub
+    m_boxstate = state;
+    m_boxtime  = uid.time;
+    setShowState();
+    if (state == boxstate_t::box_out) {
+        PostMoveinEvent();
+    }
 }

code/client/cl_uiminicon.h

@@ -20,38 +20,36 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIMINICON_H__
-#define __CL_UIMINICON_H__
+#pragma once
 
-class FakkMiniconsole : public UIWidget {
+class FakkMiniconsole : public UIWidget
+{
 protected:
-	Container<str> m_lines;
-	int m_maxlines;
-	bool m_reallyshown;
-	bool m_boxmovingout;
-	boxstate_t m_boxstate;
-	int m_boxtime;
-	int m_movespeed;
+    Container<str> m_lines;
+    int            m_maxlines;
+    bool           m_reallyshown;
+    bool           m_boxmovingout;
+    boxstate_t     m_boxstate;
+    int            m_boxtime;
+    int            m_movespeed;
 
 public:
-	CLASS_PROTOTYPE( FakkMiniconsole );
+    CLASS_PROTOTYPE(FakkMiniconsole);
 
 protected:
-	void		VerifyBoxOut( void );
-	void		ChangeBoxState( boxstate_t state );
-	void		HandleBoxMoving( void );
-	void		PostMoveinEvent( void );
-	void		setShowState( void );
+    void VerifyBoxOut(void);
+    void ChangeBoxState(boxstate_t state);
+    void HandleBoxMoving(void);
+    void PostMoveinEvent(void);
+    void setShowState(void);
 
 public:
-	FakkMiniconsole();
+    FakkMiniconsole();
 
-	void			OnSizeChanged( Event *ev );
-	void			Print( const char *text );
-	void			Create( const UISize2D& size, const UColor& fore, const UColor& back, float alpha );
-	void			MoveInEvent( Event *ev );
-	void			Draw( void ) override;
-	void			setRealShow( bool b );
+    void OnSizeChanged(Event *ev);
+    void Print(const char *text);
+    void Create(const UISize2D& size, const UColor& fore, const UColor& back, float alpha);
+    void MoveInEvent(Event *ev);
+    void Draw(void) override;
+    void setRealShow(bool b);
 };
-
-#endif

code/client/cl_uimpmappicker.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -21,73 +21,339 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "cl_ui.h"
+#include "../qcommon/localization.h"
 
-CLASS_DECLARATION( USignal, MpMapPickerClass, NULL )
+class MpMapPickerItem : public UIListCtrlItem
 {
-	{ NULL, NULL }
+    str m_string;
+    // Added in 2.0
+    str m_directory;
+
+public:
+    MpMapPickerItem(const str& string, const str& directory);
+
+    int            getListItemValue(int which) const override;
+    griditemtype_t getListItemType(int which) const override;
+    str            getListItemString(int which) const override;
+    void           DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) override;
+    qboolean       IsHeaderEntry() const override;
+};
+
+CLASS_DECLARATION(USignal, MpMapPickerClass, NULL) {
+    {&EV_UIListBase_ItemSelected,      &MpMapPickerClass::FileSelected },
+    {&EV_UIListBase_ItemDoubleClicked, &MpMapPickerClass::FileChosen   },
+    {&W_Deactivated,                   &MpMapPickerClass::OnDeactivated},
+    {NULL,                             NULL                            }
 };
 
 MpMapPickerClass::MpMapPickerClass()
 {
-	// FIXME: stub
+    window = new UIFloatingWindow();
+    window->Create(
+        NULL,
+        UIRect2D((cls.glconfig.vidWidth - 300) / 2, (cls.glconfig.vidHeight - 200) / 2, 300, 200),
+        "Select a Map",
+        UColor(0.15f, 0.195f, 0.278f),
+        UHudColor
+    );
+    window->setFont("facfont-20");
+    window->PassEventToWidget("closebutton", new Event(EV_Widget_Disable));
+    window->PassEventToWidget("minimizebutton", new Event(EV_Widget_Disable));
+    window->Connect(this, W_Deactivated, W_Deactivated);
+
+    listbox = new UIListCtrl();
+    listbox->InitFrame(window->getChildSpace(), window->getChildSpace()->getClientFrame(), 0);
+    listbox->SetDrawHeader(false);
+    listbox->setFont("facfont-20");
+    listbox->FrameInitialized();
+    listbox->AddColumn(Sys_LV_CL_ConvertString("Select a Map"), 0, 400, false, false);
+
+    listbox->Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
+    listbox->Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
+    listbox->AllowActivate(true);
+
+    // Added in 2.0
+    //  Don't localize elements
+    listbox->SetDontLocalize();
 }
 
 MpMapPickerClass::~MpMapPickerClass()
 {
-	// FIXME: stub
+    if (listbox) {
+        delete listbox;
+        listbox = NULL;
+    }
+
+    if (window) {
+        delete window;
+        window = NULL;
+    }
 }
 
-void MpMapPickerClass::SetupFiles( void )
+void MpMapPickerClass::Setup(const char *root_directory, const char *current_directory, const char *game_type)
 {
-	// FIXME: stub
+    Initialize(root_directory, current_directory, game_type);
 }
 
-void MpMapPickerClass::GotoParentDirectory( void )
+void MpMapPickerClass::Initialize(const char *root_directory, const char *current_directory, const char *game_type)
 {
-	// FIXME: stub
+    rootDirectory = root_directory;
+    if (rootDirectory.length() > 1 && rootDirectory[rootDirectory.length() - 1] != '/') {
+        rootDirectory += "/";
+    }
+
+    currentDirectory = current_directory;
+    if (currentDirectory.length() > 1 && currentDirectory[currentDirectory.length() - 1] != '/') {
+        currentDirectory += "/";
+    }
+
+    if (game_type) {
+        gameType = game_type;
+    }
+
+    SetupFiles();
 }
 
-void MpMapPickerClass::GotoSubDirectory( str subdir )
+void MpMapPickerClass::GotoParentDirectory(void)
 {
-	// FIXME: stub
+    uintptr_t i;
+
+    if (currentDirectory == rootDirectory) {
+        return;
+    }
+
+    for (i = currentDirectory.length() - 2; i > 0; i--) {
+        if (currentDirectory[i] == '/') {
+            break;
+        }
+    }
+
+    if (currentDirectory[i] == '/') {
+        i++;
+    }
+
+    currentDirectory = str(currentDirectory, 0, i);
+
+    // refresh files
+    SetupFiles();
 }
 
-void MpMapPickerClass::Initialize( const char *root_directory, const char *current_directory )
+void MpMapPickerClass::GotoSubDirectory(str subdir)
 {
-	// FIXME: stub
+    currentDirectory += subdir + "/";
+
+    // refresh files
+    SetupFiles();
 }
 
-void MpMapPickerClass::CloseWindow( void )
+void MpMapPickerClass::SetupFiles(void)
 {
-	// FIXME: stub
+    char **filenames;
+    int    numfiles;
+    int    i;
+    char   mapname[128];
+    bool   bTugOfWar = false, bObjective = false, bLiberation = false;
+
+    listbox->DeleteAllItems();
+
+    if (gameType == "tow") {
+        bTugOfWar = true;
+    } else if (gameType == "obj") {
+        bObjective = true;
+    } else if (gameType == "lib") {
+        bLiberation = true;
+    } else {
+        // retrieve directories
+        filenames = FS_ListFiles(rootDirectory, ".bsp", qfalse, &numfiles);
+
+        for (i = 0; i < numfiles; i++) {
+            const char *filename = filenames[i];
+
+            strcpy(mapname, filename);
+            mapname[strlen(mapname) - 4] = 0;
+
+            if (COM_IsMapValid(mapname)) {
+                listbox->AddItem(new MpMapPickerItem(mapname, rootDirectory));
+            }
+        }
+
+        FS_FreeFileList(filenames);
+    }
+
+    if (com_target_game->integer > target_game_e::TG_MOH) {
+        if (currentDirectory.length()) {
+            if (currentDirectory == "maps/-/") {
+                SetupSecondaryFiles(currentDirectory, bTugOfWar, bObjective, bLiberation);
+            } else {
+                SetupSecondaryFiles("maps/obj/", bTugOfWar, bObjective, bLiberation);
+                SetupSecondaryFiles("maps/lib/", bTugOfWar, bObjective, bLiberation);
+            }
+        }
+    }
+
+    listbox->SortByColumn(0);
 }
 
-void MpMapPickerClass::FileSelected( Event *ev )
+void MpMapPickerClass::SetupSecondaryFiles(const char *path, bool bTugOfWar, bool bObjective, bool bLiberation)
 {
-	// FIXME: stub
+    char **filenames;
+    int    numfiles;
+    int    i;
+    char   mapname[128];
+    char   string[1024];
+
+    filenames = FS_ListFiles(path, ".bsp", qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        const char *filename = filenames[i];
+        const char *token;
+
+        strcpy(mapname, filename);
+        mapname[strlen(mapname) - 4] = 0;
+
+        if (!COM_IsMapValid(mapname)) {
+            continue;
+        }
+
+        if (bTugOfWar || bObjective || bLiberation) {
+            bool bHasMP = false, bHasTOW = false, bHasLib = false;
+
+            strcpy(string, mapname);
+
+            for (token = strtok(string, "_"); token; token = strtok(NULL, "_")) {
+                if (bObjective) {
+                    if (!Q_stricmp(token, "obj")) {
+                        listbox->AddItem(new MpMapPickerItem(mapname, path));
+                    } else if (!Q_stricmp(token, "ship")) {
+                        listbox->AddItem(new MpMapPickerItem(mapname, path));
+                    }
+                }
+
+                if (bTugOfWar) {
+                    if (!Q_stricmp(token, "MP")) {
+                        bHasMP = true;
+                    }
+                    if (!Q_stricmp(token, "TOW")) {
+                        bHasTOW = true;
+                    }
+
+                    if (bHasMP && bHasTOW) {
+                        listbox->AddItem(new MpMapPickerItem(mapname, path));
+                    }
+                }
+
+                if (bLiberation) {
+                    if (!Q_stricmp(token, "MP")) {
+                        bHasMP = true;
+                    }
+                    if (!Q_stricmp(token, "LIB")) {
+                        bHasLib = true;
+                    }
+
+                    if (bHasMP && bHasLib) {
+                        listbox->AddItem(new MpMapPickerItem(mapname, path));
+                    }
+                }
+            }
+        } else {
+            if (!Q_stricmp(mapname, "obj_team2") || !Q_stricmp(mapname, "obj_team4")) {
+                continue;
+            }
+
+            listbox->AddItem(new MpMapPickerItem(mapname, path));
+        }
+    }
+
+    FS_FreeFileList(filenames);
 }
 
-void MpMapPickerClass::FileSelected( str& currentDirectory, str& partialName, str& fullname )
+void MpMapPickerClass::FileSelected(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-	// FIXME: stub
+    FileChosen(currentDirectory, partialName, fullname);
 }
 
-void MpMapPickerClass::FileChosen( Event *ev )
+void MpMapPickerClass::FileSelected(Event *ev)
 {
-	// FIXME: stub
+    if (!listbox->getCurrentItem()) {
+        return;
+    }
+
+    uii.Snd_PlaySound("sound/menu/apply.wav");
+
+    UIListCtrlItem *item      = listbox->GetItem(listbox->getCurrentItem());
+    str             name      = item->getListItemString(0);
+    str             directory = item->getListItemString(1);
+
+    FileSelected(directory, name, directory + name);
 }
 
-void MpMapPickerClass::FileChosen( str& currentDirectory, str& partialName, str& fullname )
+void MpMapPickerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-	// FIXME: stub
+    const char *pszFilename;
+    str         sCommand;
+
+    pszFilename = fullname.c_str();
+    sCommand    = va("ui_dmmap %s\n", pszFilename + 5);
+
+    Cbuf_AddText(sCommand);
+    CloseWindow();
 }
 
-void MpMapPickerClass::OnDeactivated( Event *ev )
+void MpMapPickerClass::FileChosen(Event *ev)
 {
-	// FIXME: stub
+    if (!listbox->getCurrentItem()) {
+        return;
+    }
+
+    uii.Snd_PlaySound("sound/menu/apply.wav");
+
+    UIListCtrlItem *item      = listbox->GetItem(listbox->getCurrentItem());
+    str             name      = item->getListItemString(0);
+    str             directory = item->getListItemString(1);
+
+    FileSelected(directory, name, directory + name);
 }
 
-void MpMapPickerClass::Setup( const char *root_directory, const char *current_directory )
+void MpMapPickerClass::CloseWindow(void)
 {
-	// FIXME: stub
+    PostEvent(EV_Remove, 0);
+}
+
+void MpMapPickerClass::OnDeactivated(Event *ev)
+{
+    CloseWindow();
+}
+
+MpMapPickerItem::MpMapPickerItem(const str& string, const str& directory)
+{
+    m_string    = string;
+    m_directory = directory;
+}
+
+int MpMapPickerItem::getListItemValue(int which) const
+{
+    return atoi(m_string);
+}
+
+griditemtype_t MpMapPickerItem::getListItemType(int which) const
+{
+    return griditemtype_t::TYPE_STRING;
+}
+
+str MpMapPickerItem::getListItemString(int which) const
+{
+    switch (which) {
+    default:
+    case 0:
+        return m_string;
+    case 1:
+        return m_directory;
+    }
+}
+
+void MpMapPickerItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) {}
+
+qboolean MpMapPickerItem::IsHeaderEntry() const
+{
+    return qfalse;
 }

code/client/cl_uimpmappicker.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,39 +20,40 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIMPMAPPICKER_H__
-#define __CL_UIMPMAPPICKER_H__
+#pragma once
 
 class UIFloatingWindow;
 
-class MpMapPickerClass : public USignal {
-	UIFloatingWindow *window;
-	UIListCtrl *listbox;
-	str currentDirectory;
-	str rootDirectory;
+class MpMapPickerClass : public USignal
+{
+    UIFloatingWindow *window;
+    UIListCtrl       *listbox;
+    str               currentDirectory;
+    str               rootDirectory;
+    str               gameType;
 
 public:
-	CLASS_PROTOTYPE( MpMapPickerClass );
+    CLASS_PROTOTYPE(MpMapPickerClass);
 
 private:
-	void		SetupFiles( void );
-	void		GotoParentDirectory( void );
-	void		GotoSubDirectory( str subdir );
-	void		Initialize( const char *root_directory, const char *current_directory );
+    void SetupFiles(void);
+    void SetupSecondaryFiles(const char *path, bool bTugOfWar, bool bObjective, bool bLiberation);
+    void GotoParentDirectory(void);
+    void GotoSubDirectory(str subdir);
+    void Initialize(const char *root_directory, const char *current_directory, const char *game_type);
 
 protected:
-	void			CloseWindow( void );
-	void			FileSelected( Event *ev );
-	virtual void	FileSelected( str& currentDirectory, str& partialName, str& fullname );
-	void			FileChosen( Event *ev );
-	virtual void	FileChosen( str& currentDirectory, str& partialName, str& fullname );
-	void			OnDeactivated( Event *ev );
+    void         CloseWindow(void);
+    void         FileSelected(Event *ev);
+    virtual void FileSelected(const str& currentDirectory, const str& partialName, const str& fullname);
+    void         FileChosen(Event *ev);
+    virtual void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname);
+    void         OnDeactivated(Event *ev);
 
 public:
-	MpMapPickerClass();
-	~MpMapPickerClass();
+    MpMapPickerClass();
+    ~MpMapPickerClass();
 
-	void		Setup( const char *root_directory, const char *current_directory );
+    // game_type was added in 2.0
+    void Setup(const char *root_directory, const char *current_directory, const char *game_type = NULL);
 };
-
-#endif /* __CL_UIMPMAPPICKER_H__ */

code/client/cl_uiplayermodelpicker.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -22,62 +22,361 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-CLASS_DECLARATION( USignal, PlayerModelPickerClass, NULL )
+class PMPickerItem : public UIListCtrlItem
 {
-	{ NULL, NULL }
+    str m_string;
+
+public:
+    PMPickerItem(const str& string);
+
+    int            getListItemValue(int which) const override;
+    griditemtype_t getListItemType(int which) const override;
+    str            getListItemString(int which) const override;
+    void           DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) override;
+    qboolean       IsHeaderEntry() const override;
+};
+
+typedef struct {
+    const char *fileName;
+    const char *displayName;
+} PMPickerModel_t;
+
+static const PMPickerModel_t pickerModels[] = {
+  // 2.0 skins
+    {"allied_101st_captain",                    "US - 101st Airborne Captain"    },
+    {"allied_101st_infantry",                   "US - 101st Airborne Private 1"  },
+    {"allied_101st_scout",                      "US - 101st Airborne Private 2"  },
+    {"allied_501st_pir_scout",                  "US - 501st Paratrooper 1"       },
+    {"allied_501st_pir_soldier",                "US - 501st Paratrooper 2"       },
+ // 1.0 skins
+    {"allied_airborne",                         "US - 501st Paratrooper 3"       },
+ // Readded in OPM (was removed in 2.0)
+    {"allied_manon",                            "US - Manon"                     },
+ // 2.0 skins
+    {"allied_british_6th_airborne_captain",     "UK - 6th Airborne Captain"      },
+    {"allied_british_6th_airborne_paratrooper", "UK - 6th Airborne Paratrooper"  },
+ // 1.0 skins
+    {"allied_pilot",                            "US - Army Pilot"                },
+ // 2.0 skins
+    {"allied_russian_corporal",                 "RA - Corporal"                  },
+    {"allied_russian_crazy_boris",              "RA - Crazy Boris"               },
+    {"allied_russian_recon_scout",              "RA - Junior Lieutenant"         },
+    {"allied_russian_recon_soldier",            "RA - Black Sea Petty Officer"   },
+ // 1.0 skins
+    {"allied_sas",                              "UK - SAS Officer"               },
+    {"american_army",                           "US - Soldier"                   },
+    {"american_ranger",                         "US - Ranger"                    },
+ // 1.0 skins
+    {"german_afrika_officer",                   "DE - Afrika Officer"            },
+    {"german_afrika_private",                   "DE - Afrika Private"            },
+ // 2.0 skins
+    {"german_ardennes_artillery_commander",     "DE - Artillery Commander"       },
+    {"german_dday_colonel",                     "DE - Normandy Colonel"          },
+ // 1.0 skins
+    {"german_elite_officer",                    "DE - Elite Officer"             },
+    {"german_elite_sentry",                     "DE - Elite Sentry"              },
+    {"german_kradshutzen",                      "DE - Kradshutzen"               },
+    {"german_panzer_grenadier",                 "DE - Panzer Grenadier"          },
+    {"german_panzer_obershutze",                "DE - Panzer Obershutze"         },
+    {"german_panzer_shutze",                    "DE - Panzer Shutze"             },
+    {"german_panzer_tankcommander",             "DE - Panzer Tank Commander"     },
+    {"german_scientist",                        "DE - German Scientist"          },
+ // Those skins were superseded by german_waffenss
+    {"german_waffen_officer",                   "DE - Waffen Officer"            },
+    {"german_waffen_shutze",                    "DE - Waffen Shutze"             },
+ // 1.0 skins
+    {"german_waffenss_officer",                 "DE - Waffen Officer"            },
+    {"german_waffenss_shutze",                  "DE - Waffen Shutze"             },
+    {"german_wehrmacht_officer",                "DE - Wehrmacht Officer"         },
+    {"german_wehrmacht_soldier",                "DE - Wehrmacht Soldier"         },
+    {"german_winter_1",                         "DE - Winter Infantry 1"         },
+    {"german_winter_2",                         "DE - Winter Infantry 2"         },
+    {"german_worker",                           "DE - German Mechanic"           },
+ // 2.11 skins
+    {"allied_british_tank_corporal",            "UK - 6th Royal Tank Regiment"   },
+    {"allied_russian_seaman",                   "RA - Red Navy Seaman"           },
+    {"german_Panzer_Corporal",                  "DE - 1st Panzer Regiment"       },
+    {"allied_technician",                       "US - Air Force Technician"      },
+    {"german_stukageschwader",                  "DE - Stukageschwader"           },
+ // 2.30 skins
+    {"It_AX_Ital_Vol",                          "IT - 10th Army XXI Corps"       },
+    {"SC_AX_Ital_Inf",                          "IT - 6th Army 202nd Coastal Div"},
+    {"SC_AX_Ital_Inf2",                         "IT - 114th Inf Regiment"        },
+    {"SC_AX_ITAL_PARA",                         "IT - Paracadutista Militare"    },
+ // 2.40 skins
+    {"allied_Wheathers",                        "US - General Wheathers"         },
+    {"allied_US_Tank",                          "US - II Corps Tank Commander"   },
+    {"allied_US_Mask",                          "US - II Corps Infantry"         },
+    {"allied_british_Cmd",                      "UK - 10th Corps"                },
+    {"allied_british_Tank",                     "UK - 8th Army"                  },
+    {NULL,                                      NULL                             }
+};
+
+const char *PM_FilenameToDisplayname(const char *fileName)
+{
+    int i;
+
+    for (i = 0; pickerModels[i].fileName; i++) {
+        const PMPickerModel_t& model = pickerModels[i];
+
+        if (!Q_stricmp(model.fileName, fileName)) {
+            return model.displayName;
+        }
+    }
+
+    return fileName;
+}
+
+const char *PM_DisplaynameToFilename(const char *displayName)
+{
+    int i;
+
+    for (i = 0; pickerModels[i].fileName; i++) {
+        const PMPickerModel_t& model = pickerModels[i];
+
+        if (!Q_stricmp(model.displayName, displayName)) {
+            return model.fileName;
+        }
+    }
+
+    return displayName;
+}
+
+CLASS_DECLARATION(USignal, PlayerModelPickerClass, NULL) {
+    {&EV_UIListBase_ItemSelected,       &PlayerModelPickerClass::FileSelected },
+    {&EV_UIListBase_ItemDoubleClicked,  &PlayerModelPickerClass::FileChosen   },
+    {&UIFloatingWindow::W_ClosePressed, &PlayerModelPickerClass::OnDeactivated},
+    {&W_Deactivated,                    &PlayerModelPickerClass::OnDeactivated},
+    {NULL,                              NULL                                  }
 };
 
 PlayerModelPickerClass::PlayerModelPickerClass()
 {
-	// FIXME: stub
+    window = new UIFloatingWindow();
+    window->Create(
+        NULL,
+        UIRect2D((cls.glconfig.vidWidth - 400) / 2, (cls.glconfig.vidHeight - 300) / 2, 400, 300),
+        "Player Model Select...",
+        UColor(0.15f, 0.195f, 0.278f),
+        UHudColor
+    );
+    window->setFont("facfont-20");
+    window->PassEventToWidget("closebutton", new Event(EV_Widget_Disable));
+    window->PassEventToWidget("minimizebutton", new Event(EV_Widget_Disable));
+    window->Connect(this, W_Deactivated, W_Deactivated);
+
+    listbox = new UIListCtrl();
+    listbox->InitFrame(window->getChildSpace(), window->getChildSpace()->getClientFrame(), 0);
+    listbox->SetDrawHeader(false);
+    listbox->setFont("facfont-20");
+    listbox->FrameInitialized();
+    listbox->AddColumn("Player Model", 0, 400, false, false);
+
+    listbox->Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
+    listbox->Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
+    listbox->AllowActivate(true);
+
+    // Added in 2.0
+    //  Don't localize elements
+    listbox->SetDontLocalize();
+
+    m_bGermanModels = false;
 }
 
 PlayerModelPickerClass::~PlayerModelPickerClass()
 {
-	// FIXME: stub
+    if (listbox) {
+        delete listbox;
+        listbox = NULL;
+    }
+
+    if (window) {
+        delete window;
+        window = NULL;
+    }
 }
 
-void PlayerModelPickerClass::SetupFiles( void )
+void PlayerModelPickerClass::Setup(const char *root_directory, const char *current_directory, qboolean bGermanModels)
 {
-	// FIXME: stub
+    Initialize(root_directory, current_directory, bGermanModels);
 }
 
-void PlayerModelPickerClass::Initialize( const char *root_directory, const char *current_directory, qboolean bGermanModels )
+void PlayerModelPickerClass::Initialize(
+    const char *root_directory, const char *current_directory, qboolean bGermanModels
+)
 {
-	// FIXME: stub
+    rootDirectory   = root_directory;
+    m_bGermanModels = bGermanModels;
+    if (rootDirectory.length() > 1 && rootDirectory[rootDirectory.length() - 1] != '/') {
+        rootDirectory += "/";
+    }
+
+    currentDirectory = current_directory;
+    if (currentDirectory.length() > 1 && currentDirectory[currentDirectory.length() - 1] != '/') {
+        currentDirectory += "/";
+    }
+
+    SetupFiles();
 }
 
-void PlayerModelPickerClass::CloseWindow( void )
+void PlayerModelPickerClass::SetupFiles(void)
 {
-	// FIXME: stub
+    str         mappath;
+    char        work[128];
+    char      **filenames;
+    const char *displayName;
+    int         numfiles;
+    int         i;
+    int         iLen;
+    qboolean    bIsGerman;
+
+    // cleanup
+    listbox->DeleteAllItems();
+
+    if (m_bGermanModels) {
+        window->setTitle("Select Your Axis Player Model");
+    } else {
+        window->setTitle("Select Your Allied Player Model");
+    }
+
+    filenames = FS_ListFiles(currentDirectory, ".tik", qfalse, &numfiles);
+
+    for (i = 0; i < numfiles; i++) {
+        Q_strncpyz(work, filenames[i], sizeof(work));
+
+        if (strstr(work, "_fps")) {
+            // ignore view models
+            continue;
+        }
+
+        if (work[0] == '_') {
+            // ignore hidden models
+            continue;
+        }
+
+        // allied_manon readded in OPM
+        //if (!Q_stricmpn(work, "allied_manon")) {
+        //    continue;
+        //}
+
+        bIsGerman = !Q_stricmpn(work, "german", 6u) || !Q_stricmpn(work, "axis", 4u) || !Q_stricmpn(work, "it", 2u)
+                 || !Q_stricmpn(work, "sc", 2u);
+
+        if (m_bGermanModels != bIsGerman) {
+            continue;
+        }
+
+        // strip the extension
+        work[strlen(work) - 4] = 0;
+        displayName            = PM_FilenameToDisplayname(work);
+
+        listbox->AddItem(new PMPickerItem(displayName));
+    }
+
+    FS_FreeFileList(filenames);
+
+    listbox->SortByColumn(0);
 }
 
-void PlayerModelPickerClass::FileSelected( Event *ev )
+void PlayerModelPickerClass::FileSelected(
+    const str& name, const str& currentDirectory, const str& partialName, const str& fullname
+)
 {
-	// FIXME: stub
+    FileChosen(name, currentDirectory, partialName, fullname);
 }
 
-void PlayerModelPickerClass::FileSelected( str& currentDirectory, str& partialName, str& fullname )
+void PlayerModelPickerClass::FileSelected(Event *ev)
 {
-	// FIXME: stub
+    str  name;
+    char donotshowssindeorfr[64];
+    str  fullname;
+
+    name     = listbox->GetItem(listbox->getCurrentItem())->getListItemString(0);
+    fullname = PM_DisplaynameToFilename(name);
+
+    if (!Q_stricmpn(fullname, "german_waffen_", 14)) {
+        Q_strncpyz(donotshowssindeorfr, "german_waffenss_", sizeof(donotshowssindeorfr));
+        Q_strcat(donotshowssindeorfr, sizeof(donotshowssindeorfr), fullname.c_str() + 14);
+    } else {
+        Q_strncpyz(donotshowssindeorfr, fullname, sizeof(donotshowssindeorfr));
+    }
+
+    FileSelected(name, currentDirectory, fullname, currentDirectory + donotshowssindeorfr);
 }
 
-void PlayerModelPickerClass::FileChosen( Event *ev )
+void PlayerModelPickerClass::FileChosen(
+    const str& name, const str& currentDirectory, const str& partialName, const str& fullname
+)
 {
-	// FIXME: stub
+    str sCommand;
+
+    if (m_bGermanModels) {
+        sCommand += "ui_dm_playergermanmodel \"" + name;
+        sCommand += "\" ; ui_dm_playergermanmodel_set " + partialName;
+        sCommand += " ; ui_disp_playergermanmodel " + fullname + ".tik";
+    } else {
+        sCommand += "ui_dm_playermodel \"" + name;
+        sCommand += "\" ; ui_dm_playermodel_set " + partialName;
+        sCommand += " ; ui_disp_playermodel " + fullname + ".tik";
+    }
+    sCommand += "\n";
+
+    Cbuf_AddText(sCommand);
+    CloseWindow();
 }
 
-void PlayerModelPickerClass::FileChosen( str& currentDirectory, str& partialName, str& fullname )
+void PlayerModelPickerClass::FileChosen(Event *ev)
 {
-	// FIXME: stub
+    str  name;
+    char donotshowssindeorfr[64];
+    str  fullname;
+
+    name     = listbox->GetItem(listbox->getCurrentItem())->getListItemString(0);
+    fullname = PM_DisplaynameToFilename(name);
+
+    if (!Q_stricmpn(fullname, "german_waffen_", 14)) {
+        Q_strncpyz(donotshowssindeorfr, "german_waffen_", sizeof(donotshowssindeorfr));
+        Q_strcat(donotshowssindeorfr, sizeof(donotshowssindeorfr), fullname.c_str() + 14);
+    } else {
+        Q_strncpyz(donotshowssindeorfr, fullname, sizeof(donotshowssindeorfr));
+    }
+
+    FileChosen(name, currentDirectory, fullname, currentDirectory + donotshowssindeorfr);
 }
 
-void PlayerModelPickerClass::OnDeactivated( Event *ev )
+void PlayerModelPickerClass::CloseWindow(void)
 {
-	// FIXME: stub
+    PostEvent(EV_Remove, 0);
 }
 
-void PlayerModelPickerClass::Setup( const char *root_directory, const char *current_directory, qboolean bGermanModels )
+void PlayerModelPickerClass::OnDeactivated(Event *ev)
 {
-	// FIXME: stub
+    CloseWindow();
+}
+
+PMPickerItem::PMPickerItem(const str& string)
+{
+    m_string = string;
+}
+
+int PMPickerItem::getListItemValue(int which) const
+{
+    return atoi(m_string);
+}
+
+griditemtype_t PMPickerItem::getListItemType(int which) const
+{
+    return griditemtype_t::TYPE_STRING;
+}
+
+str PMPickerItem::getListItemString(int which) const
+{
+    return m_string;
+}
+
+void PMPickerItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont *pFont) {}
+
+qboolean PMPickerItem::IsHeaderEntry() const
+{
+    return qfalse;
 }

code/client/cl_uiplayermodelpicker.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,37 +20,41 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIPLAYERMODELPICKER_H__
-#define __CL_UIPLAYERMODELPICKER_H__
+#pragma once
 
 class UIFloatingWindow;
 
-class PlayerModelPickerClass : public USignal {
-	UIFloatingWindow *window;
-	UIListCtrl *listbox;
-	str currentDirectory;
-	str rootDirectory;
-	qboolean m_bGermanModels;
+class PlayerModelPickerClass : public USignal
+{
+    UIFloatingWindow *window;
+    UIListCtrl       *listbox;
+    str               currentDirectory;
+    str               rootDirectory;
+    qboolean          m_bGermanModels;
+
 public:
-	CLASS_PROTOTYPE( PlayerModelPickerClass );
+    CLASS_PROTOTYPE(PlayerModelPickerClass);
 
 private:
-	void		SetupFiles( void );
-	void		Initialize( const char *root_directory, const char *current_directory, qboolean bGermanModels );
+    void SetupFiles(void);
+    void Initialize(const char *root_directory, const char *current_directory, qboolean bGermanModels);
 
 protected:
-	void			CloseWindow( void );
-	void			FileSelected( Event *ev );
-	virtual void	FileSelected( str& currentDirectory, str& partialName, str& fullname );
-	void			FileChosen( Event *ev );
-	virtual void	FileChosen( str& currentDirectory, str& partialName, str& fullname );
-	void			OnDeactivated( Event *ev );
+    void         CloseWindow(void);
+    void         FileSelected(Event *ev);
+    // The name parameter was added in 2.0.
+    virtual void FileSelected(const str& name, const str& currentDirectory, const str& partialName, const str& fullname);
+    void         FileChosen(Event *ev);
+    // The name parameter was added in 2.0.
+    virtual void FileChosen(const str& name, const str& currentDirectory, const str& partialName, const str& fullname);
+    void         OnDeactivated(Event *ev);
 
 public:
-	PlayerModelPickerClass();
-	~PlayerModelPickerClass();
+    PlayerModelPickerClass();
+    ~PlayerModelPickerClass();
 
-	void	Setup( const char *root_directory, const char *current_directory, qboolean bGermanModels );
+    void Setup(const char *root_directory, const char *current_directory, qboolean bGermanModels);
 };
 
-#endif /* __CL_UIPLAYERMODELPICKER_H__ */
+const char* PM_FilenameToDisplayname(const char* fileName);
+const char* PM_DisplaynameToFilename(const char* displayName);

code/client/cl_uiradar.cpp

@@ -58,7 +58,7 @@ void UIRadar::Draw(void)
 	float inv;
 	float iconSize;
 	int blinkTime, speakTime;
-	float origin[2], axis[2];
+	vec2_t origin, axis;
 	float halfScale;
 	int i;
 
@@ -105,17 +105,17 @@ void UIRadar::Draw(void)
 	halfScale = iconSize * 0.5f;
 
 	for (i = 0; i < MAX_CLIENTS; i++) {
-		float delta[2];
-		float newOrg[2];
-		float screenOrg[2];
-		float length;
+		vec2_t delta;
+		vec2_t newOrg;
+		vec2_t screenOrg;
+		float  length;
 
 		radar = &g_radarClients[i];
 		if (i == g_radarClientNum) {
 			continue;
 		}
 
-		if (!g_radarClients[i].time) {
+		if (!radar->time) {
 			continue;
 		}
 
@@ -128,10 +128,13 @@ void UIRadar::Draw(void)
 			// make the icon blink
 			if (delta >= 0 && delta < speakTime && ((delta / blinkTime) % 2) == 0) {
 				continue;
+            }
+
+			if (delta < 0 || delta >= speakTime) {
+				radar->lastSpeakTime = 0;
 			}
 		}
 
-		radar->lastSpeakTime = 0;
 		delta[0] = radar->origin[0] - origin[0];
 		delta[1] = radar->origin[1] - origin[1];
 		newOrg[0] = -(delta[0] * axis[0] + delta[1] * axis[1]) * inv;
@@ -140,12 +143,12 @@ void UIRadar::Draw(void)
 
 		if (length > 1)
 		{
-			newOrg[0] = -(delta[0] * axis[0] + delta[1] * axis[1]) * inv * (1.f / length);
-			newOrg[1] = (delta[0] * axis[1] + delta[1] * -axis[0]) * inv * (1.f / length);
+			newOrg[0] *= 1.f / length;
+			newOrg[1] *= 1.f / length;
 		}
 
-		screenOrg[0] = -((halfScale * (1.141f * newOrg[1] + m_vVirtualScale[0])) - ((1.f + newOrg[1]) * 0.5f * m_frame.size.width));
-		screenOrg[1] = -((halfScale * (1.141f * newOrg[0] + m_vVirtualScale[1])) - ((1.f + newOrg[0]) * 0.5f * m_frame.size.height));
+		screenOrg[0] = -((halfScale * (1.414f * newOrg[1] + m_vVirtualScale[0])) - ((1.f + newOrg[1]) * 0.5f * m_frame.size.width));
+		screenOrg[1] = -((halfScale * (1.414f * newOrg[0] + m_vVirtualScale[1])) - ((1.f + newOrg[0]) * 0.5f * m_frame.size.height));
 
 		uii.Rend_DrawPicStretched2(
 			screenOrg[0],

code/client/cl_uiserverlist.cpp

@@ -79,6 +79,7 @@ struct ServerListInstance {
 };
 
 class FAKKServerListItem : public UIListCtrlItem {
+    UIFAKKServerList* m_parent; // Added in OPM
     str m_strings[6];
     str m_sVersion;
     bool m_bDifferentVersion;
@@ -94,7 +95,7 @@ public:
     int m_iGameSpyPort;
 
 public:
-    FAKKServerListItem(str string1, str string2, str string3, str string4, str string5, str string6, str ver);
+    FAKKServerListItem(UIFAKKServerList* parent, str string1, str string2, str string3, str string4, str string5, str string6, str ver);
 
     griditemtype_t getListItemType(int index) const override;
     int getListItemValue(int i) const override;
@@ -125,8 +126,9 @@ ServerListInstance g_ServerListInst[2];
 void UpdateServerListCallBack(GServerList serverlist, int msg, void* instance, void* param1, void* param2);
 static void AddFilter(char* filter, const char* value);
 
-FAKKServerListItem::FAKKServerListItem(str string1, str string2, str string3, str string4, str string5, str string6, str ver)
+FAKKServerListItem::FAKKServerListItem(UIFAKKServerList* parent, str string1, str string2, str string3, str string4, str string5, str string6, str ver)
 {
+    m_parent = parent;
     m_strings[0] = string1;
     m_strings[1] = string2;
     m_strings[2] = string3;
@@ -164,84 +166,95 @@ void FAKKServerListItem::setListItemString(int i, str sNewString)
 void FAKKServerListItem::DrawListItem(int iColumn, const UIRect2D& drawRect, bool bSelected, UIFont* pFont)
 {
     static cvar_t *pColoringType = Cvar_Get("cl_browserdetailedcolors", "0", CVAR_ARCHIVE);
+    UIRect2D newRect = drawRect;
+    vec2_t virtualScale = { 1.f, 1.f };
+
+    /*
+    if (m_parent->isVirtual()) {
+        virtualScale[0] = uid.vidWidth / 640.f;
+        virtualScale[1] = uid.vidHeight / 480.f;
+        newRect.size.width *= uid.vidWidth / 1024;
+        newRect.size.height *= uid.vidHeight / 768;
+    }
+    */
     
     if (!pColoringType->integer) {
         if (IfQueryFailed() || (IsDifferentVersion() && IsQueried())) {
             if (bSelected) {
-                DrawBox(drawRect, UColor(0.2f, 0.0f, 0.0f), 1.0);
+                DrawBox(newRect, UColor(0.2f, 0.0f, 0.0f), 1.0);
                 pFont->setColor(UColor(0.9f, 0.0f, 0.0f));
             } else {
-                DrawBox(drawRect, UColor(0.1f, 0.0f, 0.0f), 1.0);
+                DrawBox(newRect, UColor(0.1f, 0.0f, 0.0f), 1.0);
                 pFont->setColor(UColor(0.55f, 0.0f, 0.0f));
             }
         } else if (IsQueried()) {
             if (bSelected) {
-                DrawBox(drawRect, UColor(0.2f, 0.18f, 0.015f), 1.0);
+                DrawBox(newRect, UColor(0.2f, 0.18f, 0.015f), 1.0);
                 pFont->setColor(UColor(0.9f, 0.8f, 0.6f));
             } else {
-                DrawBox(drawRect, UColor(0.02f, 0.07f, 0.004f), 1.0);
+                DrawBox(newRect, UColor(0.02f, 0.07f, 0.004f), 1.0);
                 pFont->setColor(UHudColor);
             }
         } else {
             if (bSelected) {
-                DrawBox(drawRect, UColor(0.15f, 0.18f, 0.18f), 1.0);
+                DrawBox(newRect, UColor(0.15f, 0.18f, 0.18f), 1.0);
                 pFont->setColor(UColor(0.6f, 0.7f, 0.8f));
             } else {
-                DrawBox(drawRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
+                DrawBox(newRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
                 pFont->setColor(UColor(0.05f, 0.5f, 0.6f));
             }
         }
 
         pFont->Print(
-            drawRect.pos.x + 1.0,
-            drawRect.pos.y,
+            newRect.pos.x / virtualScale[0] + 1.0,
+            newRect.pos.y / virtualScale[1],
             getListItemString(iColumn).c_str(),
             -1,
-            qfalse
+            false //m_parent->isVirtual()
         );
     } else {
         if (IsDifferentVersion()) {
             if (IsQueried()) {
                 if (bSelected) {
-                    DrawBox(drawRect, UColor(0.25f, 0.0f, 0.0f), 1.0);
+                    DrawBox(newRect, UColor(0.25f, 0.0f, 0.0f), 1.0);
                     pFont->setColor(UColor(0.0f, 0.5f, 0.0f));
                 } else {
-                    DrawBox(drawRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
+                    DrawBox(newRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
                     pFont->setColor(UColor(0.0f, 0.35f, 0.0f));
                 }
             } else {
                 if (bSelected) {
-                    DrawBox(drawRect, UColor(0.25f, 0.0f, 0.0f), 1.0);
+                    DrawBox(newRect, UColor(0.25f, 0.0f, 0.0f), 1.0);
                     pFont->setColor(UColor(0.5f, 0.6f, 0.7f));
                 } else {
-                    DrawBox(drawRect, UColor(0.15f, 0.0f, 0.0f), 1.0);
+                    DrawBox(newRect, UColor(0.15f, 0.0f, 0.0f), 1.0);
                     pFont->setColor(UColor(0.05f, 0.4f, 0.5f));
                 }
             }
         } else if (IsQueried()) {
             if (bSelected) {
-                DrawBox(drawRect, UColor(0.2f, 0.18f, 0.015f), 1.0);
+                DrawBox(newRect, UColor(0.2f, 0.18f, 0.015f), 1.0);
                 pFont->setColor(UColor(0.9f, 0.8f, 0.6f));
             } else {
-                DrawBox(drawRect, UColor(0.02f, 0.07f, 0.005f), 1.0);
+                DrawBox(newRect, UColor(0.02f, 0.07f, 0.005f), 1.0);
                 pFont->setColor(UHudColor);
             }
         } else {
             if (bSelected) {
-                DrawBox(drawRect, UColor(0.15f, 0.18f, 0.18f), 1.0);
+                DrawBox(newRect, UColor(0.15f, 0.18f, 0.18f), 1.0);
                 pFont->setColor(UColor(0.6f, 0.7f, 0.8f));
             } else {
-                DrawBox(drawRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
+                DrawBox(newRect, UColor(0.005f, 0.07f, 0.02f), 1.0);
                 pFont->setColor(UColor(0.05f, 0.5f, 0.6f));
             }
 
             if (IfQueryFailed()) {
                 DrawBox(
                     UIRect2D(
-                        drawRect.pos.x,
-                        drawRect.pos.y + drawRect.size.height * 0.5 - 1.0 + drawRect.pos.y,
-                        drawRect.size.width,
-                        drawRect.size.height * 0.5 - 1.0 + drawRect.pos.y
+                        newRect.pos.x,
+                        newRect.pos.y + newRect.size.height * 0.5 - 1.0 + newRect.pos.y,
+                        newRect.size.width,
+                        newRect.size.height * 0.5 - 1.0 + newRect.pos.y
                     ),
                     URed,
                     0.3f
@@ -249,19 +262,19 @@ void FAKKServerListItem::DrawListItem(int iColumn, const UIRect2D& drawRect, boo
             }
 
             pFont->Print(
-                drawRect.pos.x + 1.0,
-                drawRect.pos.y,
+                newRect.pos.x / virtualScale[0] + 1.0,
+                newRect.pos.y / virtualScale[1],
                 getListItemString(iColumn).c_str(),
                 -1,
-                qfalse
+                false //m_parent->isVirtual()
             );
 
             if (IsDifferentVersion()) {
                 DrawBox(
                     UIRect2D(
-                        drawRect.pos.x,
-                        drawRect.pos.y + drawRect.size.height * 0.5 - 1.0 + drawRect.pos.y,
-                        drawRect.size.width,
+                        newRect.pos.x,
+                        newRect.pos.y + newRect.size.height * 0.5 - 1.0 + newRect.pos.y,
+                        newRect.size.width,
                         1.0
                     ),
                     URed,
@@ -638,6 +651,9 @@ static void AddFilter(char* filter, const char* value) {
 void UIFAKKServerList::CancelRefresh( Event *ev )
 {
 	ServerListHalt(m_serverList[0]);
+    if (m_serverList[1]) {
+        ServerListHalt(m_serverList[1]);
+    }
 }
 
 void UIFAKKServerList::NewServerList( void )
@@ -730,6 +746,14 @@ void UIFAKKServerList::UpdateServer( Event *ev )
 
     FAKKServerListItem* item = (FAKKServerListItem*)GetItem(getCurrentItem());
     ServerListAuxUpdate(m_serverList[0], item->m_sIP.c_str(), item->m_iGameSpyPort, true, GQueryType::qt_status);
+
+    if (com_target_game->integer >= target_game_e::TG_MOHTT) {
+        const cvar_t* dm_omit_spearhead = Cvar_Get("dm_omit_spearhead", "0", CVAR_ARCHIVE);
+        // check for Spearhead
+        if (!dm_omit_spearhead->integer) {
+            ServerListAuxUpdate(m_serverList[1], item->m_sIP.c_str(), item->m_iGameSpyPort, true, GQueryType::qt_status);
+        }
+    }
 }
 
 int UIFAKKServerList::ServerCompareFunction( const UIListCtrlItem *i1, const UIListCtrlItem *i2, int columnname )
@@ -1016,31 +1040,51 @@ void UpdateServerListCallBack(GServerList serverlist, int msg, void* instance, v
     {
         const char* pszHostName;
         bool bDiffVersion;
+        bool bIsDemo;
         str sServerName;
         str sPlayers;
         const char* pszGameVer;
+        const char* pszGameVerNumber;
 
         pszHostName = ServerGetStringValue(server, "hostname", "(NONE)");
         bDiffVersion = false;
+        bIsDemo = false;
         pszGameVer = ServerGetStringValue(server, "gamever", "1.00");
+        pszGameVerNumber = pszGameVer;
+
+        if (pszGameVerNumber[0] == 'd') {
+            // demo server
+            pszGameVerNumber++;
+            bIsDemo = true;
+        }
 
         if (com_target_game->integer >= target_game_e::TG_MOHTT) {
             if (iServerType == target_game_e::TG_MOHTT) {
-                if (fabs(atof(pszGameVer) - com_target_version->value) > 0.1f) {
+                //if (fabs(atof(pszGameVerNumber) - com_target_version->value) > 0.1f) {
+                //    bDiffVersion = true;
+                //}
+                if (fabs(atof(pszGameVerNumber)) < 2.3f) {
                     bDiffVersion = true;
                 }
             } else {
-                if (fabs(atof(pszGameVer) - com_target_version->value) > 0.3f) {
+                //if (fabs(atof(pszGameVerNumber) - com_target_version->value) > 0.3f) {
+                //    bDiffVersion = true;
+                //}
+                if (fabs(atof(pszGameVerNumber)) < 2.1f) {
                     bDiffVersion = true;
                 }
             }
         } else {
-            if (fabs(atof(pszGameVer) - com_target_version->value) > 0.1f) {
+            if (fabs(atof(pszGameVerNumber) - com_target_version->value) > 0.1f) {
                 bDiffVersion = true;
             }
         }
         // always show the version
-        sServerName = va(" (%s) %s", pszGameVer, pszHostName);
+        if (!bIsDemo) {
+            sServerName = va(" (%s) %s", pszGameVerNumber, pszHostName);
+        } else {
+            sServerName = va(" (d%s) %s", pszGameVerNumber, pszHostName);
+        }
 
         iRealIP = inet_addr(ServerGetAddress(server));
         iPort = ServerGetIntValue(server, "hostport", PORT_SERVER);
@@ -1056,7 +1100,7 @@ void UpdateServerListCallBack(GServerList serverlist, int msg, void* instance, v
         }
 
         if (i > uiServerList->getNumItems() || !pNewServerItem) {
-            pNewServerItem = new FAKKServerListItem("?", sAddress, "?", "?/?", "?", "?", "?");
+            pNewServerItem = new FAKKServerListItem(uiServerList, "?", sAddress, "?", "?/?", "?", "?", "?");
             pNewServerItem->m_sIP = ServerGetAddress(server);
             pNewServerItem->m_uiRealIP = iRealIP;
             pNewServerItem->m_iGameSpyPort = iGameSpyPort;
@@ -1154,7 +1198,7 @@ void UpdateServerListCallBack(GServerList serverlist, int msg, void* instance, v
                 continue;
             }
 
-            pNewServerItem = new FAKKServerListItem("?", sAddress, "?", "?/?", "?", "?", "?");
+            pNewServerItem = new FAKKServerListItem(uiServerList, "?", sAddress, "?", "?/?", "?", "?", "?");
             pNewServerItem->m_sIP = ServerGetAddress(arrayServer);
             pNewServerItem->m_uiRealIP = iRealIP;
             pNewServerItem->m_iPort = PORT_SERVER;

code/client/cl_uisoundpicker.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -22,22 +22,42 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-CLASS_DECLARATION( FilePickerClass, SoundPickerClass, NULL )
-{
-	{ NULL, NULL }
+CLASS_DECLARATION(FilePickerClass, SoundPickerClass, NULL) {
+    {NULL, NULL}
 };
 
 SoundPickerClass::SoundPickerClass()
 {
-	// FIXME: stub
+    str         soundpath;
+    str         currentpath;
+    const char *varValue;
+    int         i;
+
+    soundpath = "sound";
+
+    varValue = UI_GetCvarString("ui_pickedsound", NULL);
+    if (varValue && *varValue) {
+        currentpath = varValue;
+
+        for (i = currentpath.length(); i > 0; i--) {
+            if (currentpath[i] == '/') {
+                break;
+            }
+        }
+
+        currentpath = str(currentpath, 0, i + 1);
+    } else {
+        currentpath = soundpath;
+    }
 }
 
-void SoundPickerClass::FileSelected( str &currentDirectory, str &partialName, str &fullname )
+void SoundPickerClass::FileSelected(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-
+    uii.Snd_PlaySound(fullname);
 }
 
-void SoundPickerClass::FileChosen( str &currentDirectory, str &partialName, str &fullname )
+void SoundPickerClass::FileChosen(const str& currentDirectory, const str& partialName, const str& fullname)
 {
-
+    uii.Cvar_Set("ui_pickedsound", fullname);
+    CloseWindow();
 }

code/client/cl_uisoundpicker.h

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2023 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,17 +20,15 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UISOUNDPICKER_H__
-#define __CL_UISOUNDPICKER_H__
+#pragma once
 
-class SoundPickerClass : public FilePickerClass {
+class SoundPickerClass : public FilePickerClass
+{
 public:
-	CLASS_PROTOTYPE( SoundPickerClass );
+    CLASS_PROTOTYPE(SoundPickerClass);
 
-	SoundPickerClass();
+    SoundPickerClass();
 
-	void	FileSelected( str &currentDirectory, str &partialName, str &fullname ) override;
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
+    void FileSelected(const str& currentDirectory, const str& partialName, const str& fullname) override;
+    void FileChosen(const str& currentDirectory, const str& partialName, const str& fullname) override;
 };
-
-#endif /* __CL_UISOUNDPICKER_H__ */

code/client/cl_uistd.cpp

@@ -439,8 +439,10 @@ void UIFakkLabel::LayoutRenderModelAnim(Event *ev)
 
 void UIFakkLabel::DrawStatbar(float frac)
 {
-    vec4_t col;
-    float  alpha;
+    vec4_t    col;
+    float     alpha;
+    qhandle_t hMat;
+    float     w, h;
 
     col[0] = col[1] = col[2] = col[3] = 1.0;
 
@@ -475,11 +477,7 @@ void UIFakkLabel::DrawStatbar(float frac)
     m_lastfrac = frac;
 
     alpha = 1.0 - ((float)uid.time - m_flashtime) / 1500.0;
-    if (alpha < 0.0) {
-        alpha = 0.0;
-    } else if (alpha > 1.0) {
-        alpha = 1.0;
-    }
+    alpha = Q_clamp_float(alpha, 0, 1);
 
     col[3] = alpha;
 
@@ -490,14 +488,30 @@ void UIFakkLabel::DrawStatbar(float frac)
                 {
                     float width = frac * m_frame.size.width;
 
-                    m_statbar_material->ReregisterMaterial();
                     re.DrawTilePic(0.0, 0.0, width, m_frame.size.height, m_statbar_material->GetMaterial());
 
                     if (alpha != 0.0 && m_statbar_material_flash) {
                         re.SetColor(col);
-                        m_statbar_material_flash->ReregisterMaterial();
                         re.DrawTilePic(0.0, 0.0, width, m_frame.size.height, m_statbar_material_flash->GetMaterial());
                     }
+
+                    if (m_statbar_material_marker) {
+                        hMat = m_statbar_material_marker->GetMaterial();
+                        w    = re.GetShaderWidth(hMat);
+                        h    = re.GetShaderHeight(hMat);
+
+                        re.DrawStretchPic(
+                            m_frame.size.width * frac - w * 0.5,
+                            m_frame.size.height * 0.5 - h * 0.5,
+                            w,
+                            h,
+                            0,
+                            0,
+                            1,
+                            1,
+                            hMat
+                        );
+                    }
                     break;
                 }
             case L_STATBAR_VERTICAL:
@@ -507,16 +521,32 @@ void UIFakkLabel::DrawStatbar(float frac)
                 {
                     float y = m_frame.size.height * (1.0 - frac);
 
-                    m_statbar_material->ReregisterMaterial();
                     re.DrawTilePic(0.0, y, m_frame.size.width, m_frame.size.height, m_statbar_material->GetMaterial());
 
                     if (alpha != 0.0 && m_statbar_material_flash) {
                         re.SetColor(col);
-                        m_statbar_material_flash->ReregisterMaterial();
                         re.DrawTilePic(
                             0.0, y, m_frame.size.width, m_frame.size.height, m_statbar_material_flash->GetMaterial()
                         );
                     }
+
+                    if (m_statbar_material_marker) {
+                        hMat = m_statbar_material_marker->GetMaterial();
+                        w    = re.GetShaderWidth(hMat);
+                        h    = re.GetShaderHeight(hMat);
+
+                        re.DrawStretchPic(
+                            m_frame.size.width * frac - w * 0.5,
+                            m_frame.size.height * 0.5 - h * 0.5,
+                            w,
+                            h,
+                            0,
+                            0,
+                            1,
+                            1,
+                            hMat
+                        );
+                    }
                     break;
                 }
             default:
@@ -528,14 +558,12 @@ void UIFakkLabel::DrawStatbar(float frac)
                 {
                     float width = frac * m_frame.size.width;
 
-                    m_statbar_material->ReregisterMaterial();
                     re.DrawStretchPic(
                         0.0, 0.0, width, m_frame.size.height, 0.0, 0.0, 1.0, 1.0, m_statbar_material->GetMaterial()
                     );
 
                     if (alpha != 0.0 && m_statbar_material_flash) {
                         re.SetColor(col);
-                        m_statbar_material_flash->ReregisterMaterial();
                         re.DrawStretchPic(
                             0.0,
                             0.0,
@@ -548,6 +576,24 @@ void UIFakkLabel::DrawStatbar(float frac)
                             m_statbar_material_flash->GetMaterial()
                         );
                     }
+
+                    if (m_statbar_material_marker) {
+                        hMat = m_statbar_material_marker->GetMaterial();
+                        w    = re.GetShaderWidth(hMat);
+                        h    = re.GetShaderHeight(hMat);
+
+                        re.DrawStretchPic(
+                            m_frame.size.width * frac - w * 0.5,
+                            m_frame.size.height * 0.5 - h * 0.5,
+                            w,
+                            h,
+                            0,
+                            0,
+                            1,
+                            1,
+                            hMat
+                        );
+                    }
                     break;
                 }
             case L_STATBAR_VERTICAL:
@@ -557,14 +603,12 @@ void UIFakkLabel::DrawStatbar(float frac)
                     float y      = m_frame.size.height * (1.0 - frac);
                     float height = m_frame.size.height * frac;
 
-                    m_statbar_material->ReregisterMaterial();
                     re.DrawStretchPic(
                         0.0, y, m_frame.size.width, height, 0.0, 1.0 - frac, 1.0, 1.0, m_statbar_material->GetMaterial()
                     );
 
                     if (alpha != 0.0 && m_statbar_material_flash) {
                         re.SetColor(col);
-                        m_statbar_material_flash->ReregisterMaterial();
                         re.DrawStretchPic(
                             0.0,
                             y,
@@ -577,20 +621,36 @@ void UIFakkLabel::DrawStatbar(float frac)
                             m_statbar_material_flash->GetMaterial()
                         );
                     }
+
+                    if (m_statbar_material_marker) {
+                        hMat = m_statbar_material_marker->GetMaterial();
+                        w    = re.GetShaderWidth(hMat);
+                        h    = re.GetShaderHeight(hMat);
+
+                        re.DrawStretchPic(
+                            m_frame.size.width * frac - w * 0.5,
+                            m_frame.size.height * 0.5 - h * 0.5,
+                            w,
+                            h,
+                            0,
+                            0,
+                            1,
+                            1,
+                            hMat
+                        );
+                    }
                     break;
                 }
             case L_STATBAR_VERTICAL_REVERSE:
                 {
                     float height = m_frame.size.height * frac;
 
-                    m_statbar_material->ReregisterMaterial();
                     re.DrawStretchPic(
                         0.0, 0.0, m_frame.size.width, height, 0.0, 0.0, 1.0, frac, m_statbar_material->GetMaterial()
                     );
 
                     if (alpha != 0.0 && m_statbar_material_flash) {
                         re.SetColor(col);
-                        m_statbar_material_flash->ReregisterMaterial();
                         re.DrawStretchPic(
                             0.0,
                             0.0,
@@ -686,12 +746,10 @@ void UIFakkLabel::DrawStatCircle(float frac)
                 re.SetColor(m_foreground_color);
             }
 
-            m_statbar_material->ReregisterMaterial();
             re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
             if (alpha && m_statbar_material_flash) {
                 re.SetColor(col);
-                m_statbar_material_flash->ReregisterMaterial();
                 re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
             }
         } else {
@@ -709,12 +767,10 @@ void UIFakkLabel::DrawStatCircle(float frac)
                     re.SetColor(m_foreground_color);
                 }
 
-                m_statbar_material->ReregisterMaterial();
                 re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
                 if (alpha && m_statbar_material_flash) {
                     re.SetColor(col);
-                    m_statbar_material_flash->ReregisterMaterial();
                     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
                 }
 
@@ -739,12 +795,10 @@ void UIFakkLabel::DrawStatCircle(float frac)
                 re.SetColor(m_foreground_color);
             }
 
-            m_statbar_material->ReregisterMaterial();
             re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
             if (alpha && m_statbar_material_flash) {
                 re.SetColor(col);
-                m_statbar_material_flash->ReregisterMaterial();
                 re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
             }
         } else {
@@ -766,12 +820,10 @@ void UIFakkLabel::DrawStatCircle(float frac)
                     re.SetColor(m_foreground_color);
                 }
 
-                m_statbar_material->ReregisterMaterial();
                 re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
                 if (alpha && m_statbar_material_flash) {
                     re.SetColor(col);
-                    m_statbar_material_flash->ReregisterMaterial();
                     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
                 }
 
@@ -846,12 +898,10 @@ void UIFakkLabel::DrawStatNeedle(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
         re.SetColor(col);
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 
@@ -867,11 +917,9 @@ void UIFakkLabel::DrawStatNeedle(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 }
@@ -937,11 +985,9 @@ void UIFakkLabel::DrawStatRotator(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 
@@ -959,11 +1005,9 @@ void UIFakkLabel::DrawStatRotator(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 }
@@ -1137,7 +1181,6 @@ void UIFakkLabel::DrawStatCompass(float frac)
     vVerts[1][1] = vCenter[1] + vCompassDir[1] * vCenter[1] + fSinVal * vCenter[0];
     vVerts[2][1] = vCenter[1] - vCompassDir[1] * vCenter[1] - fSinVal * vCenter[0];
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     vVerts[0][0]     = vVerts[2][0];
@@ -1150,7 +1193,6 @@ void UIFakkLabel::DrawStatCompass(float frac)
     vVerts[2][0] = vCenter[0] + fCosVal * vCenter[1] - vCompassDir[0] * vCenter[0];
     vVerts[2][1] = vCenter[1] * fSinVal + vCenter[0] - vCompassDir[1] * vCenter[1];
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 }
 
@@ -1227,11 +1269,9 @@ void UIFakkLabel::DrawStatSpinner(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 
@@ -1249,11 +1289,9 @@ void UIFakkLabel::DrawStatSpinner(float frac)
         re.SetColor(m_foreground_color);
     }
 
-    m_statbar_material->ReregisterMaterial();
     re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material->GetMaterial());
 
     if (alpha != 0.f && m_statbar_material_flash) {
-        m_statbar_material_flash->ReregisterMaterial();
         re.DrawTrianglePic(vVerts, vTexCoords, m_statbar_material_flash->GetMaterial());
     }
 }
@@ -1294,40 +1332,16 @@ void UIFakkLabel::Draw(void)
 {
     if (m_stat_alpha != -1) {
         float frac;
-        
+
         frac = (cl.snap.ps.stats[m_stat_alpha] + 1) / 100.0;
         frac = Q_clamp_float(frac, 0, 1);
-  
+
         m_alpha = frac;
     }
 
-    if (m_stat == -1 && m_itemindex == -1 && m_inventoryrendermodelindex == -1) {
-        if (m_stat_configstring != -1) {
-            m_font->setColor(m_foreground_color);
-
-            if (m_bOutlinedText) {
-                m_font->PrintOutlinedJustified(
-                    getClientFrame(),
-                    m_iFontAlignmentHorizontal,
-                    m_iFontAlignmentVertical,
-                    Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(cl.snap.ps.stats[m_stat_configstring]))),
-                    UBlack,
-                    m_bVirtual ? m_vVirtualScale : NULL
-                );
-            } else {
-                m_font->PrintJustified(
-                    getClientFrame(),
-                    m_iFontAlignmentHorizontal,
-                    m_iFontAlignmentVertical,
-                    Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(cl.snap.ps.stats[m_stat_configstring]))),
-                    m_bVirtual ? m_vVirtualScale : NULL
-                );
-            }
-
-            return;
-        }
-
-        if (!m_rendermodel && m_statbar_or == L_STATBAR_NONE && !m_sDrawModelName.length()) {
+    if (m_stat == -1 && m_itemindex == -1 && m_inventoryrendermodelindex == -1 && m_stat_configstring == -1
+        && !m_rendermodel && m_statbar_or == L_STATBAR_NONE) {
+        if (!m_sDrawModelName.length()) {
             UILabel::Draw();
             return;
         }
@@ -1354,28 +1368,13 @@ void UIFakkLabel::Draw(void)
                 m_bVirtual ? m_vVirtualScale : NULL
             );
         }
-
         return;
     }
 
-    if (m_stat == -1) {
-        float     scale;
-        qhandle_t handle;
-        vec3_t    origin;
-        vec3_t    mins;
-        vec3_t    maxs;
-        vec3_t    angles;
-        vec3_t    offset;
-        vec3_t    rotateoffset;
-        vec4_t    color;
-        str       sAnimName;
-        float     height;
-
-        if (m_itemindex != -1) {
-            if (m_itemindex < 0) {
-                return;
-            }
+    if (m_stat != -1) {
+        int delta = cl.snap.ps.stats[m_stat];
 
+        if (m_statbar_or == L_STATBAR_NONE) {
             m_font->setColor(m_foreground_color);
 
             if (m_bOutlinedText) {
@@ -1383,7 +1382,7 @@ void UIFakkLabel::Draw(void)
                     getClientFrame(),
                     m_iFontAlignmentHorizontal,
                     m_iFontAlignmentVertical,
-                    Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_itemindex]))),
+                    va("%d", delta),
                     UBlack,
                     m_bVirtual ? m_vVirtualScale : NULL
                 );
@@ -1392,143 +1391,13 @@ void UIFakkLabel::Draw(void)
                     getClientFrame(),
                     m_iFontAlignmentHorizontal,
                     m_iFontAlignmentVertical,
-                    Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_itemindex]))),
+                    va("%d", delta),
                     m_bVirtual ? m_vVirtualScale : NULL
                 );
             }
-
             return;
         }
 
-        if (m_inventoryrendermodelindex == -1 && !m_sDrawModelName.length() || !m_rendermodel) {
-            float frac = 0.0;
-
-            if (m_statbar_or == L_STATBAR_NONE) {
-                return;
-            }
-
-            if (m_cvarname.length()) {
-                frac = Cvar_VariableValue(m_cvarname) / (m_statbar_max - m_statbar_min);
-            }
-
-            if (frac > 1.0) {
-                frac = 1.0;
-            }
-            if (frac < 0.0) {
-                frac = 0.0;
-            }
-
-            DrawStatbar(frac);
-            return;
-        }
-
-        VectorSet4(color, 255, 255, 255, 255);
-
-        if (m_rendermodel) {
-            if (!m_cvarname.length()) {
-                return;
-            }
-
-            handle = re.RegisterModel(Cvar_VariableString(m_cvarname));
-            if (!handle) {
-                return;
-            }
-
-            VectorCopy(m_angles, angles);
-            VectorCopy(m_rotateoffset, rotateoffset);
-            VectorCopy(m_offset, offset);
-            scale     = m_scale;
-            sAnimName = m_anim;
-        } else if (m_sDrawModelName.length()) {
-            if (m_lastitemindex != cl.snap.ps.activeItems[m_inventoryrendermodelindex]) {
-                if (!m_lastitem) {
-                    m_lastitem = CL_GetInvItemByName(&client_inv, m_sDrawModelName);
-                }
-            }
-
-        _shitlabel01:
-            if (!m_lastitem) {
-                return;
-            }
-
-            VectorCopy(m_lastitem->hudprops.rotateoffset, rotateoffset);
-            VectorCopy(m_lastitem->hudprops.offset, offset);
-
-            handle = re.RegisterModel(m_lastitem->hudprops.model);
-
-            VectorCopy(m_lastitem->hudprops.angledeltas, angles);
-
-            if (m_lastitem->hudprops.move == INV_MOVE_BOB) {
-                float frac = uid.time / 600.0;
-                angles[0] += sin(frac) * m_lastitem->hudprops.angledeltas[0];
-                angles[1] += sin(frac) * m_lastitem->hudprops.angledeltas[1];
-                angles[2] += sin(frac) * m_lastitem->hudprops.angledeltas[2];
-            } else if (m_lastitem->hudprops.model == INV_MOVE_SPIN) {
-                float frac = uid.time / 600.0;
-                angles[0] += frac * m_lastitem->hudprops.angledeltas[0];
-                angles[1] += frac * m_lastitem->hudprops.angledeltas[1];
-                angles[2] += frac * m_lastitem->hudprops.angledeltas[2];
-            }
-
-            if (m_rendermodel) {
-                VectorSet(mins, -16, -16, 0);
-                VectorSet(maxs, 16, 16, 96);
-            } else {
-                re.ModelBounds(handle, mins, maxs);
-            }
-
-            origin[1] = (mins[1] + maxs[1]) * 0.5;
-            origin[2] = (mins[1] + maxs[1]) * -0.5;
-
-            height = maxs[2] - mins[2];
-
-            if (height < maxs[1] - mins[1]) {
-                height = maxs[1] - mins[1];
-            }
-
-            if (height <= maxs[0] - mins[0]) {
-                height = maxs[0] - mins[0];
-            }
-
-            origin[0] = height * scale * 0.5 / 0.268f;
-
-            CL_Draw3DModel(
-                m_screenframe.pos.x,
-                m_screenframe.pos.y,
-                m_screenframe.size.width,
-                m_screenframe.size.height,
-                handle,
-                origin,
-                rotateoffset,
-                offset,
-                angles,
-                color,
-                sAnimName
-            );
-            return;
-        }
-
-        if (m_lastitemindex == cl.snap.ps.activeItems[m_inventoryrendermodelindex]) {
-            goto _shitlabel01;
-        }
-
-        if (m_lastitem
-            == CL_GetInvItemByName(
-                &client_inv, CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_inventoryrendermodelindex])
-            )) {
-            m_lastitemindex = cl.snap.ps.activeItems[m_inventoryrendermodelindex];
-            goto _shitlabel01;
-        }
-
-        m_lastitem = CL_GetInvItemByName(
-            &client_inv, CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_inventoryrendermodelindex])
-        );
-        goto _shitlabel01;
-    }
-
-    int delta = cl.snap.ps.stats[m_stat];
-
-    if (m_statbar_or) {
         if (m_statbar_or == L_STATBAR_VERTICAL_STAGGER_EVEN || m_statbar_or == L_STATBAR_VERTICAL_STAGGER_ODD) {
             int stat;
 
@@ -1574,28 +1443,180 @@ void UIFakkLabel::Draw(void)
         }
 
         DrawStatbar(frac);
+        return;
+    }
+
+    float     scale;
+    qhandle_t handle;
+    vec3_t    origin;
+    vec3_t    mins;
+    vec3_t    maxs;
+    vec3_t    angles;
+    vec3_t    offset;
+    vec3_t    rotateoffset;
+    vec4_t    color;
+    str       sAnimName;
+    float     height;
+
+    if (m_itemindex != -1) {
+        if (m_itemindex < 0) {
+            return;
+        }
+
+        if (cl.snap.ps.activeItems[m_itemindex] < 0 || cl.snap.ps.activeItems[m_itemindex] >= MAX_WEAPONS) {
+            // Fixed in OPM
+            //  Make sure to not overflow configstrings
+            return;
+        }
+
+        m_font->setColor(m_foreground_color);
+
+        if (m_bOutlinedText) {
+            m_font->PrintOutlinedJustified(
+                getClientFrame(),
+                m_iFontAlignmentHorizontal,
+                m_iFontAlignmentVertical,
+                Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_itemindex]))),
+                UBlack,
+                m_bVirtual ? m_vVirtualScale : NULL
+            );
+        } else {
+            m_font->PrintJustified(
+                getClientFrame(),
+                m_iFontAlignmentHorizontal,
+                m_iFontAlignmentVertical,
+                Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_itemindex]))),
+                m_bVirtual ? m_vVirtualScale : NULL
+            );
+        }
 
         return;
     }
 
-    m_font->setColor(m_foreground_color);
+    if (m_inventoryrendermodelindex == -1 && !m_sDrawModelName.length() && !m_rendermodel) {
+        float frac = 0.0;
 
-    if (m_bOutlinedText) {
-        m_font->PrintOutlinedJustified(
-            getClientFrame(),
-            m_iFontAlignmentHorizontal,
-            m_iFontAlignmentVertical,
-            va("%d", delta),
-            UBlack,
-            m_bVirtual ? m_vVirtualScale : NULL
-        );
-    } else {
-        m_font->PrintJustified(
-            getClientFrame(),
-            m_iFontAlignmentHorizontal,
-            m_iFontAlignmentVertical,
-            va("%d", delta),
-            m_bVirtual ? m_vVirtualScale : NULL
-        );
+        if (m_statbar_or == L_STATBAR_NONE) {
+            return;
+        }
+
+        if (m_cvarname.length()) {
+            frac = Cvar_VariableValue(m_cvarname) / (m_statbar_max - m_statbar_min);
+        }
+
+        if (frac > 1.0) {
+            frac = 1.0;
+        }
+        if (frac < 0.0) {
+            frac = 0.0;
+        }
+
+        DrawStatbar(frac);
+        return;
     }
+
+    VectorSet4(color, 255, 255, 255, 255);
+
+    if (m_rendermodel) {
+        if (!m_cvarname.length()) {
+            return;
+        }
+
+        handle = re.RegisterModel(Cvar_VariableString(m_cvarname));
+        if (!handle) {
+            return;
+        }
+
+        VectorCopy(m_angles, angles);
+        VectorCopy(m_rotateoffset, rotateoffset);
+        VectorCopy(m_offset, offset);
+        scale     = m_scale;
+        sAnimName = m_anim;
+
+        // Added in 2.11
+        //  Tunak easter egg
+        if (Cvar_Get("tunak", "0", 0)->integer) {
+            // Since 2.15, those animations start has 'zz' prefix
+            if (strstr(m_anim, "american")) {
+                sAnimName = "zzamericanspecialidle";
+            } else {
+                // Added in 2.15
+                sAnimName = "zzgermanspecialidle";
+            }
+        }
+    } else {
+        if (m_sDrawModelName.length()) {
+            if (!m_lastitem) {
+                m_lastitem = CL_GetInvItemByName(&client_inv, m_sDrawModelName);
+            }
+        } else {
+            if (m_inventoryrendermodelindex >= 0
+                && m_lastitemindex != cl.snap.ps.activeItems[m_inventoryrendermodelindex]) {
+                m_lastitem = CL_GetInvItemByName(
+                    &client_inv, CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_inventoryrendermodelindex])
+                );
+                m_lastitemindex = cl.snap.ps.activeItems[m_inventoryrendermodelindex];
+            }
+        }
+
+        if (!m_lastitem) {
+            return;
+        }
+
+        VectorCopy(m_lastitem->hudprops.rotateoffset, rotateoffset);
+        VectorCopy(m_lastitem->hudprops.offset, offset);
+        scale  = m_lastitem->hudprops.scale;
+        handle = re.RegisterModel(m_lastitem->hudprops.model);
+        VectorCopy(m_lastitem->hudprops.angledeltas, angles);
+
+        if (m_lastitem->hudprops.move == INV_MOVE_BOB) {
+            float frac = uid.time / 600.0;
+            angles[0] += sin(frac) * m_lastitem->hudprops.angledeltas[0];
+            angles[1] += sin(frac) * m_lastitem->hudprops.angledeltas[1];
+            angles[2] += sin(frac) * m_lastitem->hudprops.angledeltas[2];
+        } else if (m_lastitem->hudprops.model == INV_MOVE_SPIN) {
+            float frac = uid.time / 600.0;
+            angles[0] += frac * m_lastitem->hudprops.angledeltas[0];
+            angles[1] += frac * m_lastitem->hudprops.angledeltas[1];
+            angles[2] += frac * m_lastitem->hudprops.angledeltas[2];
+        }
+    }
+
+    if (m_rendermodel) {
+        VectorSet(mins, -16, -16, 0);
+        VectorSet(maxs, 16, 16, 96);
+    } else {
+        re.ModelBounds(handle, mins, maxs);
+    }
+
+    origin[1] = (mins[1] + maxs[1]) * 0.5;
+    origin[2] = (mins[2] + maxs[2]) * -0.5;
+
+    height = maxs[2] - mins[2];
+
+    if (height < maxs[1] - mins[1]) {
+        height = maxs[1] - mins[1];
+    }
+
+    if (height < maxs[0] - mins[0]) {
+        height = maxs[0] - mins[0];
+    }
+
+    origin[0] = height * scale * 0.5 / 0.268f;
+
+    CL_Draw3DModel(
+        m_screenframe.pos.x,
+        m_screenframe.pos.y,
+        m_screenframe.size.width,
+        m_screenframe.size.height,
+        handle,
+        origin,
+        rotateoffset,
+        offset,
+        angles,
+        color,
+        sAnimName
+    );
+
+    set2D();
 }

code/client/cl_uistd.h

@@ -37,6 +37,8 @@ typedef enum {
     L_STATBAR_HEADING_SPINNER
 } statbar_orientation_t;
 
+extern Event EV_ClearInvItemReference;
+
 class UIFakkLabel : public UILabel
 {
 protected:

code/client/cl_uiview3d.h

@@ -20,55 +20,57 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#ifndef __CL_UIVIEW3D__
-#define __CL_UIVIEW3D__
+#pragma once
 
-class View3D : public UIWidget {
-	float m_printfadetime;
-	float m_printalpha;
-	str m_printstring;
-	UIReggedMaterial *m_print_mat;
-	qboolean m_locationprint;
-	int m_x_coord;
-	int m_y_coord;
-	qboolean m_letterbox_active;
+class View3D : public UIWidget
+{
+    float             m_printfadetime;
+    float             m_printalpha;
+    str               m_printstring;
+    UIReggedMaterial *m_print_mat;
+    qboolean          m_locationprint;
+    int               m_x_coord;
+    int               m_y_coord;
+    qboolean          m_letterbox_active;
 
 public:
-	CLASS_PROTOTYPE( View3D );
+    CLASS_PROTOTYPE(View3D);
 
 protected:
-	void		Draw( void ) override;
-	void		DrawLetterbox( void );
-	void		DrawFades( void );
-	void		Draw2D( void );
-	void		DrawFPS( void );
-	void		DrawProf( void );
-	void		PrintSound( int channel, const char *name, float vol, int rvol, float pitch, float base, int& line );
-	void		DrawSoundOverlay( void );
-	void		CenterPrint( void );
-	void		LocationPrint( void );
-	void		OnActivate( Event *ev );
-	void		OnDeactivate( Event *ev );
-	void		DrawSubtitleOverlay( void );
+    void Draw(void) override;
+    void DrawLetterbox(void);
+    void DrawFades(void);
+    void Draw2D(void);
+    void DrawFPS(void);
+    void DrawProf(void);
+    void PrintSound(int channel, const char *name, float vol, int rvol, float pitch, float base, int& line);
+    void DrawSoundOverlay(void);
+    void CenterPrint(void);
+    void LocationPrint(void);
+    void OnActivate(Event *ev);
+    void OnDeactivate(Event *ev);
+    void DrawSubtitleOverlay(void);
+
+    // Added in 2.0
+    void DrawNetProfile(void);
 
 public:
-	View3D();
+    View3D();
 
-	void			ClearCenterPrint( void );
-	void			UpdateCenterPrint( const char *s, float alpha );
-	void			UpdateLocationPrint( int x, int y, const char *s, float alpha );
-	qboolean		LetterboxActive( void );
-	void			InitSubtitle( void );
-	void			FrameInitialized( void ) override;
-	virtual void	Pressed( Event *ev );
+    void         ClearCenterPrint(void);
+    void         UpdateCenterPrint(const char *s, float alpha);
+    void         UpdateLocationPrint(int x, int y, const char *s, float alpha);
+    qboolean     LetterboxActive(void);
+    void         InitSubtitle(void);
+    void         FrameInitialized(void) override;
+    virtual void Pressed(Event *ev);
 };
 
-class ConsoleView : public UIWidget {
+class ConsoleView : public UIWidget
+{
 public:
-	CLASS_PROTOTYPE( ConsoleView );
+    CLASS_PROTOTYPE(ConsoleView);
 
 protected:
-	void Draw( void ) override;
+    void Draw(void) override;
 };
-
-#endif /* __CL_UIVIEW3D__ */

code/client/client.h

@@ -36,6 +36,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "cl_curl.h"
 #endif /* USE_CURL */
 
+#ifdef USE_VOIP
+#include <opus.h>
+#endif
+
 // file full of random crap that gets used to create cl_guid
 #define QKEY_FILE "qkey"
 #define QKEY_SIZE 2048
@@ -174,6 +178,7 @@ typedef struct {
 	int			lastPacketSentTime;			// for retransmits during connection
 	int			lastPacketTime;				// for timeouts
 
+	char		servername[MAX_OSPATH];		// name of server from original connect (used by reconnect)
 	netadr_t	serverAddress;
 	int			connectTime;				// for connection retransmits
 	int			connectStartTime;
@@ -239,15 +244,42 @@ typedef struct {
 	int			timeDemoMaxDuration;	// maximum frame duration
 	unsigned char	timeDemoDurations[ MAX_TIMEDEMO_DURATIONS ];	// log of frame durations
 
+    float		aviVideoFrameRemainder;
+    float		aviSoundFrameRemainder;
+
+#ifdef USE_VOIP
+	qboolean voipEnabled;
+	qboolean voipCodecInitialized;
+
+	// incoming data...
+	// !!! FIXME: convert from parallel arrays to array of a struct.
+	OpusDecoder *opusDecoder[MAX_CLIENTS];
+	byte voipIncomingGeneration[MAX_CLIENTS];
+	int voipIncomingSequence[MAX_CLIENTS];
+	float voipGain[MAX_CLIENTS];
+	qboolean voipIgnore[MAX_CLIENTS];
+	qboolean voipMuteAll;
+
+	// outgoing data...
+	// if voipTargets[i / 8] & (1 << (i % 8)),
+	// then we are sending to clientnum i.
+	uint8_t voipTargets[(MAX_CLIENTS + 7) / 8];
+	uint8_t voipFlags;
+	OpusEncoder *opusEncoder;
+	int voipOutgoingDataSize;
+	int voipOutgoingDataFrames;
+	int voipOutgoingSequence;
+	byte voipOutgoingGeneration;
+	byte voipOutgoingData[1024];
+	float voipPower;
+#endif
+
 #ifdef LEGACY_PROTOCOL
 	qboolean compat;
 #endif
 
 	// big stuff at end of structure so most offsets are 15 bits or less
 	netchan_t	netchan;
-
-    float		aviVideoFrameRemainder;
-    float		aviSoundFrameRemainder;
 } clientConnection_t;
 
 extern	clientConnection_t clc;
@@ -297,8 +329,6 @@ typedef struct {
 	qboolean	cddialog;			// bring up the cd needed dialog next frame
 	qboolean	no_menus;
 
-	char		servername[MAX_OSPATH];		// name of server from original connect (used by reconnect)
-
 	// when the server clears the hunk, all of these must be restarted
 	qboolean	rendererRegistered;
 	qboolean	cgameStarted;
@@ -320,7 +350,7 @@ typedef struct {
 	serverInfo_t  globalServers[MAX_GLOBAL_SERVERS];
 	// additional global servers
 	int			numGlobalServerAddresses;
-	serverAddress_t		globalServerAddresses[MAX_GLOBAL_SERVERS];
+	netadr_t	globalServerAddresses[MAX_GLOBAL_SERVERS];
 
 	int			numfavoriteservers;
 	serverInfo_t	favoriteServers[MAX_OTHER_SERVERS];
@@ -353,8 +383,8 @@ typedef struct {
 	void* savedCgameState;
 	size_t savedCgameStateSize;
 	char gcdResponse[73];
-	int unknown3_0;
-	int currentRate;
+	// Added in 2.0
+	netprofclient_t netprofile;
 	qhandle_t	charSetShader;
 	qhandle_t	whiteShader;
 	qhandle_t	consoleShader;
@@ -385,6 +415,8 @@ extern	cvar_t	*cl_connect_timeout;
 extern	cvar_t	*cl_maxpackets;
 extern	cvar_t	*cl_packetdup;
 extern	cvar_t	*cl_shownet;
+extern	cvar_t	*cl_netprofile;
+extern	cvar_t	*cl_netprofileoverlay;
 extern	cvar_t	*cl_showSend;
 extern	cvar_t	*cl_timeNudge;
 extern	cvar_t	*cl_showTimeDelta;
@@ -445,6 +477,32 @@ extern	cvar_t	*cl_r_fullscreen;
 
 extern	cvar_t	*cl_consoleKeys;
 
+#ifdef USE_MUMBLE
+extern	cvar_t	*cl_useMumble;
+extern	cvar_t	*cl_mumbleScale;
+#endif
+
+#ifdef USE_VOIP
+// cl_voipSendTarget is a string: "all" to broadcast to everyone, "none" to
+//  send to no one, or a comma-separated list of client numbers:
+//  "0,7,2,23" ... an empty string is treated like "all".
+extern	cvar_t	*cl_voipUseVAD;
+extern	cvar_t	*cl_voipVADThreshold;
+extern	cvar_t	*cl_voipSend;
+extern	cvar_t	*cl_voipSendTarget;
+extern	cvar_t	*cl_voipGainDuringCapture;
+extern	cvar_t	*cl_voipCaptureMult;
+extern	cvar_t	*cl_voipShowMeter;
+extern	cvar_t	*cl_voip;
+
+// 20ms at 48k
+#define VOIP_MAX_FRAME_SAMPLES		( 20 * 48 )
+
+// 3 frame is 60ms of audio, the max opus will encode at once
+#define VOIP_MAX_PACKET_FRAMES		3
+#define VOIP_MAX_PACKET_SAMPLES		( VOIP_MAX_FRAME_SAMPLES * VOIP_MAX_PACKET_FRAMES )
+#endif
+
 extern	cvar_t	*cg_gametype;
 
 extern	cvar_t* j_pitch;
@@ -520,6 +578,7 @@ void IN_MouseOn( void );
 void IN_MouseOff( void );
 
 void CL_InitInput (void);
+void CL_ShutdownInput(void);
 void CL_SendCmd (void);
 void CL_ClearState (void);
 void CL_ReadPackets (void);
@@ -545,6 +604,10 @@ extern int cl_connectedToPureServer;
 extern int cl_connectedToCheatServer;
 extern msg_t *cl_currentMSG;
 
+#ifdef USE_VOIP
+void CL_Voip_f( void );
+#endif
+
 void CL_SystemInfoChanged( void );
 void CL_ParseServerMessage( msg_t *msg );
 
@@ -583,6 +646,7 @@ void Con_DrawCharacter (int cx, int line, int num);
 
 void Con_CheckResize (void);
 void Con_Init (void);
+void Con_Shutdown (void);
 void Con_Clear_f (void);
 void Con_ToggleConsole_f (void);
 void Con_DrawNotify (void);
@@ -670,6 +734,7 @@ void LAN_SaveServersToCache( void );
 void CL_Netchan_Transmit( netchan_t *chan, msg_t* msg);	//int length, const byte *data );
 void CL_Netchan_TransmitNextFragment( netchan_t *chan );
 qboolean CL_Netchan_Process( netchan_t *chan, msg_t *msg );
+void CL_NET_OutOfBandPrint( netadr_t adr, const char* format, ... );
 
 //
 // cl_avi.c

code/client/new/snd_local_new.h

@@ -59,6 +59,9 @@ typedef struct {
 void S_ChannelFree_Callback(channel_t* v);
 void S_LoadData(soundsystemsavegame_t* pSave);
 void S_SaveData(soundsystemsavegame_t* pSave);
+void S_ReLoad(soundsystemsavegame_t* pSave);
+
+extern qboolean s_bSoundPaused;
 
 #ifdef __cplusplus
 }

code/client/new/snd_main_new.cpp

@@ -21,11 +21,24 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "../snd_local.h"
+#include "../client.h"
+
+#if defined(NO_MODERN_DMA) && NO_MODERN_DMA
+
+qboolean s_bSoundPaused = qfalse;
 
 void S_Init2()
 {
     S_Init();
     SND_setup();
+
+    // HACK: S_RegisterSound returns 0 when unsuccessful, or it returns the the sfx handle
+    // But the first sfx handle is also 0...
+    S_RegisterSound("sound/null.wav", qfalse);
+
+    Cmd_AddCommand("tmstart", S_TriggeredMusic_Start);
+    Cmd_AddCommand("tmstartloop", S_TriggeredMusic_StartLoop);
+    Cmd_AddCommand("tmstop", S_TriggeredMusic_Stop);
 }
 
 /*
@@ -46,7 +59,18 @@ S_AddLoopingSound
 */
 void S_AddLoopingSound(const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle, float volume, float minDist, float maxDist, float pitch, int flags)
 {
+    if (!sfxHandle) {
+        return;
+    }
+
     // FIXME: unimplemented
+
+    if (VectorCompare(origin, vec3_origin)) {
+        // Consider it to be a local sound, uses the player origin
+        S_AddLoopingSound(cl.snap.ps.clientNum, cl.snap.ps.origin, velocity, sfxHandle);
+        return;
+    }
+
     S_AddLoopingSound(ENTITYNUM_WORLD, origin, velocity, sfxHandle);
 }
 
@@ -91,7 +115,13 @@ S_StartLocalSoundChannel
 */
 void S_StartLocalSound(const char* sound_name, qboolean force_load)
 {
-    // FIXME: unimplemented
+    sfxHandle_t h;
+
+    h = S_RegisterSound(sound_name, qfalse);
+
+    if (h) {
+        S_StartLocalSound(h, CHAN_LOCAL_SOUND);
+    }
 }
 
 /*
@@ -351,6 +381,16 @@ void MUSIC_CheckForStoppedSongs(void)
     STUB();
 }
 
+/*
+==============
+S_CurrentSoundtrack
+==============
+*/
+const char* S_CurrentSoundtrack()
+{
+    return "";
+}
+
 /*
 =================
 S_IsSoundRegistered
@@ -415,26 +455,166 @@ void S_FadeSound(float fTime)
     // FIXME: unimplemented
 }
 
+/*
+==============
+S_TriggeredMusic_Start
+==============
+*/
+void S_TriggeredMusic_Start()
+{
+    if (Cmd_Argc() != 2) {
+        Com_Printf("tmstart <sound file>\n");
+        return;
+    }
+
+    S_StartBackgroundTrack(Cmd_Argv(1), "");
+}
+
+/*
+==============
+S_TriggeredMusic_StartLoop
+==============
+*/
+void S_TriggeredMusic_StartLoop()
+{
+    if (Cmd_Argc() != 2) {
+        Com_Printf("tmstartloop <sound file>\n");
+        return;
+    }
+
+    S_StartBackgroundTrack(Cmd_Argv(1), Cmd_Argv(1));
+}
+
+/*
+==============
+S_TriggeredMusic_Stop
+==============
+*/
+void S_TriggeredMusic_Stop()
+{
+    S_StopBackgroundTrack();
+}
+
+/*
+==============
+S_TriggeredMusic_PlayIntroMusic
+==============
+*/
 void S_TriggeredMusic_PlayIntroMusic() {
+    S_StartBackgroundTrack("sound/music/mus_MainTheme.mp3", "");
+}
+
+/*
+==============
+S_TriggeredMusic_SetupHandle
+==============
+*/
+void S_TriggeredMusic_SetupHandle(const char* pszName, int iLoopCount, int iOffset, qboolean autostart) {
     // FIXME: unimplemented
 }
 
+/*
+==============
+S_GetMusicFilename
+==============
+*/
+const char* S_GetMusicFilename() {
+    // FIXME: unimplemented
+    return "";
+}
+
+/*
+==============
+S_GetMusicLoopCount
+==============
+*/
+int S_GetMusicLoopCount() {
+    // FIXME: unimplemented
+    return 0;
+}
+
+/*
+==============
+S_GetMusicOffset
+==============
+*/
+unsigned int S_GetMusicOffset() {
+    // FIXME: unimplemented
+    return 0;
+}
+
+/*
+==============
+callbackServer
+==============
+*/
 void callbackServer(int entnum, int channel_number, const char* name) {
     if (com_sv_running->integer) {
         SV_SoundCallback(entnum, channel_number, name);
     }
 }
 
+/*
+==============
+S_ChannelFree_Callback
+==============
+*/
 void S_ChannelFree_Callback(channel_t* v) {
     if (v->entnum & S_FLAG_DO_CALLBACK) {
         callbackServer(v->entnum & ~S_FLAG_DO_CALLBACK, v - s_channels, v->thesfx->soundName);
     }
 }
 
+/*
+==============
+S_LoadData
+==============
+*/
 void S_LoadData(soundsystemsavegame_t* pSave) {
     // FIXME: unimplemented
 }
 
+/*
+==============
+S_SaveData
+==============
+*/
 void S_SaveData(soundsystemsavegame_t* pSave) {
     // FIXME: unimplemented
 }
+
+/*
+==============
+S_ReLoad
+==============
+*/
+void S_ReLoad(soundsystemsavegame_t* pSave) {
+    // FIXME: unimplemented
+}
+
+/*
+==============
+S_StopMovieAudio
+==============
+*/
+void S_StopMovieAudio() {
+}
+
+/*
+==============
+S_CurrentMoviePosition
+==============
+*/
+int S_CurrentMoviePosition() {
+    return 0;
+}
+
+/*
+==============
+S_SetupMovieAudio
+==============
+*/
+void S_SetupMovieAudio(const char* pszMovieName) {
+}
+
+#endif

code/client/new/snd_public_new.h

@@ -64,6 +64,12 @@ qboolean MUSIC_PlaySong(const char* alias);
 void MUSIC_UpdateMusicVolumes(void);
 void MUSIC_CheckForStoppedSongs(void);
 
+void S_TriggeredMusic_Start();
+void S_TriggeredMusic_StartLoop();
+void S_TriggeredMusic_Stop();
+
+const char* S_CurrentSoundtrack();
+
 void S_StopSound(int entnum, int channel);
 void S_StopAllSounds2(qboolean stop_music);
 float S_GetSoundTime(sfxHandle_t handle);
@@ -74,6 +80,15 @@ qboolean S_IsSoundPlaying(int channelNumber, const char* name);
 void S_UpdateEntity(int entityNum, const vec3_t origin, const vec3_t velocity, qboolean use_listener);
 void S_FadeSound(float fTime);
 void S_TriggeredMusic_PlayIntroMusic();
+void S_TriggeredMusic_SetupHandle(const char* pszName, int iLoopCount, int iOffset, qboolean autostart);
+
+const char* S_GetMusicFilename();
+int S_GetMusicLoopCount();
+unsigned int S_GetMusicOffset();
+
+void S_StopMovieAudio();
+int S_CurrentMoviePosition();
+void S_SetupMovieAudio(const char* pszMovieName);
 
 #ifdef __cplusplus
 }

code/client/qal.c

@@ -66,6 +66,7 @@ LPALGETSOURCEF qalGetSourcef;
 LPALGETSOURCE3F qalGetSource3f;
 LPALGETSOURCEFV qalGetSourcefv;
 LPALGETSOURCEI qalGetSourcei;
+LPALGETSOURCEIV qalGetSourceiv;
 LPALSOURCEPLAYV qalSourcePlayv;
 LPALSOURCESTOPV qalSourceStopv;
 LPALSOURCEREWINDV qalSourceRewindv;
@@ -81,6 +82,7 @@ LPALDELETEBUFFERS qalDeleteBuffers;
 LPALISBUFFER qalIsBuffer;
 LPALBUFFERDATA qalBufferData;
 LPALGETBUFFERF qalGetBufferf;
+LPALGETBUFFERFV qalGetBufferfv;
 LPALGETBUFFERI qalGetBufferi;
 LPALDOPPLERFACTOR qalDopplerFactor;
 LPALSPEEDOFSOUND qalSpeedOfSound;
@@ -184,6 +186,7 @@ qboolean QAL_Init(const char *libname)
 	qalGetSource3f = GPA("alGetSource3f");
 	qalGetSourcefv = GPA("alGetSourcefv");
 	qalGetSourcei = GPA("alGetSourcei");
+	qalGetSourceiv = GPA("alGetSourceiv");
 	qalSourcePlayv = GPA("alSourcePlayv");
 	qalSourceStopv = GPA("alSourceStopv");
 	qalSourceRewindv = GPA("alSourceRewindv");
@@ -199,6 +202,7 @@ qboolean QAL_Init(const char *libname)
 	qalIsBuffer = GPA("alIsBuffer");
 	qalBufferData = GPA("alBufferData");
 	qalGetBufferf = GPA("alGetBufferf");
+	qalGetBufferfv = GPA("alGetBufferfv");
 	qalGetBufferi = GPA("alGetBufferi");
 	qalDopplerFactor = GPA("alDopplerFactor");
 	qalSpeedOfSound = GPA("alSpeedOfSound");
@@ -283,6 +287,7 @@ void QAL_Shutdown( void )
 	qalGetSource3f = NULL;
 	qalGetSourcefv = NULL;
 	qalGetSourcei = NULL;
+	qalGetSourceiv = NULL;
 	qalSourcePlayv = NULL;
 	qalSourceStopv = NULL;
 	qalSourceRewindv = NULL;
@@ -298,6 +303,7 @@ void QAL_Shutdown( void )
 	qalIsBuffer = NULL;
 	qalBufferData = NULL;
 	qalGetBufferf = NULL;
+	qalGetBufferfv = NULL;
 	qalGetBufferi = NULL;
 	qalDopplerFactor = NULL;
 	qalSpeedOfSound = NULL;

code/client/qal.h

@@ -55,6 +55,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #  define ALC_ALL_DEVICES_SPECIFIER                0x1013
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #ifdef USE_OPENAL_DLOPEN
 extern LPALENABLE qalEnable;
 extern LPALDISABLE qalDisable;
@@ -248,4 +252,8 @@ extern LPALCCAPTURESAMPLES qalcCaptureSamples;
 qboolean QAL_Init(const char *libname);
 void QAL_Shutdown( void );
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif	// __QAL_H__

code/client/snd_codec.h

@@ -27,6 +27,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "../qcommon/q_shared.h"
 #include "../qcommon/qcommon.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct snd_info_s
 {
 	int rate;
@@ -113,4 +117,8 @@ void S_OggOpus_CodecCloseStream(snd_stream_t *stream);
 int S_OggOpus_CodecReadStream(snd_stream_t *stream, int bytes, void *buffer);
 #endif // USE_CODEC_OPUS
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif // !_SND_CODEC_H_

code/client/snd_codec_mp3.c

@@ -31,7 +31,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "snd_codec.h"
 
 // includes for the MP3 codec
-#include "../libmad-0.15.1b/synth.h"
+#include "mad.h"
 
 #define MP3_SAMPLE_WIDTH		2
 #define MP3_PCMSAMPLES_PERSLICE		32

code/client/snd_dma.c

@@ -161,12 +161,12 @@ void S_Base_SoundList( void ) {
 	char	type[4][16];
 	char	mem[2][16];
 
-	strcpy(type[0], "16bit");
-	strcpy(type[1], "adpcm");
-	strcpy(type[2], "daub4");
-	strcpy(type[3], "mulaw");
-	strcpy(mem[0], "paged out");
-	strcpy(mem[1], "resident ");
+	Q_strncpyz(type[0], "16bit", sizeof(type[0]));
+	Q_strncpyz(type[1], "adpcm", sizeof(type[1]));
+	Q_strncpyz(type[2], "daub4", sizeof(type[2]));
+	Q_strncpyz(type[3], "mulaw", sizeof(type[3]));
+	Q_strncpyz(mem[0], "paged out", sizeof(mem[0]));
+	Q_strncpyz(mem[1], "resident ", sizeof(mem[1]));
 	total = 0;
 	for (sfx=s_knownSfx, i=0 ; i<s_numSfx ; i++, sfx++) {
 		size = sfx->soundLength;
@@ -303,7 +303,7 @@ static sfx_t *S_FindName( const char *name ) {
 	
 	sfx = &s_knownSfx[i];
 	Com_Memset (sfx, 0, sizeof(*sfx));
-	strcpy (sfx->soundName, name);
+	Q_strncpyz (sfx->soundName, name, sizeof(sfx->soundName));
 
 	sfx->next = sfxHash[hash];
 	sfxHash[hash] = sfx;
@@ -785,7 +785,11 @@ void S_Base_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t ve
 	}
 
 	if ( !sfx->soundLength ) {
-		Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+		// Fixed in OPM
+		//  Why should it crash???
+		//Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+		Com_Printf( "%s has length 0\n", sfx->soundName );
+		return;
 	}
 
 	VectorCopy( origin, loopSounds[entityNum].origin );
@@ -848,7 +852,11 @@ void S_Base_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_
 	}
 
 	if ( !sfx->soundLength ) {
-		Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+		// Fixed in OPM
+		//  Why should it crash???
+		//Com_Error( ERR_DROP, "%s has length 0", sfx->soundName );
+		Com_Printf( "%s has length 0", sfx->soundName );
+		return;
 	}
 	VectorCopy( origin, loopSounds[entityNum].origin );
 	VectorCopy( velocity, loopSounds[entityNum].velocity );
@@ -1581,7 +1589,9 @@ qboolean S_Base_Init( soundInterface_t *si ) {
 
 	if ( r ) {
 		s_soundStarted = 1;
-		s_soundMuted = 1;
+// Fixed in OPM
+//  The UI must be able to play sounds
+//		s_soundMuted = 1;
 //		s_numSfx = 0;
 
 		Com_Memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);

code/client/snd_dma_new.cpp

@@ -0,0 +1,826 @@
+/*
+===========================================================================
+Copyright (C) 2024 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+#include "snd_local.h"
+#include "snd_openal_new.h"
+#include "client.h"
+#include "cl_ui.h"
+
+typedef struct {
+    vec3_t origin;
+    vec3_t velocity;
+    sfx_t *sfx;
+    int    mergeFrame;
+} loopSound_t;
+
+qboolean s_bLastInitSound  = qfalse;
+qboolean s_bSoundStarted   = qfalse;
+qboolean s_bSoundPaused    = qfalse;
+qboolean s_bTryUnpause     = qfalse;
+int      s_iListenerNumber = 0;
+float    s_fAmbientVolume  = 1.f;
+
+int number_of_sfx_infos = 0;
+
+cvar_t *s_volume;
+cvar_t *s_loadas8bit;
+cvar_t *s_khz;
+cvar_t *s_show;
+cvar_t *s_testsound;
+cvar_t *s_separation;
+cvar_t *s_musicVolume;
+cvar_t *s_ambientVolume;
+
+sfx_info_t sfx_infos[MAX_SFX_INFOS];
+
+sfx_t s_knownSfx[MAX_SFX];
+int   s_numSfx;
+
+s_entity_t s_entity[MAX_GENTITIES];
+
+static int      s_registrationSequence;
+static qboolean s_inRegistration;
+
+cvar_t *s_mixPreStep;
+cvar_t *s_dialogscale;
+
+int         numLoopSounds;
+loopSound_t loopSounds[MAX_LOOP_SOUNDS];
+
+/*
+==============
+S_SoundInfo_f
+==============
+*/
+void S_SoundInfo_f()
+{
+    S_PrintInfo();
+}
+
+/*
+==============
+S_SoundDump_f
+==============
+*/
+void S_SoundDump_f()
+{
+    S_DumpInfo();
+}
+
+/*
+==============
+S_Init
+==============
+*/
+void S_Init(qboolean full_startup)
+{
+    int     iStart, iEnd;
+    cvar_t *cv;
+
+    Com_Printf("------- Sound Initialization (%s) -------\n", full_startup ? "full" : "partial");
+
+    iStart = Sys_Milliseconds();
+
+    s_volume         = Cvar_Get("s_volume", "0.9", CVAR_ARCHIVE);
+    s_musicVolume    = Cvar_Get("s_musicvolume", "0.9", CVAR_ARCHIVE);
+    s_ambientVolume  = Cvar_Get("s_ambientvolume", "1.00", CVAR_ARCHIVE);
+    s_separation     = Cvar_Get("s_separation", "0.5", CVAR_ARCHIVE);
+    s_khz            = Cvar_Get("s_khz", "11", CVAR_ARCHIVE | CVAR_SOUND_LATCH);
+    s_loadas8bit     = Cvar_Get("s_loadas8bit", "0", CVAR_ARCHIVE | CVAR_LATCH);
+    s_mixPreStep     = Cvar_Get("s_mixPreStep", "0.05", CVAR_ARCHIVE);
+    s_show           = Cvar_Get("s_show", "0", CVAR_CHEAT);
+    s_testsound      = Cvar_Get("s_testsound", "0", CVAR_CHEAT);
+    s_dialogscale    = Cvar_Get("s_dialogscale", "1", CVAR_ARCHIVE);
+    s_bLastInitSound = false;
+
+    cv = Cvar_Get("s_initsound", "1", 0);
+
+    if (cv->integer) {
+        Cmd_AddCommand("play", S_Play);
+        Cmd_AddCommand("soundlist", S_SoundList);
+        Cmd_AddCommand("soundinfo", S_SoundInfo_f);
+        Cmd_AddCommand("sounddump", S_SoundDump_f);
+
+        if (S_Driver_Init()) {
+            s_bLastInitSound = true;
+            s_bSoundStarted  = true;
+
+            if (full_startup) {
+                s_numSfx = 0;
+                S_StopAllSounds(true);
+            }
+
+            S_FindName("***DEFAULT***", -1);
+            S_SoundInfo_f();
+        }
+    } else {
+        Com_Printf("Sound Not Initializing.\n");
+        s_bSoundStarted = 0;
+    }
+
+    iEnd = Sys_Milliseconds();
+    Com_Printf("------- Sound Initialization Complete ------- %i ms\n", iEnd - iStart);
+}
+
+/*
+==============
+S_Shutdown
+==============
+*/
+void S_Shutdown(qboolean full_shutdown)
+{
+    int    i;
+    sfx_t *sfx;
+
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    Com_Printf("------- Sound Shutdown (%s) -------\n", full_shutdown ? "full" : "partial");
+
+    S_Driver_Shutdown();
+    s_bSoundStarted = false;
+
+    Cmd_RemoveCommand("play");
+    Cmd_RemoveCommand("music");
+    Cmd_RemoveCommand("stopsound");
+    Cmd_RemoveCommand("soundlist");
+    Cmd_RemoveCommand("soundinfo");
+
+    if (full_shutdown) {
+        for (i = 0; i < s_numSfx; i++) {
+            sfx = &s_knownSfx[i];
+
+            if (sfx->name[0]) {
+                if (sfx->data) {
+                    Z_Free(sfx->data);
+                }
+
+                *sfx = {};
+            }
+        }
+
+        s_numSfx = 0;
+    }
+
+    Com_Printf("------- Sound Shutdown Complete -------\n");
+}
+
+/*
+==============
+S_NameExists
+==============
+*/
+qboolean S_NameExists(const char *name)
+{
+    int i;
+
+    if (strlen(name) >= MAX_RES_NAME) {
+        Com_DPrintf("Sound name too long: %s", name);
+        return qfalse;
+    }
+
+    for (i = 0; i < s_numSfx; i++) {
+        if (!strcmp(s_knownSfx[i].name, name)) {
+            return qtrue;
+        }
+    }
+
+    return qfalse;
+}
+
+/*
+==============
+S_FindName
+==============
+*/
+sfx_t *S_FindName(const char *name, int sequenceNumber)
+{
+    int    i;
+    sfx_t *sfx;
+
+    if (!name) {
+        Com_DPrintf("S_FindName: NULL\n");
+        return NULL;
+    }
+
+    if (!name[0]) {
+        Com_DPrintf("S_FindName: empty name\n");
+        return NULL;
+    }
+
+    if (strlen(name) >= MAX_RES_NAME) {
+        Com_DPrintf("Sound name too long: %s", name);
+        return NULL;
+    }
+
+    for (i = 0; i < s_numSfx; i++) {
+        sfx = &s_knownSfx[i];
+
+        if (!strcmp(sfx->name, name)) {
+            if (sfx->registration_sequence != -1) {
+                sfx->registration_sequence = sequenceNumber;
+            }
+
+            return sfx;
+        }
+    }
+
+    sfx = &s_knownSfx[0];
+
+    for (i = 0; i < s_numSfx; i++) {
+        sfx = &s_knownSfx[i];
+        if (!sfx->name[0]) {
+            break;
+        }
+    }
+
+    if (i == s_numSfx) {
+        if (i == MAX_SFX) {
+            Com_Error(ERR_FATAL, "S_FindName: out of sfx_t");
+        }
+
+        sfx = &s_knownSfx[s_numSfx];
+        s_numSfx++;
+    }
+
+    *sfx = {};
+    // Fixed in OPM
+    //  strcpy was used before
+    //strcpy(sfx->name, name);
+    Q_strncpyz(sfx->name, name, sizeof(sfx->name));
+    sfx->registration_sequence = sequenceNumber;
+
+    return sfx;
+}
+
+/*
+==============
+S_BeginRegistration
+==============
+*/
+void S_BeginRegistration()
+{
+    int i;
+
+    Com_Printf("------- Sound Begin Registration -------\n");
+
+    S_StopAllSounds(true);
+
+    s_registrationSequence++;
+    s_inRegistration                    = true;
+    s_knownSfx[0].registration_sequence = s_registrationSequence;
+
+    Com_Printf("------- Sound Begin Registration Complete -------\n");
+
+    // Added in OPM
+    //  Reset all sound entities
+    //  OG doesn't do this but this makes sure
+    //  entities don't leak info from previous sessions
+    for (i = 0; i < ARRAY_LEN(s_entity); i++) {
+        s_entity[i] = s_entity_t{};
+    }
+}
+
+/*
+==============
+S_DefaultSound
+==============
+*/
+void S_DefaultSound(sfx_t *sfx)
+{
+    sfx->data = NULL;
+    sfx->iFlags |= SFX_FLAG_DEFAULT_SOUND;
+}
+
+/*
+==============
+S_IsSoundRegistered
+==============
+*/
+qboolean S_IsSoundRegistered(const char *name)
+{
+    char szCacheName[MAX_QPATH];
+    int  i;
+
+    if (!s_bSoundStarted) {
+        return qfalse;
+    }
+
+    for (i = 0; name[i] && i < MAX_QPATH; i++) {
+        szCacheName[i] = tolower(name[i]);
+    }
+    szCacheName[i] = 0;
+
+    if (i >= MAX_QPATH) {
+        Com_Printf("Sound name exceeds MAX_QPATH\n");
+        return qfalse;
+    }
+
+    return S_NameExists(szCacheName);
+}
+
+/*
+==============
+S_RegisterSound
+==============
+*/
+sfxHandle_t S_RegisterSound(const char *name, int streamed, qboolean force_load)
+{
+    char   szCacheName[MAX_QPATH];
+    sfx_t *sfx;
+    int    i;
+
+    if (!s_bSoundStarted) {
+        Com_Printf("ERROR:  Trying to register sound %s when soundsystem hasn't started.\n", name);
+        return 0;
+    }
+
+    if (!name) {
+        return 0;
+    }
+
+    for (i = 0; name[i] && i < MAX_QPATH; i++) {
+        szCacheName[i] = tolower(name[i]);
+    }
+    szCacheName[i] = 0;
+
+    if (i >= MAX_QPATH) {
+        Com_Printf("Sound name exceeds MAX_QPATH\n");
+        return 0;
+    }
+
+    sfx = S_FindName(szCacheName, s_registrationSequence);
+    if (!sfx) {
+        return 0;
+    }
+
+    if (!sfx->data) {
+        if (!S_LoadSound(sfx->name, sfx, streamed, force_load)) {
+            Com_DPrintf("Couldn't load sound: %s\n", sfx->name);
+            if (!S_LoadSound("sound/default.wav", sfx, streamed, 0)) {
+                Com_DPrintf("Couldn't load sound: sound/default.wav\n");
+                sfx->iFlags |= SFX_FLAG_DEFAULT_SOUND;
+                return 0;
+            }
+        }
+
+        sfx->iFlags &= ~SFX_FLAG_DEFAULT_SOUND;
+        sfx->sfx_info_index = 0;
+
+        for (i = 0; i < number_of_sfx_infos; i++) {
+            if (!Q_stricmp(sfx->name, sfx_infos[i].name)) {
+                sfx->sfx_info_index = i;
+                break;
+            }
+        }
+    }
+
+    return sfx - s_knownSfx;
+}
+
+/*
+==============
+S_GetSoundTime
+==============
+*/
+float S_GetSoundTime(sfxHandle_t handle)
+{
+    return s_knownSfx[handle].time_length;
+}
+
+/*
+==============
+S_EndRegistration
+==============
+*/
+void S_EndRegistration()
+{
+    int    i;
+    sfx_t *sfx;
+
+    Com_Printf("------- Sound End Registration -------\n");
+    s_inRegistration = qfalse;
+
+    for (i = 0; i < s_numSfx; i++) {
+        sfx = &s_knownSfx[i];
+
+        if (!sfx->name[0]) {
+            continue;
+        }
+
+        if (sfx->registration_sequence && sfx->registration_sequence != s_registrationSequence) {
+            if (sfx->data) {
+                Z_Free(sfx->data);
+            }
+
+            *sfx = {};
+        }
+    }
+
+    Com_Printf("------- Sound End Registration Complete -------\n");
+}
+
+/*
+==============
+S_UpdateEntity
+==============
+*/
+void S_UpdateEntity(int entityNum, const vec3_t origin, const vec3_t vel, qboolean use_listener)
+{
+    if (entityNum > MAX_GENTITIES) {
+        Com_Error(ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum);
+    }
+
+    VectorCopy(origin, s_entity[entityNum].position);
+    VectorCopy(vel, s_entity[entityNum].velocity);
+    s_entity[entityNum].use_listener = use_listener;
+    s_entity[entityNum].time         = cl.serverTime;
+}
+
+/*
+==============
+S_SetGlobalAmbientVolumeLevel
+==============
+*/
+void S_SetGlobalAmbientVolumeLevel(float volume)
+{
+    s_fAmbientVolume = volume;
+}
+
+/*
+==============
+S_StartSound
+==============
+*/
+void S_StartSound(
+    const vec3_t origin,
+    int          entnum,
+    int          entchannel,
+    sfxHandle_t  sfxHandle,
+    float        volume,
+    float        min_dist,
+    float        pitch,
+    float        maxDist,
+    int          streamed
+)
+{
+    if (s_show_sounds->integer > 0 && sfxHandle > 0 && sfxHandle < s_numSfx) {
+        Com_DPrintf("S_StartSound: %s\n", s_knownSfx[sfxHandle].name);
+    }
+
+    if (!s_bSoundStarted) {
+        if (s_show_sounds->integer > 0) {
+            Com_DPrintf("^~^~^ sound system not yet started\n");
+        }
+        return;
+    }
+
+    if (server_loading) {
+        if (s_show_sounds->integer > 0) {
+            Com_DPrintf("^~^~^ cannot start sounds while loading a server\n");
+        }
+        return;
+    }
+
+    if (sfxHandle < 0 || sfxHandle >= s_numSfx) {
+        Com_Error(ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle);
+    }
+
+    if (!sfxHandle) {
+        if (s_show_sounds->integer > 0) {
+            Com_DPrintf("^~^~^ null handle\n");
+        }
+        return;
+    }
+
+    if (entnum && (entchannel == CHAN_DIALOG || entchannel == CHAN_DIALOG_SECONDARY) && s_dialogscale->value > 0) {
+        volume *= s_dialogscale->value;
+    }
+
+    S_Driver_StartSound(origin, entnum, entchannel, sfxHandle, volume, min_dist, pitch, maxDist, streamed);
+}
+
+/*
+==============
+S_StartLocalSound
+==============
+*/
+void S_StartLocalSound(const char *sound_name, qboolean force_load)
+{
+    sfxHandle_t      sfxHandle;
+    const char      *name;
+    AliasListNode_t *pSoundAlias = NULL;
+
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    if (!sound_name) {
+        return;
+    }
+
+    name = Alias_FindRandom(sound_name, &pSoundAlias);
+    if (!name) {
+        name = sound_name;
+    }
+
+    sfxHandle = S_RegisterSound(name, pSoundAlias ? pSoundAlias->streamed : qfalse, force_load);
+
+    if (!pSoundAlias) {
+        S_StartSound(NULL, s_iListenerNumber, CHAN_MENU, sfxHandle, -1.0, -1.0, 1.0, -1.0, qfalse);
+        return;
+    }
+
+    S_StartSound(
+        0,
+        s_iListenerNumber,
+        CHAN_MENU,
+        sfxHandle,
+        pSoundAlias->volume + random() * pSoundAlias->volumeMod,
+        -1.0,
+        pSoundAlias->pitch + random() * pSoundAlias->pitchMod,
+        pSoundAlias->maxDist,
+        pSoundAlias->streamed
+    );
+}
+
+/*
+==============
+S_StartLocalSoundChannel
+
+Added in 2.0
+Starts a local sound, with the specified channel
+==============
+*/
+void S_StartLocalSoundChannel(const char *sound_name, qboolean force_load, soundChannel_t channel)
+{
+    sfxHandle_t      sfxHandle;
+    const char      *name;
+    AliasListNode_t *pSoundAlias = NULL;
+
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    if (!sound_name) {
+        return;
+    }
+
+    name = Alias_FindRandom(sound_name, &pSoundAlias);
+    if (!name) {
+        name = sound_name;
+    }
+
+    sfxHandle = S_RegisterSound(name, pSoundAlias ? pSoundAlias->streamed : qfalse, force_load);
+
+    if (!pSoundAlias) {
+        S_StartSound(NULL, s_iListenerNumber, channel, sfxHandle, -1.0, -1.0, 1.0, -1.0, qfalse);
+        return;
+    }
+
+    S_StartSound(
+        0,
+        s_iListenerNumber,
+        channel,
+        sfxHandle,
+        pSoundAlias->volume + random() * pSoundAlias->volumeMod,
+        -1.0,
+        pSoundAlias->pitch + random() * pSoundAlias->pitchMod,
+        pSoundAlias->maxDist,
+        pSoundAlias->streamed
+    );
+}
+
+/*
+==============
+S_StopAllSounds
+==============
+*/
+void S_StopAllSounds(qboolean stop_music)
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    Com_Printf("------- S_StopAllSounds (%s) -------\n", stop_music ? "stop music" : "don't stop music");
+
+    // Tell the driver to stop all sounds
+    S_Driver_StopAllSounds(stop_music);
+
+    Com_Printf("------- S_StopAllSounds Complete-------\n");
+}
+
+/*
+==============
+S_ClearLoopingSounds
+==============
+*/
+void S_ClearLoopingSounds()
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    S_Driver_ClearLoopingSounds();
+}
+
+/*
+==============
+S_AddLoopingSound
+==============
+*/
+void S_AddLoopingSound(
+    const vec3_t origin,
+    const vec3_t velocity,
+    sfxHandle_t  sfxHandle,
+    float        volume,
+    float        min_dist,
+    float        max_dist,
+    float        pitch,
+    int          flags
+)
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    if (sfxHandle < 0 || sfxHandle >= s_numSfx) {
+        Com_Error(ERR_DROP, "S_AddLoopingSound: handle %i out of range", sfxHandle);
+    }
+
+    if (!sfxHandle) {
+        return;
+    }
+
+    S_Driver_AddLoopingSound(origin, velocity, sfxHandle, volume, min_dist, max_dist, pitch, flags);
+}
+
+/*
+==============
+S_Respatialize
+==============
+*/
+void S_Respatialize(int entityNum, const vec3_t head, vec3_t axis[3])
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    S_Driver_Respatialize(entityNum, head, axis);
+}
+
+/*
+==============
+S_Update
+==============
+*/
+void S_Update()
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    if (server_loading) {
+        return;
+    }
+
+    S_Driver_Update();
+}
+
+/*
+==============
+S_StopSound
+==============
+*/
+void S_StopSound(int entnum, int channel)
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    if (channel == CHAN_AUTO) {
+        return;
+    }
+
+    S_Driver_StopSound(entnum, channel);
+}
+
+/*
+==============
+S_SetReverb
+==============
+*/
+void S_SetReverb(int reverb_type, float reverb_level)
+{
+    if (!s_bSoundStarted) {
+        return;
+    }
+
+    S_Driver_SetReverb(reverb_type, reverb_level);
+}
+
+/*
+==============
+S_Play
+==============
+*/
+void S_Play()
+{
+    int  i;
+    char name[MAX_QPATH];
+
+    for (i = 1; i < Cmd_Argc(); i++) {
+        if (strrchr(Cmd_Argv(i), '.')) {
+            Q_strncpyz(name, Cmd_Argv(i), sizeof(name));
+        } else {
+            Com_sprintf(name, sizeof(name), "%s.wav", Cmd_Argv(1));
+        }
+    }
+
+    S_StartLocalSound(name, qfalse);
+}
+
+/*
+==============
+S_SoundList
+==============
+*/
+void S_SoundList()
+{
+    int    i;
+    sfx_t *sfx;
+    int    size;
+    int    total = 0;
+
+    for (i = 0; i < s_numSfx; i++) {
+        sfx = &s_knownSfx[i];
+
+        if (sfx->registration_sequence) {
+            size = sfx->length * sfx->width;
+            total += size;
+            Com_Printf("(%2db) %6i : %s\n", sfx->width * 8, size, sfx->name);
+        }
+    }
+
+    Com_Printf("Total resident: %i\n", total);
+}
+
+/*
+==============
+S_ClearSoundBuffer
+==============
+*/
+void S_ClearSoundBuffer()
+{
+    // TODO: Remove once AL is fully implemented
+}
+
+/*
+==============
+S_GetMusicFilename
+==============
+*/
+const char* S_GetMusicFilename()
+{
+    return S_Driver_GetMusicFilename();
+}
+
+/*
+==============
+S_GetMusicLoopCount
+==============
+*/
+int S_GetMusicLoopCount()
+{
+    return S_Driver_GetMusicLoopCount();
+}
+
+/*
+==============
+S_GetMusicOffset
+==============
+*/
+unsigned int S_GetMusicOffset()
+{
+    return S_Driver_GetMusicOffset();
+}