Rename latest prerelease to dev

This caused issues such as clients crashing as they were improperly unregistering used models

.github/workflows/branches-build.yml

@@ -0,0 +1,76 @@
+name: "Builds"
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+
+jobs:
+  build-all:
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: 'testing'
+
+  # Initially create a release with 1 job
+  # so multiple files can be uploaded at the same time afterwards
+  create-release:
+    runs-on: ubuntu-24.04
+    environment: 'testing'
+    needs: [build-all]
+
+    steps:
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        prerelease: true
+        name: '${{github.ref_name}}-${{github.sha}}'
+        tag_name: 'dev'
+
+  deploy-release:
+    if: github.event_name != 'pull_request' && github.ref_name == 'main'
+    strategy:
+      matrix:
+        target_os: [
+          'linux-amd64',
+          'linux-i686',
+          'linux-arm64',
+          'linux-armhf',
+          'linux-powerpc',
+          'linux-ppc64',
+          'linux-ppc64el',
+          'windows-x64-pdb',
+          'windows-x86-pdb',
+          'windows-arm64-pdb',
+          'macos-multiarch-arm64-x86_64',
+        ]
+
+    runs-on: ubuntu-24.04
+    environment: 'testing'
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{github.event.repository.name}}-dev-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Zip
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run: zip -r "../${{env.RELEASE_NAME}}.zip" ./
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        tag_name: 'dev'
+        files: ${{github.workspace}}/${{env.RELEASE_NAME}}.zip

.github/workflows/build-cmake.yml

@@ -1,256 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches:
-      - '**'
-  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: '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
-
-    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 \
-            libpulse-dev portaudio19-dev libasound2-dev libjack-dev libpipewire-0.3-dev qtbase5-dev libdbus-1-dev
-  
-    - 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 }}"
-
-    # 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.23.1'
-
-    - name: Configure and install soft-oal
-      working-directory: ${{github.workspace}}/thirdparties/soft-oal
-      run: |
-        cmake -B ./build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
-        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install' \
-        -DCMAKE_C_COMPILER=${{ matrix.architecture.triple }}-gcc-12 \
-        -DCMAKE_CXX_COMPILER=${{ matrix.architecture.triple }}-g++-12
-        cmake --build ./build --config ${{env.BUILD_TYPE}}
-        cmake --install ./build --config ${{env.BUILD_TYPE}}
-
-    - uses: actions/checkout@v4
-      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 }} \
-        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal' \
-        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/include' \
-        -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}}
-        # Create hard-link and copy symbolic links
-        cp -l ${{steps.sdl.outputs.prefix}}/lib/libSDL2-2.0.so.0 '${{github.workspace}}/install/'
-        cp -l ${{github.workspace}}/thirdparties/soft-oal/install/lib/libopenal.so.1 '${{github.workspace}}/install/'
-
-    - uses: actions/upload-artifact@v4
-      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
-
-    # soft-oal setup
-    - name: Checkout soft-oal
-      uses: actions/checkout@v4
-      with:
-        repository: 'kcat/openal-soft'
-        path: 'thirdparties/soft-oal'
-        ref: '1.23.1'
-
-    # 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 -A ${{ matrix.architecture.config }} `
-        -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} `
-        -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 ${{env.BUILD_TYPE}}
-        cmake --install ./build --config ${{env.BUILD_TYPE}}
-        # 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' }
-
-    - uses: actions/checkout@v4
-      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' `
-        -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'".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'
-        Copy-Item '${{github.workspace}}/thirdparties/soft-oal/install/bin/*.dll' -Destination '${{github.workspace}}/install'
-
-    - uses: actions/upload-artifact@v4
-      with:
-        name: out-windows-${{matrix.architecture.name}}
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install
-          !${{github.workspace}}/install/**/*.pdb
-
-    - uses: actions/upload-artifact@v4
-      with:
-        name: out-windows-${{matrix.architecture.name}}-pdb
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install

.github/workflows/doxygen-publish.yml

@@ -0,0 +1,60 @@
+name: "Generate Documentation"
+
+on:
+    push:
+      branches:
+        - 'main'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get and install Doxygen
+        run: |
+            wget https://github.com/doxygen/doxygen/releases/download/Release_1_13_2/doxygen-1.13.2.linux.bin.tar.gz -O doxygen.tar.gz
+            tar xzf doxygen.tar.gz
+            cd doxygen-*
+            sudo cp bin/doxygen /usr/local/bin/
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: 'source'
+
+      - name: Generate Documentation (Doxygen)
+        working-directory: ${{github.workspace}}/source
+        run: |
+            version_file=$(cat code/qcommon/q_version.h)
+            PRODUCT_VERSION_MAJOR=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_MAJOR" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            PRODUCT_VERSION_MINOR=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_MINOR" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            PRODUCT_VERSION_PATCH=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_PATCH" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            export PROJECT_VERSION_NUMBER="$PRODUCT_VERSION_MAJOR.$PRODUCT_VERSION_MINOR.$PRODUCT_VERSION_PATCH"
+            doxygen docs/Doxyfile
+
+      - name: Upload static files as artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ${{github.workspace}}/source/docs/doxygen/html
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    needs: build
+
+    # Permissions for deploying the page
+    permissions:
+      pages: write
+      id-token: write
+
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+

.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
@@ -43,6 +47,12 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v4
 
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: libopenal-dev libpulse-dev portaudio19-dev libasound2-dev libjack-dev libpipewire-0.3-dev qtbase5-dev libdbus-1-dev
+        version: "0.1"
+
     # Setup SDL
     - name: Set up SDL
       id: sdl

.github/workflows/publish-release.yml

@@ -1,63 +0,0 @@
-name: Publish artifacts
-
-on:
-  push:
-    tags:
-        - "v*.*.*"
-
-env:
-  RELEASE_TYPE: ${{ vars.RELEASE_TYPE || 'test' }}
-  RELEASE_IS_PRERELEASE: ${{ vars.RELEASE_IS_PRELEASE }}
-
-permissions:
-  contents: write
-
-jobs:
-  build-all:
-   uses: ./.github/workflows/build-cmake.yml
-
-  deploy_all:
-    strategy:
-      # Set the maximum number of parallel jobs to 1, to avoid a race-condition
-      # while creating a new release
-      max-parallel: 1
-      matrix:
-        target_os: [
-          'linux-amd64',
-          'linux-i686',
-          'linux-arm64',
-          'linux-armhf',
-          'linux-powerpc',
-          'linux-ppc64',
-          'linux-ppc64el',
-          'windows-x64',
-          'windows-x86',
-          'windows-x64-pdb',
-          'windows-x86-pdb',
-          'windows-arm64',
-          'windows-arm64-pdb'
-        ]
-
-    runs-on: ubuntu-22.04
-    environment: release
-    needs: [build-all]
-
-    env:
-      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
-
-    steps:
-    - uses: actions/download-artifact@v4
-      with:
-        name: 'out-${{matrix.target_os}}'
-        path: ${{github.workspace}}/${{matrix.target_os}}
-
-    - name: Zip
-      working-directory: ${{github.workspace}}/${{matrix.target_os}}
-      run: zip -r ../${{ env.RELEASE_NAME }}.zip ./
-
-    - name: Release
-      uses: softprops/action-gh-release@v2
-      with:
-        name: '${{github.ref_name}}-${{env.RELEASE_TYPE}}'
-        prerelease: ${{env.RELEASE_IS_PRERELEASE}}
-        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.zip

.github/workflows/shared-build-linux.yml

@@ -0,0 +1,238 @@
+##########################
+#
+# Linux
+# Ubuntu 22.04
+#
+# Using this version instead of 24.04 to use a lower GLIBC version (2.34).
+# ARM is used for more efficiency, and x64 is used for legacy architectures like PowerPC.
+##########################
+name: "Linux Builds"
+
+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:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'amd64',   os: "ubuntu-22.04-arm", package: 'x86-64-linux-gnu',      triple: 'x86_64-linux-gnu',      arch_option: 'linux-x86_64'},
+          {name: 'i686',    os: "ubuntu-22.04-arm", package: 'i686-linux-gnu',        triple: 'i686-linux-gnu',        arch_option: 'linux-x86'},
+          {name: 'arm64',   os: "ubuntu-22.04-arm", package: 'aarch64-linux-gnu',     triple: 'aarch64-linux-gnu',     arch_option: 'linux-aarch64'},
+          {name: 'armhf',   os: "ubuntu-22.04-arm", package: 'arm-linux-gnueabihf',   triple: 'arm-linux-gnueabihf',   arch_option: 'linux-armv4'},
+          {name: 'powerpc', os: "ubuntu-22.04",     package: 'powerpc-linux-gnu',     triple: 'powerpc-linux-gnu',     arch_option: 'linux-ppc'},
+          {name: 'ppc64',   os: "ubuntu-22.04",     package: 'powerpc64-linux-gnu',   triple: 'powerpc64-linux-gnu',   arch_option: 'linux-ppc64'},
+          {name: 'ppc64el', os: "ubuntu-22.04-arm", package: 'powerpc64le-linux-gnu', triple: 'powerpc64le-linux-gnu', arch_option: 'linux-ppc64le'}
+        ]
+
+    name: "Building for platform linux-${{matrix.architecture.name}}"
+    runs-on: ${{ matrix.architecture.os }}
+    environment: ${{ inputs.environment }}
+    env:
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+        openal-soft-branch: '1.24.3'
+
+    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: "${{ runner.os }}-${{ runner.arch }}-v1"
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "HOST_TRIPLE=$(gcc -dumpmachine)" >> $GITHUB_ENV
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required cross-platform packages (${{ matrix.architecture.package }})
+      if: env.HOST_TRIPLE != matrix.architecture.triple
+      with:
+        packages: gcc-12-${{ matrix.architecture.package }} g++-12-${{ matrix.architecture.package }}
+        version: "${{ runner.os }}-${{ runner.arch }}-v1"
+
+    - 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
+
+    ###
+    # 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
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build \
+        -DALSOFT_UTILS=OFF \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # WolfSSL
+    ###
+    - name: Cache WolfSSL
+      id: cache-wolfssl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/wolfssl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-wolfssl-${{ env.wolfssl-version }}-v1
+
+    # WolfSSL setup
+    - name: Checkout WolfSSL
+      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'wolfssl/wolfssl'
+        path: 'thirdparties/wolfssl'
+        ref: '${{ env.wolfssl-version }}'
+
+    # WolfSSL build
+    - name: Configure and install wolfssl
+      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/wolfssl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/wolfssl/install' \
+            -DCMAKE_C_FLAGS="$CFLAGS -fPIC" \
+            -DCMAKE_CXX_FLAGS="$CFLAGS -fPIC" \
+            -DBUILD_SHARED_LIBS=OFF -DWOLFSSL_OPENSSLEXTRA=ON -DWOLFSSL_ASM=OFF -DWOLFSSL_EXAMPLES=OFF -DWOLFSSL_CURL=ON
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # cURL
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' \
+            -DCURL_USE_LIBPSL=OFF \
+            -DCURL_USE_WOLFSSL=ON \
+            -DCURL_ZLIB="" \
+            -DCURL_BROTLI="" \
+            -DCURL_ZSTD="" \
+            -DCMAKE_SHARED_LINKER_FLAGS="-lm" \
+            -DWolfSSL_ROOT='${{github.workspace}}/thirdparties/wolfssl/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/install/include' \
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' \
+        -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: 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/'
+        cp -l ${{github.workspace}}/thirdparties/curl/install/lib*/libcurl.so.4 '${{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

.github/workflows/shared-build-macos.yml

@@ -0,0 +1,231 @@
+##########################
+#
+# Apple macOS
+# macOS 15
+#
+# This version is used as the OS, as it's faster than other versions.
+##########################
+name: "macOS Builds"
+
+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:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          #{name: 'x86_64',   triple: 'x86_64-apple-macos10.8'},
+          #{name: 'arm64',    triple: 'arm64-apple-macos11'}
+          #{name: 'x86_64',    build_name: 'x86_64'},
+          #{name: 'arm64',     build_name: 'arm64'},
+          # Compile into an universal binary
+          {name: 'multiarch-arm64-x86_64', build_name: 'arm64;x86_64' }
+        ]
+
+    name: "Building for platform macos-${{matrix.architecture.name}}"
+    runs-on: "macos-15"
+    env:
+        openal-soft-branch: '1.24.3'
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - name: Install required packages
+      run: |
+        brew install git flex bison ninja cmake llvm perl
+
+    - 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.build_name }}'
+          -DCMAKE_VERBOSE_MAKEFILE=on"
+
+    ###
+    # OpenAL
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # 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
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    # soft-oal build
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      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.build_name }}' \
+        -DCMAKE_VERBOSE_MAKEFILE=on
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # WolfSSL
+    ###
+# FIXME: Figure out how to compile WolfSSL cross-architecture
+#
+#    - name: Cache WolfSSL
+#      id: cache-wolfssl
+#      uses: actions/cache@v4
+#      with:
+#        path: 'thirdparties/wolfssl_install'
+#        key: ${{ runner.os }}-${{ matrix.architecture.name }}-wolfssl-${{ env.wolfssl-version }}-v1
+#
+#    # WolfSSL setup
+#    - name: Checkout WolfSSL
+#      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+#      uses: actions/checkout@v4
+#      with:
+#        repository: 'wolfssl/wolfssl'
+#        path: 'thirdparties/wolfssl'
+#        ref: '${{ env.wolfssl-version }}'
+#
+#    # WolfSSL build
+#    - name: Configure and install wolfssl
+#      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+#      working-directory: ${{github.workspace}}/thirdparties/wolfssl
+#      run: |
+#        cmake -B ./build \
+#            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/wolfssl_install' \
+#            -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+#            -DBUILD_SHARED_LIBS=OFF -DWOLFSSL_OPENSSLEXTRA=ON -DWOLFSSL_ASM=OFF -DWOLFSSL_EXAMPLES=OFF -DWOLFSSL_CURL=ON
+#        cmake --build ./build --config Release --parallel
+#        cmake --install ./build --config Release
+
+    ###
+    # cURL
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' \
+            -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+            -DCURL_USE_LIBPSL=OFF \
+            -DCURL_USE_WOLFSSL=OFF \
+            -DCURL_USE_LIBSSH2=OFF \
+            -DUSE_LIBIDN2=OFF \
+            -DUSE_NGHTTP2=OFF \
+            -DCURL_ENABLE_SSL=OFF \
+            -DCURL_ZLIB="" \
+            -DCURL_BROTLI="" \
+            -DCURL_ZSTD="" \
+            -DWolfSSL_ROOT='${{github.workspace}}/thirdparties/wolfssl_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' \
+        -DCMAKE_VERBOSE_MAKEFILE=on \
+        -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal/install' \
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/install/include/AL' \
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' \
+        -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: 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/'
+        cp -l ${{github.workspace}}/thirdparties/curl/install/lib*/libcurl.4.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/shared-build-windows.yml

@@ -0,0 +1,266 @@
+##########################
+#
+# Microsoft Windows
+# Windows Server 2025
+#
+##########################
+name: "Windows Builds"
+
+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:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'x64',   os: 'windows-2025',   config: 'x64',    toolset: 'x64',        arch_option: 'VC-WIN64A'    },
+          {name: 'x86',   os: 'windows-2025',   config: 'Win32',  toolset: 'x64_x86',    arch_option: 'VC-WIN32'     },
+          {name: 'arm64', os: 'windows-11-arm', config: 'ARM64',  toolset: 'x64_arm64',  arch_option: 'VC-WIN64-ARM' }
+        ]
+
+    name: "Building for platform windows-${{matrix.architecture.name}}"
+    runs-on: ${{ matrix.architecture.os }}
+    environment: ${{ inputs.environment }}
+    env:
+        flexbison-branch: 'v2.5.25'
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+        openal-soft-branch: '1.24.3'
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - name: Cache Flex/Bison
+      id: cache-flexbison
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/winflexbison-install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-flexbison-${{ env.flexbison-branch }}-v1
+
+    - name: Install Flex/Bison
+      if: steps.cache-flexbison.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}
+      run: |
+        mkdir thirdparties && cd thirdparties
+        git clone --depth 1 --single-branch --branch ${{ env.flexbison-branch }} 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
+
+    - name: Cache Required Packages
+      id: cache-required-packages
+      uses: actions/cache@v4
+      with:
+        path: 'C:\Packages'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-required-packages-v1
+
+    - name: Install required packages
+      if: steps.cache-required-packages.outputs.cache-hit != 'true'
+      run: |
+        $DownloadPath="$($env:USERPROFILE)\Downloads"
+        if ("${{ matrix.architecture.config }}" -ieq "ARM64") {
+          Invoke-WebRequest "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-winarm64.zip" -OutFile "$DownloadPath\ninja-win.zip"
+        } else {
+          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 "C:\Packages\ninja"
+        Invoke-WebRequest "https://download.qt.io/official_releases/jom/jom.zip" -OutFile "$DownloadPath\jom.zip"
+        Expand-Archive -Path "$DownloadPath\jom.zip" -DestinationPath "C:\Packages\jom"
+
+    - name: Setup required packages path
+      run: |
+        $env:PATH += ";C:\Packages\ninja;C:\Packages\jom;"
+        echo "PATH=$($env:PATH)" >> $env: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: ""
+
+    ###
+    # OpenAL
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    # soft-oal build
+    # Statically link the CRT runtime into OAL as a workaround to prevent crashes
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      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' }
+
+    ###
+    # cURL
+    #
+    # Uses Schannel as SSL backend, native CAs are used
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build `
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' `
+            -DCURL_USE_LIBPSL=OFF `
+            -DCURL_USE_SCHANNEL=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_INTERPROCEDURAL_OPTIMIZATION=true `
+        -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/install/include' `
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' `
+        -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: 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'
+        Copy-Item '${{github.workspace}}/thirdparties/curl/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' }
+
+    - name: Generate setup files
+      working-directory: ${{github.workspace}}
+      run: |
+        Copy-Item -Path '${{github.workspace}}/package' -Destination 'source/misc/setup/windows/app/files' -Recurse
+        dotnet build -p Platform=${{matrix.architecture.config}} -c Release -o out source/misc/setup/windows/app
+
+    ###
+    # 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
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}-installer
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/out/en-us/Setup.msi
+          ${{github.workspace}}/out/en-us/Setup.wixpdb

.github/workflows/shared-build.yml

@@ -0,0 +1,24 @@
+name: Shared build workflow
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+
+jobs:
+  build-platform-linux:
+    uses: ./.github/workflows/shared-build-linux.yml
+    with:
+      environment: ${{inputs.environment}}
+
+  build-platform-windows:
+    uses: ./.github/workflows/shared-build-windows.yml
+    with:
+      environment: ${{inputs.environment}}
+
+  build-platform-macos:
+    uses: ./.github/workflows/shared-build-macos.yml
+    with:
+      environment: ${{inputs.environment}}

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

@@ -0,0 +1,109 @@
+name: "Publish Release"
+
+on:
+  push:
+    tags:
+        - "v*.*.*"
+
+env:
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+  RELEASE_IS_PRERELEASE: ${{ vars.RELEASE_IS_PRELEASE }}
+
+permissions:
+  contents: write
+
+jobs:
+  build-all:
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: "release"
+
+  # Initially create a release with 1 job
+  # so multiple files can be uploaded at the same time afterwards
+  create-release:
+    runs-on: ubuntu-24.04
+    environment: 'release'
+    needs: [build-all]
+
+    steps:
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        name: '${{github.ref_name}}-${{env.RELEASE_STAGE}}'
+        prerelease: ${{env.RELEASE_IS_PRERELEASE}}
+
+  deploy-all:
+    strategy:
+      matrix:
+        target_os: [
+          'linux-amd64',
+          'linux-i686',
+          'linux-arm64',
+          'linux-armhf',
+          'linux-powerpc',
+          'linux-ppc64',
+          'linux-ppc64el',
+          'windows-x64',
+          'windows-x64-pdb',
+          'windows-x86',
+          'windows-x86-pdb',
+          'windows-arm64',
+          'windows-arm64-pdb',
+          #'macos-x86_64',
+          #'macos-arm64',
+          'macos-multiarch-arm64-x86_64',
+        ]
+
+    runs-on: ubuntu-24.04
+    environment: 'release'
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Zip
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run: zip -r "../${{ env.RELEASE_NAME }}.zip" ./
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.zip
+
+  deploy_installer_windows:
+    strategy:
+      matrix:
+        target_os: [
+          'windows-x64',
+          'windows-x86',
+          'windows-arm64',
+        ]
+    
+    runs-on: ubuntu-24.04
+    environment: "release"
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}-installer'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Setup
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run:
+        cp Setup.msi ../${{ env.RELEASE_NAME }}.msi
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.msi

.github/workflows/unit-testing.yml

@@ -0,0 +1,53 @@
+name: "Unit Tests"
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: "Running unit tests"
+    runs-on: ubuntu-latest
+    environment: "testing"
+
+    steps:
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: flex bison ninja-build cmake clang libsdl2-dev libopenal-dev
+        version: "${{ runner.os }}-${{ runner.arch }}-unittest-v1"
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - 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 "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install'" >> $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 Debug --parallel
+
+    - name: Test
+      working-directory: ${{github.workspace}}
+      run: |
+        cd "${{github.workspace}}/build"
+        ctest -C Debug --output-on-failure

CMakeLists.txt

@@ -1,36 +1,57 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.12)
 project(openmohaa)
 
-include(TargetArch.cmake)
+include(misc/cmake/TargetArch.cmake)
 
 target_architecture(TARGET_ARCH)
+list(LENGTH TARGET_ARCH TARGET_ARCH_COUNT)
 
+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})
+option(USE_RENDERER_DLOPEN "Whether to compile the renderer as separate pluggable modules" OFF)
 
 if(TARGET_GAME_TYPE)
 	message(SEND_ERROR "TARGET_GAME_TYPE is now unsupported, it is now done at runtime.")
 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)
 	# Treat no return type as error
 	add_compile_options(/we4715)
 endif()
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+#
+# 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
@@ -42,26 +63,22 @@ if(DEBUG_MEMORY)
 	add_definitions(-D_DEBUG_MEM)
 endif()
 
-IF("${TARGET_ARCH}" STREQUAL "i386")
-	set(TARGET_ARCH_SUFFIX "x86")
-ELSE()
-	set(TARGET_ARCH_SUFFIX ${TARGET_ARCH})
-ENDIF()
+message(STATUS "Architecture detected: ${TARGET_ARCH}")
 
-message(STATUS "Architecture detected: ${TARGET_ARCH}, suffix set to ${TARGET_ARCH_SUFFIX}.")
+set(TARGET_BIN_SUFFIX "")
 
-IF(WIN32)
+if(WIN32)
 	set(TARGET_PLATFORM_PREFIX "")
 	message(STATUS "Using Win32 naming convention")
-ELSEIF(UNIX)
+elseif(UNIX)
 	set(TARGET_PLATFORM_PREFIX "")
 	message(STATUS "Using Unix naming convention")
-ELSE()
+else()
 	set(TARGET_PLATFORM_PREFIX "")
-ENDIF()
+endif()
 
-IF(CMAKE_BUILD_TYPE MATCHES Debug)
-	add_definitions(-D_DEBUG)
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+	add_compile_definitions(_DEBUG)
 
 	# NOTE: The following may mess up function importation
 	#if(UNIX)
@@ -69,18 +86,62 @@ IF(CMAKE_BUILD_TYPE MATCHES Debug)
 	#	set(CMAKE_ENABLE_EXPORTS ON)
 	#	message(STATUS "Enabling exports on Unix for backtrace")
 	#endif()
-ENDIF()
+else()
+	# Non-debug builds
+	add_compile_definitions(NDEBUG)
+endif()
 
+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${CMAKE_LIB_SUFFIX})
+	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)
+# Enable unit testing
+include(CTest)
+
+#
 # 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")
@@ -91,48 +152,99 @@ 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")
+	##
+	option(NO_MODERN_DMA "Use older sound-system" FALSE)
 
-	#include("code/renderergl2/glsl/shaders.cmake")
-	#file(GLOB_RECURSE SOURCES_RENDERER "code/sdl/*.c" "code/renderercommon/*.c" "code/renderergl2/*.c" "code/renderergl2/*.cpp")
-	#list(FILTER SOURCES_RENDERER EXCLUDE REGEX "code/renderergl2/tr_subs.c")
-	#list(FILTER SOURCES_RENDERER EXCLUDE REGEX "code/renderergl2/tr_model.c")
+	add_subdirectory("code/client")
+	add_subdirectory("code/renderercommon")
+	add_subdirectory("code/sdl")
 
 	add_executable(openmohaa "misc/dummy.c")
 	target_link_libraries(openmohaa PRIVATE syslib)
 	target_link_libraries(openmohaa PRIVATE omohserver)
 	target_link_libraries(openmohaa PRIVATE omohclient)
-	target_link_libraries(openmohaa PRIVATE omohrenderer omohsdl)
+	target_link_libraries(openmohaa PRIVATE omohrenderer)
 	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_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)
+		# 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,101 +1,108 @@
 # 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)
 
+![logo](misc/openmohaa-text-sm.png)
 
-```
-     / _ \ _ __   ___ _ __ |  \/  |/ _ \| | | |  / \      / \
-    | | | | '_ \ / _ \ '_ \| |\/| | | | | |_| | / _ \    / _ \
-    | |_| | |_) |  __/ | | | |  | | |_| |  _  |/ ___ \  / ___ \
-     \___/| .__/ \___|_| |_|_|  |_|\___/|_| |_/_/   \_\/_/   \_\
-          |_|
-```
+## What is OpenMoHAA?
 
-## Intro
+OpenMoHAA is an open-source project aimed at preserving and enhancing **Medal of Honor: Allied Assault** (including Spearhead and Breakthrough expansions) by providing more features and bugfixes, across modern platforms and architectures.
 
-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).
+Powered by [ioquake3](https://github.com/ioquake/ioq3) and the [F.A.K.K SDK](https://code.idtech.space/ritual/fakk2-sdk), OpenMoHAA provides:
+- Full compatibility with the original game: assets, scripts and multiplayer
+- Better support for modern systems
+- Cross-platform support (Linux, Windows, macOS)
+- Support for both single-player and multiplayer modes
+- Includes all fixes from Spearhead 2.15 and Breakthrough 2.40b
+- More fixes and features, such as bots and a ban system
+
+*OpenMoHAA is an independent project and is not affiliated with or endorsed by Electronic Arts.*
 
 ## Getting started
 
-- [Installing OpenMoHAA](docs/getting_started_installation.md)
-- [Running OpenMoHAA and using expansion assets](docs/getting_started_running.md)
+- 📦 [Installing OpenMoHAA](docs/markdown/01-intro/01-installation.md)
+- ▶️ [How to play: Launching the game, expansions & file locations](docs/markdown/02-running/01-running.md)
+- ❓ [FAQ & Troubleshooting](docs/markdown/02-running/03-faq.md)
+- 🌐 [Setting up a game server](docs/markdown/02-running/02-running-server.md)
+
+## Reporting Issues
+
+> [!NOTE]
+> OpenMoHAA hasn't hit version 1.0.0 yet. Think of it like a beta build from the golden age of LAN parties. Features are being added, bugs are getting squashed, and more things are being tweaked. Things might change, break, or get even better over time.
+> 
+> If that sounds like your kind of mission, gear up, frag some bots, and help level up OpenMoHAA!
+
+If you encounter a bug or a problem, you can do one of the following:
+- Submit an [issue](https://github.com/openmoh/openmohaa/issues) on GitHub (use the template).
+- Join the [OpenMoHAA Discord](https://discord.gg/NYtH58R) for a quick help.
+
+## Additional documentation
+
+- 📖 [Documentation](https://openmoh.github.io/openmohaa)
+- ⚙️ [Game settings & configuration](docs/markdown/03-configuration/01-configuration.md)
+- 📝 [Code & Scripting reference](docs/markdown/04-coding/02-coding.md)
 
 ## Current state
 
+- 🧰 [Feature list](docs/markdown/01-intro/04-features.md)
+
 ### Single-player
 
-The entire single-player campaign can be played from start to end. There may be occasional bugs though; if you encounter any, please create a new [GitHub issue](https://github.com/openmoh/openmohaa/issues) describing them.
+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.
 
 ### Multiplayer
 
-The Multiplayer part is almost fully stable.
+- Almost fully stable
+- All official game modes are supported, including those from Spearhead and Breakthrough:
+  - Free-For-All
+  - Team-Deathmatch
+  - Round-based match
+  - Objective match
+  - Tug-of-War (Spearhead)
+  - Liberation (Breakthrough)
+- Popular mods like **Freeze-Tag** are supported
+- Built-in bots for offline practice and for testing
+  - 🔧 [Setting up bots](docs/markdown/02-running/01-running.md#Playing-with-bots)
 
-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.
-
-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.
-
-## Features
-
-- [What's working](docs/features_implementation.md)
-- [New features](docs/features.md)
-- [Scripting commands](https://htmlpreview.github.io/?https://github.com/openmoh/openmohaa/blob/main/docs/features_g_allclasses.html)
-
-## Compiling
-
-- See [Compiling OpenMoHAA](docs/compiling.md)
+You can host your own [OpenMoHAA server](docs/markdown/02-running/02-running-server.md#) or join others using OpenMoHAA.
 
 ## Screenshots
 
 |                                                                                   |                                                                            |
 |-----------------------------------------------------------------------------------|----------------------------------------------------------------------------|
-| ![](docs/images/v0.60.0-x86_64/mohdm1_1.png)                                      | ![](docs/images/v0.60.0-x86_64/training_1.png)                               |
-| ![](docs/images/v0.60.0-x86_64/flughafen_1.png)                                   | ![](docs/images/v0.60.0-x86_64/flughafen_2.png)                            |
-| ![](docs/images/v0.60.0-x86_64/mohdm2_1.png "Playing Freeze-Tag mode with bots")  | ![](docs/images/v0.60.0-x86_64/training_3.png "Single-Player training")    |
+| ![](docs/assets/images/v0.60.0-x86_64/mohdm1_1.png)                                      | ![](docs/assets/images/v0.60.0-x86_64/training_1.png)                               |
+| ![](docs/assets/images/v0.60.0-x86_64/flughafen_1.png)                                   | ![](docs/assets/images/v0.60.0-x86_64/flughafen_2.png)                            |
+| ![](docs/assets/images/v0.60.0-x86_64/mohdm2_1.png "Playing Freeze-Tag mode with bots")  | ![](docs/assets/images/v0.60.0-x86_64/training_3.png "Single-Player training")    |
 
-*More screenshots [here](docs/images)*
+*More screenshots [here](docs/assets/images)*
 
-## Third party
+## Development & Compiling
 
-### SDL
+- 💻 [Building from source](docs/markdown/04-coding/01-compiling.md)
 
-http://www.libsdl.org/
+## Third party librairies
 
-### OpenAL
+The following third party tools and libraries are used by the project
 
-https://www.openal.org/
+- [Flex](https://github.com/westes/flex)
+- [Bison](https://savannah.gnu.org/projects/bison/)
+- [SDL](http://www.libsdl.org/)
+- [OpenAL](https://www.openal.org/)
+- [LibMAD](http://www.underbit.com/products/mad/)
+- [cURL](https://curl.se/)
+- [Libogg](https://github.com/gcp/libogg)
+- [Libvorbis](https://xiph.org/vorbis/)
+- [Libopus](https://opus-codec.org/)
 
-### LibMAD
+## Resources
 
-http://www.underbit.com/products/mad/
-
-### cURL
-
-https://curl.se/
-
-### Libogg
-
-https://github.com/gcp/libogg
-
-### Libvorbis
-
-https://xiph.org/vorbis/
-
-### Libopus
-
-https://opus-codec.org/
-
-## Communities
-
-### URLs
-
-- https://github.com/openmoh/openmohaa/
-- https://mohaaaa.co.uk/AAAAMOHAA/index.php
-- https://x-null.net/
-
-### Discord
-
-[![Discord Banner 1](https://discordapp.com/api/guilds/596049712579215361/widget.png?style=banner2)](https://discord.gg/NYtH58R)
+- 🔗 [GitHub Repository](https://github.com/openmoh/openmohaa/)
+- 🌐 [MOHAAAA Amalgamated Allied Assault Alliance](https://mohaaaa.co.uk/AAAAMOHAA/index.php)
+- 🕹️ [333networks](https://333networks.com/)
+- 📂 [ModDB](https://www.moddb.com/games/medal-of-honor-allied-assault)
+- 📂 [GameBanana](https://gamebanana.com/games/720)
+- 💬 [Join us on Discord](https://discord.gg/NYtH58R)

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/AL/al.h

@@ -1,8 +1,40 @@
 #ifndef AL_AL_H
 #define AL_AL_H
 
-#if defined(__cplusplus)
+/* NOLINTBEGIN */
+#ifdef __cplusplus
 extern "C" {
+
+#ifdef _MSVC_LANG
+#define AL_CPLUSPLUS _MSVC_LANG
+#else
+#define AL_CPLUSPLUS __cplusplus
+#endif
+
+#ifndef AL_DISABLE_NOEXCEPT
+#if AL_CPLUSPLUS >= 201103L
+#define AL_API_NOEXCEPT noexcept
+#else
+#define AL_API_NOEXCEPT
+#endif
+#if AL_CPLUSPLUS >= 201703L
+#define AL_API_NOEXCEPT17 noexcept
+#else
+#define AL_API_NOEXCEPT17
+#endif
+
+#else /* AL_DISABLE_NOEXCEPT */
+
+#define AL_API_NOEXCEPT
+#define AL_API_NOEXCEPT17
+#endif
+
+#undef AL_CPLUSPLUS
+
+#else /* __cplusplus */
+
+#define AL_API_NOEXCEPT
+#define AL_API_NOEXCEPT17
 #endif
 
 #ifndef AL_API
@@ -15,14 +47,14 @@ extern "C" {
  #endif
 #endif
 
-#if defined(_WIN32)
+#ifdef _WIN32
  #define AL_APIENTRY __cdecl
 #else
  #define AL_APIENTRY
 #endif
 
 
-/** Deprecated macro. */
+/* Deprecated macros. */
 #define OPENAL
 #define ALAPI                                    AL_API
 #define ALAPIENTRY                               AL_APIENTRY
@@ -30,7 +62,7 @@ extern "C" {
 #define AL_ILLEGAL_ENUM                          AL_INVALID_ENUM
 #define AL_ILLEGAL_COMMAND                       AL_INVALID_OPERATION
 
-/** Supported AL version. */
+/* Supported AL versions. */
 #define AL_VERSION_1_0
 #define AL_VERSION_1_1
 
@@ -40,43 +72,43 @@ typedef char ALboolean;
 /** character */
 typedef char ALchar;
 
-/** signed 8-bit 2's complement integer */
+/** signed 8-bit integer */
 typedef signed char ALbyte;
 
 /** unsigned 8-bit integer */
 typedef unsigned char ALubyte;
 
-/** signed 16-bit 2's complement integer */
+/** signed 16-bit integer */
 typedef short ALshort;
 
 /** unsigned 16-bit integer */
 typedef unsigned short ALushort;
 
-/** signed 32-bit 2's complement integer */
+/** signed 32-bit integer */
 typedef int ALint;
 
 /** unsigned 32-bit integer */
 typedef unsigned int ALuint;
 
-/** non-negative 32-bit binary integer size */
+/** non-negative 32-bit integer size */
 typedef int ALsizei;
 
-/** enumerated 32-bit value */
+/** 32-bit enumeration value */
 typedef int ALenum;
 
-/** 32-bit IEEE754 floating-point */
+/** 32-bit IEEE-754 floating-point */
 typedef float ALfloat;
 
-/** 64-bit IEEE754 floating-point */
+/** 64-bit IEEE-754 floating-point */
 typedef double ALdouble;
 
-/** void type (for opaque pointers only) */
+/** void type (opaque pointers only) */
 typedef void ALvoid;
 
 
-/* Enumerant values begin at column 50. No tabs. */
+/* Enumeration values begin at column 50. Do not use tabs. */
 
-/** "no distance model" or "no buffer" */
+/** No distance model or no buffer */
 #define AL_NONE                                  0
 
 /** Boolean False. */
@@ -89,10 +121,10 @@ typedef void ALvoid;
 /**
  * Relative source.
  * Type:    ALboolean
- * Range:   [AL_TRUE, AL_FALSE]
+ * Range:   [AL_FALSE, AL_TRUE]
  * Default: AL_FALSE
  *
- * Specifies if the Source has relative coordinates.
+ * Specifies if the source uses relative coordinates.
  */
 #define AL_SOURCE_RELATIVE                       0x202
 
@@ -103,7 +135,8 @@ typedef void ALvoid;
  * Range:   [0 - 360]
  * Default: 360
  *
- * The angle covered by the inner cone, where the source will not attenuate.
+ * The angle covered by the inner cone, the area within which the source will
+ * not be attenuated by direction.
  */
 #define AL_CONE_INNER_ANGLE                      0x1001
 
@@ -112,8 +145,8 @@ typedef void ALvoid;
  * Range:   [0 - 360]
  * Default: 360
  *
- * The angle covered by the outer cone, where the source will be fully
- * attenuated.
+ * The angle covered by the outer cone, the area outside of which the source
+ * will be fully attenuated by direction.
  */
 #define AL_CONE_OUTER_ANGLE                      0x1002
 
@@ -123,7 +156,7 @@ typedef void ALvoid;
  * Range:   [0.5 - 2.0]
  * Default: 1.0
  *
- * A multiplier for the frequency (sample rate) of the source's buffer.
+ * A multiplier for the sample rate of the source's buffer.
  */
 #define AL_PITCH                                 0x1003
 
@@ -134,12 +167,12 @@ typedef void ALvoid;
  *
  * The source or listener location in three dimensional space.
  *
- * OpenAL, like OpenGL, uses a right handed coordinate system, where in a
- * frontal default view X (thumb) points right, Y points up (index finger), and
- * Z points towards the viewer/camera (middle finger).
+ * OpenAL uses a right handed coordinate system, like OpenGL, where with a
+ * default view, X points right (thumb), Y points up (index finger), and Z
+ * points towards the viewer/camera (middle finger).
  *
- * To switch from a left handed coordinate system, flip the sign on the Z
- * coordinate.
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_POSITION                              0x1004
 
@@ -148,8 +181,11 @@ typedef void ALvoid;
  * Type:    ALfloat[3], ALint[3]
  * Default: {0, 0, 0}
  *
- * Specifies the current direction in local space.
- * A zero-length vector specifies an omni-directional source (cone is ignored).
+ * Specifies the current direction in local space. A zero-length vector
+ * specifies an omni-directional source (cone is ignored).
+ *
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_DIRECTION                             0x1005
 
@@ -158,26 +194,30 @@ typedef void ALvoid;
  * Type:    ALfloat[3], ALint[3]
  * Default: {0, 0, 0}
  *
- * Specifies the current velocity in local space.
+ * Specifies the current velocity, relative to the position.
+ *
+ * To change from or to a left handed coordinate system, negate the Z
+ * component.
  */
 #define AL_VELOCITY                              0x1006
 
 /**
  * Source looping.
  * Type:    ALboolean
- * Range:   [AL_TRUE, AL_FALSE]
+ * Range:   [AL_FALSE, AL_TRUE]
  * Default: AL_FALSE
  *
- * Specifies whether source is looping.
+ * Specifies whether source playback loops.
  */
 #define AL_LOOPING                               0x1007
 
 /**
  * Source buffer.
- * Type:  ALuint
- * Range: any valid Buffer.
+ * Type:    ALuint
+ * Range:   any valid Buffer ID
+ * Default: AL_NONE
  *
- * Specifies the buffer to provide sound samples.
+ * Specifies the buffer to provide sound samples for a source.
  */
 #define AL_BUFFER                                0x1009
 
@@ -186,12 +226,12 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - ]
  *
- * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
- * of about -6dB. Each multiplicaton by 2 equals an amplification of about
- * +6dB.
+ * For sources, an initial linear gain value (before attenuation is applied).
+ * For the listener, an output linear gain adjustment.
  *
- * A value of 0.0 is meaningless with respect to a logarithmic scale; it is
- * silent.
+ * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
+ * of about -6dB. Each multiplication by 2 equals an amplification of about
+ * +6dB.
  */
 #define AL_GAIN                                  0x100A
 
@@ -200,8 +240,8 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - 1.0]
  *
- * The minimum gain allowed for a source, after distance and cone attenation is
- * applied (if applicable).
+ * The minimum gain allowed for a source, after distance and cone attenuation
+ * are applied (if applicable).
  */
 #define AL_MIN_GAIN                              0x100D
 
@@ -210,31 +250,33 @@ typedef void ALvoid;
  * Type:  ALfloat
  * Range: [0.0 - 1.0]
  *
- * The maximum gain allowed for a source, after distance and cone attenation is
- * applied (if applicable).
+ * The maximum gain allowed for a source, after distance and cone attenuation
+ * are applied (if applicable).
  */
 #define AL_MAX_GAIN                              0x100E
 
 /**
  * Listener orientation.
- * Type: ALfloat[6]
+ * Type:    ALfloat[6]
  * Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
  *
  * Effectively two three dimensional vectors. The first vector is the front (or
- * "at") and the second is the top (or "up").
+ * "at") and the second is the top (or "up"). Both vectors are relative to the
+ * listener position.
  *
- * Both vectors are in local space.
+ * To change from or to a left handed coordinate system, negate the Z
+ * component of both vectors.
  */
 #define AL_ORIENTATION                           0x100F
 
 /**
  * Source state (query only).
- * Type:  ALint
+ * Type:  ALenum
  * Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
  */
 #define AL_SOURCE_STATE                          0x1010
 
-/** Source state value. */
+/* Source state values. */
 #define AL_INITIAL                               0x1011
 #define AL_PLAYING                               0x1012
 #define AL_PAUSED                                0x1013
@@ -267,9 +309,9 @@ typedef void ALvoid;
  * Range:   [0.0 - ]
  * Default: 1.0
  *
- * The distance in units that no attenuation occurs.
+ * The distance in units that no distance attenuation occurs.
  *
- * At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
+ * At 0.0, no distance attenuation occurs with non-linear attenuation models.
  */
 #define AL_REFERENCE_DISTANCE                    0x1020
 
@@ -292,7 +334,7 @@ typedef void ALvoid;
  * Default: 0.0
  *
  * The gain attenuation applied when the listener is outside of the source's
- * outer cone.
+ * outer cone angle.
  */
 #define AL_CONE_OUTER_GAIN                       0x1022
 
@@ -300,7 +342,7 @@ typedef void ALvoid;
  * Source maximum distance.
  * Type:    ALfloat
  * Range:   [0.0 - ]
- * Default: +inf
+ * Default: FLT_MAX
  *
  * The distance above which the source is not attenuated any further with a
  * clamped distance model, or where attenuation reaches 0.0 gain for linear
@@ -308,16 +350,16 @@ typedef void ALvoid;
  */
 #define AL_MAX_DISTANCE                          0x1023
 
-/** Source buffer position, in seconds */
+/** Source buffer offset, in seconds */
 #define AL_SEC_OFFSET                            0x1024
-/** Source buffer position, in sample frames */
+/** Source buffer offset, in sample frames */
 #define AL_SAMPLE_OFFSET                         0x1025
-/** Source buffer position, in bytes */
+/** Source buffer offset, in bytes */
 #define AL_BYTE_OFFSET                           0x1026
 
 /**
  * Source type (query only).
- * Type:  ALint
+ * Type:  ALenum
  * Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
  *
  * A Source is Static if a Buffer has been attached using AL_BUFFER.
@@ -330,31 +372,30 @@ typedef void ALvoid;
  */
 #define AL_SOURCE_TYPE                           0x1027
 
-/** Source type value. */
+/* Source type values. */
 #define AL_STATIC                                0x1028
 #define AL_STREAMING                             0x1029
 #define AL_UNDETERMINED                          0x1030
 
-/** Buffer format specifier. */
+/** Unsigned 8-bit mono buffer format. */
 #define AL_FORMAT_MONO8                          0x1100
+/** Signed 16-bit mono buffer format. */
 #define AL_FORMAT_MONO16                         0x1101
+/** Unsigned 8-bit stereo buffer format. */
 #define AL_FORMAT_STEREO8                        0x1102
+/** Signed 16-bit stereo buffer format. */
 #define AL_FORMAT_STEREO16                       0x1103
 
-/** Buffer frequency (query only). */
+/** Buffer frequency/sample rate (query only). */
 #define AL_FREQUENCY                             0x2001
 /** Buffer bits per sample (query only). */
 #define AL_BITS                                  0x2002
 /** Buffer channel count (query only). */
 #define AL_CHANNELS                              0x2003
-/** Buffer data size (query only). */
+/** Buffer data size in bytes (query only). */
 #define AL_SIZE                                  0x2004
 
-/**
- * Buffer state.
- *
- * Not for public use.
- */
+/* Buffer state. Not for public use. */
 #define AL_UNUSED                                0x2010
 #define AL_PENDING                               0x2011
 #define AL_PROCESSED                             0x2012
@@ -363,32 +404,31 @@ typedef void ALvoid;
 /** No error. */
 #define AL_NO_ERROR                              0
 
-/** Invalid name paramater passed to AL call. */
+/** Invalid name (ID) passed to an AL call. */
 #define AL_INVALID_NAME                          0xA001
 
-/** Invalid enum parameter passed to AL call. */
+/** Invalid enumeration passed to AL call. */
 #define AL_INVALID_ENUM                          0xA002
 
-/** Invalid value parameter passed to AL call. */
+/** Invalid value passed to AL call. */
 #define AL_INVALID_VALUE                         0xA003
 
 /** Illegal AL call. */
 #define AL_INVALID_OPERATION                     0xA004
 
-/** Not enough memory. */
+/** Not enough memory to execute the AL call. */
 #define AL_OUT_OF_MEMORY                         0xA005
 
 
-/** Context string: Vendor ID. */
+/** Context string: Vendor name. */
 #define AL_VENDOR                                0xB001
 /** Context string: Version. */
 #define AL_VERSION                               0xB002
-/** Context string: Renderer ID. */
+/** Context string: Renderer name. */
 #define AL_RENDERER                              0xB003
 /** Context string: Space-separated extension list. */
 #define AL_EXTENSIONS                            0xB004
 
-
 /**
  * Doppler scale.
  * Type:    ALfloat
@@ -398,7 +438,6 @@ typedef void ALvoid;
  * Scale for source and listener velocities.
  */
 #define AL_DOPPLER_FACTOR                        0xC000
-AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
 
 /**
  * Doppler velocity (deprecated).
@@ -406,7 +445,6 @@ AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
  * A multiplier applied to the Speed of Sound.
  */
 #define AL_DOPPLER_VELOCITY                      0xC001
-AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
 
 /**
  * Speed of Sound, in units per second.
@@ -415,14 +453,13 @@ AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
  * Default: 343.3
  *
  * The speed at which sound waves are assumed to travel, when calculating the
- * doppler effect.
+ * doppler effect from source and listener velocities.
  */
 #define AL_SPEED_OF_SOUND                        0xC003
-AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
 
 /**
  * Distance attenuation model.
- * Type:    ALint
+ * Type:    ALenum
  * Range:   [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
  *           AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
  *           AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
@@ -439,9 +476,8 @@ AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
  * distance calculated is clamped between the reference and max distances.
  */
 #define AL_DISTANCE_MODEL                        0xD000
-AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
 
-/** Distance model value. */
+/* Distance model values. */
 #define AL_INVERSE_DISTANCE                      0xD001
 #define AL_INVERSE_DISTANCE_CLAMPED              0xD002
 #define AL_LINEAR_DISTANCE                       0xD003
@@ -449,208 +485,223 @@ AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
 #define AL_EXPONENT_DISTANCE                     0xD005
 #define AL_EXPONENT_DISTANCE_CLAMPED             0xD006
 
-/** Renderer State management. */
-AL_API void AL_APIENTRY alEnable(ALenum capability);
-AL_API void AL_APIENTRY alDisable(ALenum capability);
-AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability);
+#ifndef AL_NO_PROTOTYPES
+/* Renderer State management. */
+AL_API void AL_APIENTRY alEnable(ALenum capability) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDisable(ALenum capability) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability) AL_API_NOEXCEPT;
 
-/** State retrieval. */
-AL_API const ALchar* AL_APIENTRY alGetString(ALenum param);
-AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values);
-AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values);
-AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values);
-AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values);
-AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param);
-AL_API ALint AL_APIENTRY alGetInteger(ALenum param);
-AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param);
-AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param);
+/* Context state setting. */
+AL_API void AL_APIENTRY alDopplerFactor(ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel) AL_API_NOEXCEPT;
+
+/* Context state retrieval. */
+AL_API const ALchar* AL_APIENTRY alGetString(ALenum param) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param) AL_API_NOEXCEPT;
+AL_API ALint AL_APIENTRY alGetInteger(ALenum param) AL_API_NOEXCEPT;
+AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param) AL_API_NOEXCEPT;
+AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param) AL_API_NOEXCEPT;
 
 /**
- * Error retrieval.
- *
- * Obtain the first error generated in the AL context since the last check.
+ * Obtain the first error generated in the AL context since the last call to
+ * this function.
  */
-AL_API ALenum AL_APIENTRY alGetError(void);
+AL_API ALenum AL_APIENTRY alGetError(void) AL_API_NOEXCEPT;
 
+/** Query for the presence of an extension on the AL context. */
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname) AL_API_NOEXCEPT;
 /**
- * Extension support.
- *
- * Query for the presence of an extension, and obtain any appropriate function
- * pointers and enum values.
+ * Retrieve the address of a function. The returned function may be context-
+ * specific.
  */
-AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname);
-AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname);
-AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename);
+AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname) AL_API_NOEXCEPT;
+/**
+ * Retrieve the value of an enum. The returned value may be context-specific.
+ */
+AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename) AL_API_NOEXCEPT;
 
 
-/** Set Listener parameters */
-AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value);
-AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values);
-AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value);
-AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3);
-AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values);
+/* Set listener parameters. */
+AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values) AL_API_NOEXCEPT;
 
-/** Get Listener parameters */
-AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value);
-AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values);
-AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value);
-AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3);
-AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values);
+/* Get listener parameters. */
+AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values) AL_API_NOEXCEPT;
 
 
-/** Create Source objects. */
-AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources);
-/** Delete Source objects. */
-AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources);
-/** Verify a handle is a valid Source. */
-AL_API ALboolean AL_APIENTRY alIsSource(ALuint source);
+/** Create source objects. */
+AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources) AL_API_NOEXCEPT;
+/** Delete source objects. */
+AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+/** Verify an ID is for a valid source. */
+AL_API ALboolean AL_APIENTRY alIsSource(ALuint source) AL_API_NOEXCEPT;
 
-/** Set Source parameters. */
-AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value);
-AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values);
-AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value);
-AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
-AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values);
+/* Set source parameters. */
+AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values) AL_API_NOEXCEPT;
 
-/** Get Source parameters. */
-AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value);
-AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values);
-AL_API void AL_APIENTRY alGetSourcei(ALuint source,  ALenum param, ALint *value);
-AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
-AL_API void AL_APIENTRY alGetSourceiv(ALuint source,  ALenum param, ALint *values);
+/* Get source parameters. */
+AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcei(ALuint source,  ALenum param, ALint *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourceiv(ALuint source,  ALenum param, ALint *values) AL_API_NOEXCEPT;
 
 
-/** Play, replay, or resume (if paused) a list of Sources */
-AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources);
-/** Stop a list of Sources */
-AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources);
-/** Rewind a list of Sources */
-AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources);
-/** Pause a list of Sources */
-AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources);
+/** Play, restart, or resume a source, setting its state to AL_PLAYING. */
+AL_API void AL_APIENTRY alSourcePlay(ALuint source) AL_API_NOEXCEPT;
+/** Stop a source, setting its state to AL_STOPPED if playing or paused. */
+AL_API void AL_APIENTRY alSourceStop(ALuint source) AL_API_NOEXCEPT;
+/** Rewind a source, setting its state to AL_INITIAL. */
+AL_API void AL_APIENTRY alSourceRewind(ALuint source) AL_API_NOEXCEPT;
+/** Pause a source, setting its state to AL_PAUSED if playing. */
+AL_API void AL_APIENTRY alSourcePause(ALuint source) AL_API_NOEXCEPT;
 
-/** Play, replay, or resume a Source */
-AL_API void AL_APIENTRY alSourcePlay(ALuint source);
-/** Stop a Source */
-AL_API void AL_APIENTRY alSourceStop(ALuint source);
-/** Rewind a Source (set playback postiton to beginning) */
-AL_API void AL_APIENTRY alSourceRewind(ALuint source);
-/** Pause a Source */
-AL_API void AL_APIENTRY alSourcePause(ALuint source);
+/** Play, restart, or resume a list of sources atomically. */
+AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+/** Stop a list of sources atomically. */
+AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+/** Rewind a list of sources atomically. */
+AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+/** Pause a list of sources atomically. */
+AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
 
 /** Queue buffers onto a source */
-AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers);
+AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers) AL_API_NOEXCEPT;
 /** Unqueue processed buffers from a source */
-AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers);
+AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers) AL_API_NOEXCEPT;
 
 
-/** Create Buffer objects */
-AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers);
-/** Delete Buffer objects */
-AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers);
-/** Verify a handle is a valid Buffer */
-AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer);
+/** Create buffer objects */
+AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers) AL_API_NOEXCEPT;
+/** Delete buffer objects */
+AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers) AL_API_NOEXCEPT;
+/** Verify an ID is a valid buffer (including the NULL buffer) */
+AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer) AL_API_NOEXCEPT;
 
-/** Specifies the data to be copied into a buffer */
-AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+/**
+ * Copies data into the buffer, interpreting it using the specified format and
+ * samplerate.
+ */
+AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate) AL_API_NOEXCEPT;
 
-/** Set Buffer parameters, */
-AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value);
-AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values);
-AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value);
-AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
-AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values);
+/* Set buffer parameters. */
+AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values) AL_API_NOEXCEPT;
 
-/** Get Buffer parameters. */
-AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value);
-AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values);
-AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value);
-AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
-AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values);
+/* Get buffer parameters. */
+AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values) AL_API_NOEXCEPT;
+#endif /* AL_NO_PROTOTYPES */
 
-/** Pointer-to-function type, useful for dynamically getting AL entry points. */
-typedef void          (AL_APIENTRY *LPALENABLE)(ALenum capability);
-typedef void          (AL_APIENTRY *LPALDISABLE)(ALenum capability);
-typedef ALboolean     (AL_APIENTRY *LPALISENABLED)(ALenum capability);
-typedef const ALchar* (AL_APIENTRY *LPALGETSTRING)(ALenum param);
-typedef void          (AL_APIENTRY *LPALGETBOOLEANV)(ALenum param, ALboolean *values);
-typedef void          (AL_APIENTRY *LPALGETINTEGERV)(ALenum param, ALint *values);
-typedef void          (AL_APIENTRY *LPALGETFLOATV)(ALenum param, ALfloat *values);
-typedef void          (AL_APIENTRY *LPALGETDOUBLEV)(ALenum param, ALdouble *values);
-typedef ALboolean     (AL_APIENTRY *LPALGETBOOLEAN)(ALenum param);
-typedef ALint         (AL_APIENTRY *LPALGETINTEGER)(ALenum param);
-typedef ALfloat       (AL_APIENTRY *LPALGETFLOAT)(ALenum param);
-typedef ALdouble      (AL_APIENTRY *LPALGETDOUBLE)(ALenum param);
-typedef ALenum        (AL_APIENTRY *LPALGETERROR)(void);
-typedef ALboolean     (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar *extname);
-typedef void*         (AL_APIENTRY *LPALGETPROCADDRESS)(const ALchar *fname);
-typedef ALenum        (AL_APIENTRY *LPALGETENUMVALUE)(const ALchar *ename);
-typedef void          (AL_APIENTRY *LPALLISTENERF)(ALenum param, ALfloat value);
-typedef void          (AL_APIENTRY *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-typedef void          (AL_APIENTRY *LPALLISTENERFV)(ALenum param, const ALfloat *values);
-typedef void          (AL_APIENTRY *LPALLISTENERI)(ALenum param, ALint value);
-typedef void          (AL_APIENTRY *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3);
-typedef void          (AL_APIENTRY *LPALLISTENERIV)(ALenum param, const ALint *values);
-typedef void          (AL_APIENTRY *LPALGETLISTENERF)(ALenum param, ALfloat *value);
-typedef void          (AL_APIENTRY *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-typedef void          (AL_APIENTRY *LPALGETLISTENERFV)(ALenum param, ALfloat *values);
-typedef void          (AL_APIENTRY *LPALGETLISTENERI)(ALenum param, ALint *value);
-typedef void          (AL_APIENTRY *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3);
-typedef void          (AL_APIENTRY *LPALGETLISTENERIV)(ALenum param, ALint *values);
-typedef void          (AL_APIENTRY *LPALGENSOURCES)(ALsizei n, ALuint *sources);
-typedef void          (AL_APIENTRY *LPALDELETESOURCES)(ALsizei n, const ALuint *sources);
-typedef ALboolean     (AL_APIENTRY *LPALISSOURCE)(ALuint source);
-typedef void          (AL_APIENTRY *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value);
-typedef void          (AL_APIENTRY *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-typedef void          (AL_APIENTRY *LPALSOURCEFV)(ALuint source, ALenum param, const ALfloat *values);
-typedef void          (AL_APIENTRY *LPALSOURCEI)(ALuint source, ALenum param, ALint value);
-typedef void          (AL_APIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
-typedef void          (AL_APIENTRY *LPALSOURCEIV)(ALuint source, ALenum param, const ALint *values);
-typedef void          (AL_APIENTRY *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value);
-typedef void          (AL_APIENTRY *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-typedef void          (AL_APIENTRY *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values);
-typedef void          (AL_APIENTRY *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value);
-typedef void          (AL_APIENTRY *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
-typedef void          (AL_APIENTRY *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values);
-typedef void          (AL_APIENTRY *LPALSOURCEPLAYV)(ALsizei n, const ALuint *sources);
-typedef void          (AL_APIENTRY *LPALSOURCESTOPV)(ALsizei n, const ALuint *sources);
-typedef void          (AL_APIENTRY *LPALSOURCEREWINDV)(ALsizei n, const ALuint *sources);
-typedef void          (AL_APIENTRY *LPALSOURCEPAUSEV)(ALsizei n, const ALuint *sources);
-typedef void          (AL_APIENTRY *LPALSOURCEPLAY)(ALuint source);
-typedef void          (AL_APIENTRY *LPALSOURCESTOP)(ALuint source);
-typedef void          (AL_APIENTRY *LPALSOURCEREWIND)(ALuint source);
-typedef void          (AL_APIENTRY *LPALSOURCEPAUSE)(ALuint source);
-typedef void          (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const ALuint *buffers);
-typedef void          (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers);
-typedef void          (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers);
-typedef void          (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers);
-typedef ALboolean     (AL_APIENTRY *LPALISBUFFER)(ALuint buffer);
-typedef void          (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
-typedef void          (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value);
-typedef void          (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
-typedef void          (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values);
-typedef void          (AL_APIENTRY *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value);
-typedef void          (AL_APIENTRY *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
-typedef void          (AL_APIENTRY *LPALBUFFERIV)(ALuint buffer, ALenum param, const ALint *values);
-typedef void          (AL_APIENTRY *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value);
-typedef void          (AL_APIENTRY *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
-typedef void          (AL_APIENTRY *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values);
-typedef void          (AL_APIENTRY *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value);
-typedef void          (AL_APIENTRY *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
-typedef void          (AL_APIENTRY *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values);
-typedef void          (AL_APIENTRY *LPALDOPPLERFACTOR)(ALfloat value);
-typedef void          (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value);
-typedef void          (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value);
-typedef void          (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel);
+/* Pointer-to-function types, useful for storing dynamically loaded AL entry
+ * points.
+ */
+typedef void          (AL_APIENTRY *LPALENABLE)(ALenum capability) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDISABLE)(ALenum capability) AL_API_NOEXCEPT17;
+typedef ALboolean     (AL_APIENTRY *LPALISENABLED)(ALenum capability) AL_API_NOEXCEPT17;
+typedef const ALchar* (AL_APIENTRY *LPALGETSTRING)(ALenum param) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBOOLEANV)(ALenum param, ALboolean *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETINTEGERV)(ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETFLOATV)(ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETDOUBLEV)(ALenum param, ALdouble *values) AL_API_NOEXCEPT17;
+typedef ALboolean     (AL_APIENTRY *LPALGETBOOLEAN)(ALenum param) AL_API_NOEXCEPT17;
+typedef ALint         (AL_APIENTRY *LPALGETINTEGER)(ALenum param) AL_API_NOEXCEPT17;
+typedef ALfloat       (AL_APIENTRY *LPALGETFLOAT)(ALenum param) AL_API_NOEXCEPT17;
+typedef ALdouble      (AL_APIENTRY *LPALGETDOUBLE)(ALenum param) AL_API_NOEXCEPT17;
+typedef ALenum        (AL_APIENTRY *LPALGETERROR)(void) AL_API_NOEXCEPT17;
+typedef ALboolean     (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar *extname) AL_API_NOEXCEPT17;
+typedef void*         (AL_APIENTRY *LPALGETPROCADDRESS)(const ALchar *fname) AL_API_NOEXCEPT17;
+typedef ALenum        (AL_APIENTRY *LPALGETENUMVALUE)(const ALchar *ename) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENERF)(ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENERFV)(ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENERI)(ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALLISTENERIV)(ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENERF)(ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENERFV)(ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENERI)(ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETLISTENERIV)(ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGENSOURCES)(ALsizei n, ALuint *sources) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDELETESOURCES)(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef ALboolean     (AL_APIENTRY *LPALISSOURCE)(ALuint source) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEFV)(ALuint source, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEI)(ALuint source, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEIV)(ALuint source, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEPLAYV)(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCESTOPV)(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEREWINDV)(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEPAUSEV)(ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEPLAY)(ALuint source) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCESTOP)(ALuint source) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEREWIND)(ALuint source) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEPAUSE)(ALuint source) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers) AL_API_NOEXCEPT17;
+typedef ALboolean     (AL_APIENTRY *LPALISBUFFER)(ALuint buffer) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALBUFFERIV)(ALuint buffer, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDOPPLERFACTOR)(ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value) AL_API_NOEXCEPT17;
+typedef void          (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel) AL_API_NOEXCEPT17;
 
-#if defined(__cplusplus)
+#ifdef __cplusplus
 }  /* extern "C" */
 #endif
+/* NOLINTEND */
 
 #endif /* AL_AL_H */

code/AL/alc.h

@@ -1,8 +1,40 @@
 #ifndef AL_ALC_H
 #define AL_ALC_H
 
-#if defined(__cplusplus)
+/* NOLINTBEGIN */
+#ifdef __cplusplus
 extern "C" {
+
+#ifdef _MSVC_LANG
+#define ALC_CPLUSPLUS _MSVC_LANG
+#else
+#define ALC_CPLUSPLUS __cplusplus
+#endif
+
+#ifndef AL_DISABLE_NOEXCEPT
+#if ALC_CPLUSPLUS >= 201103L
+#define ALC_API_NOEXCEPT noexcept
+#else
+#define ALC_API_NOEXCEPT
+#endif
+#if ALC_CPLUSPLUS >= 201703L
+#define ALC_API_NOEXCEPT17 noexcept
+#else
+#define ALC_API_NOEXCEPT17
+#endif
+
+#else /* AL_DISABLE_NOEXCEPT */
+
+#define ALC_API_NOEXCEPT
+#define ALC_API_NOEXCEPT17
+#endif
+
+#undef ALC_CPLUSPLUS
+
+#else /* __cplusplus */
+
+#define ALC_API_NOEXCEPT
+#define ALC_API_NOEXCEPT17
 #endif
 
 #ifndef ALC_API
@@ -15,14 +47,14 @@ extern "C" {
  #endif
 #endif
 
-#if defined(_WIN32)
+#ifdef _WIN32
  #define ALC_APIENTRY __cdecl
 #else
  #define ALC_APIENTRY
 #endif
 
 
-/** Deprecated macro. */
+/* Deprecated macros. */
 #define ALCAPI                                   ALC_API
 #define ALCAPIENTRY                              ALC_APIENTRY
 #define ALC_INVALID                              0
@@ -31,9 +63,9 @@ extern "C" {
 #define ALC_VERSION_0_1                          1
 
 /** Opaque device handle */
-typedef struct ALCdevice_struct ALCdevice;
+typedef struct ALCdevice ALCdevice;
 /** Opaque context handle */
-typedef struct ALCcontext_struct ALCcontext;
+typedef struct ALCcontext ALCcontext;
 
 /** 8-bit boolean */
 typedef char ALCboolean;
@@ -41,41 +73,41 @@ typedef char ALCboolean;
 /** character */
 typedef char ALCchar;
 
-/** signed 8-bit 2's complement integer */
+/** signed 8-bit integer */
 typedef signed char ALCbyte;
 
 /** unsigned 8-bit integer */
 typedef unsigned char ALCubyte;
 
-/** signed 16-bit 2's complement integer */
+/** signed 16-bit integer */
 typedef short ALCshort;
 
 /** unsigned 16-bit integer */
 typedef unsigned short ALCushort;
 
-/** signed 32-bit 2's complement integer */
+/** signed 32-bit integer */
 typedef int ALCint;
 
 /** unsigned 32-bit integer */
 typedef unsigned int ALCuint;
 
-/** non-negative 32-bit binary integer size */
+/** non-negative 32-bit integer size */
 typedef int ALCsizei;
 
-/** enumerated 32-bit value */
+/** 32-bit enumeration value */
 typedef int ALCenum;
 
-/** 32-bit IEEE754 floating-point */
+/** 32-bit IEEE-754 floating-point */
 typedef float ALCfloat;
 
-/** 64-bit IEEE754 floating-point */
+/** 64-bit IEEE-754 floating-point */
 typedef double ALCdouble;
 
 /** void type (for opaque pointers only) */
 typedef void ALCvoid;
 
 
-/* Enumerant values begin at column 50. No tabs. */
+/* Enumeration values begin at column 50. Do not use tabs. */
 
 /** Boolean False. */
 #define ALC_FALSE                                0
@@ -89,7 +121,7 @@ typedef void ALCvoid;
 /** Context attribute: <int> Hz. */
 #define ALC_REFRESH                              0x1008
 
-/** Context attribute: AL_TRUE or AL_FALSE. */
+/** Context attribute: AL_TRUE or AL_FALSE synchronous context? */
 #define ALC_SYNC                                 0x1009
 
 /** Context attribute: <int> requested Mono (3D) Sources. */
@@ -107,30 +139,32 @@ typedef void ALCvoid;
 /** Invalid context handle. */
 #define ALC_INVALID_CONTEXT                      0xA002
 
-/** Invalid enum parameter passed to an ALC call. */
+/** Invalid enumeration passed to an ALC call. */
 #define ALC_INVALID_ENUM                         0xA003
 
-/** Invalid value parameter passed to an ALC call. */
+/** Invalid value passed to an ALC call. */
 #define ALC_INVALID_VALUE                        0xA004
 
 /** Out of memory. */
 #define ALC_OUT_OF_MEMORY                        0xA005
 
 
-/** Runtime ALC version. */
+/** Runtime ALC major version. */
 #define ALC_MAJOR_VERSION                        0x1000
+/** Runtime ALC minor version. */
 #define ALC_MINOR_VERSION                        0x1001
 
-/** Context attribute list properties. */
+/** Context attribute list size. */
 #define ALC_ATTRIBUTES_SIZE                      0x1002
+/** Context attribute list properties. */
 #define ALC_ALL_ATTRIBUTES                       0x1003
 
 /** String for the default device specifier. */
 #define ALC_DEFAULT_DEVICE_SPECIFIER             0x1004
 /**
- * String for the given device's specifier.
+ * Device specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known device specifiers (list ends with an empty string).
  */
 #define ALC_DEVICE_SPECIFIER                     0x1005
@@ -141,9 +175,9 @@ typedef void ALCvoid;
 /** Capture extension */
 #define ALC_EXT_CAPTURE 1
 /**
- * String for the given capture device's specifier.
+ * Capture device specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known capture device specifiers (list ends with an empty string).
  */
 #define ALC_CAPTURE_DEVICE_SPECIFIER             0x310
@@ -158,80 +192,116 @@ typedef void ALCvoid;
 /** String for the default extended device specifier. */
 #define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
 /**
- * String for the given extended device's specifier.
+ * Device's extended specifier string.
  *
- * If device handle is NULL, it is instead a null-char separated list of
+ * If device handle is NULL, it is instead a null-character separated list of
  * strings of known extended device specifiers (list ends with an empty string).
  */
 #define ALC_ALL_DEVICES_SPECIFIER                0x1013
 
 
-/** Context management. */
-ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist);
-ALC_API ALCboolean  ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context);
-ALC_API void        ALC_APIENTRY alcProcessContext(ALCcontext *context);
-ALC_API void        ALC_APIENTRY alcSuspendContext(ALCcontext *context);
-ALC_API void        ALC_APIENTRY alcDestroyContext(ALCcontext *context);
-ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void);
-ALC_API ALCdevice*  ALC_APIENTRY alcGetContextsDevice(ALCcontext *context);
+#ifndef ALC_NO_PROTOTYPES
+/* Context management. */
 
-/** Device management. */
-ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename);
-ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device);
+/** Create and attach a context to the given device. */
+ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrlist) ALC_API_NOEXCEPT;
+/**
+ * Makes the given context the active process-wide context. Passing NULL clears
+ * the active context.
+ */
+ALC_API ALCboolean  ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context) ALC_API_NOEXCEPT;
+/** Resumes processing updates for the given context. */
+ALC_API void        ALC_APIENTRY alcProcessContext(ALCcontext *context) ALC_API_NOEXCEPT;
+/** Suspends updates for the given context. */
+ALC_API void        ALC_APIENTRY alcSuspendContext(ALCcontext *context) ALC_API_NOEXCEPT;
+/** Remove a context from its device and destroys it. */
+ALC_API void        ALC_APIENTRY alcDestroyContext(ALCcontext *context) ALC_API_NOEXCEPT;
+/** Returns the currently active context. */
+ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void) ALC_API_NOEXCEPT;
+/** Returns the device that a particular context is attached to. */
+ALC_API ALCdevice*  ALC_APIENTRY alcGetContextsDevice(ALCcontext *context) ALC_API_NOEXCEPT;
 
+/* Device management. */
+
+/** Opens the named playback device. */
+ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename) ALC_API_NOEXCEPT;
+/** Closes the given playback device. */
+ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device) ALC_API_NOEXCEPT;
+
+/* Error support. */
+
+/** Obtain the most recent Device error. */
+ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device) ALC_API_NOEXCEPT;
+
+/* Extension support. */
 
 /**
- * Error support.
- *
- * Obtain the most recent Device error.
+ * Query for the presence of an extension on the device. Pass a NULL device to
+ * query a device-inspecific extension.
  */
-ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device);
+ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname) ALC_API_NOEXCEPT;
+/**
+ * Retrieve the address of a function. Given a non-NULL device, the returned
+ * function may be device-specific.
+ */
+ALC_API ALCvoid*   ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname) ALC_API_NOEXCEPT;
+/**
+ * Retrieve the value of an enum. Given a non-NULL device, the returned value
+ * may be device-specific.
+ */
+ALC_API ALCenum    ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname) ALC_API_NOEXCEPT;
+
+/* Query functions. */
+
+/** Returns information about the device, and error strings. */
+ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param) ALC_API_NOEXCEPT;
+/** Returns information about the device and the version of OpenAL. */
+ALC_API void           ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values) ALC_API_NOEXCEPT;
+
+/* Capture functions. */
 
 /**
- * Extension support.
- *
- * Query for the presence of an extension, and obtain any appropriate
- * function pointers and enum values.
+ * Opens the named capture device with the given frequency, format, and buffer
+ * size.
  */
-ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname);
-ALC_API void*      ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
-ALC_API ALCenum    ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname);
+ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize) ALC_API_NOEXCEPT;
+/** Closes the given capture device. */
+ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device) ALC_API_NOEXCEPT;
+/** Starts capturing samples into the device buffer. */
+ALC_API void       ALC_APIENTRY alcCaptureStart(ALCdevice *device) ALC_API_NOEXCEPT;
+/** Stops capturing samples. Samples in the device buffer remain available. */
+ALC_API void       ALC_APIENTRY alcCaptureStop(ALCdevice *device) ALC_API_NOEXCEPT;
+/** Reads samples from the device buffer. */
+ALC_API void       ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) ALC_API_NOEXCEPT;
+#endif /* ALC_NO_PROTOTYPES */
 
-/** Query function. */
-ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param);
-ALC_API void           ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
+/* Pointer-to-function types, useful for storing dynamically loaded ALC entry
+ * points.
+ */
+typedef ALCcontext*    (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist) ALC_API_NOEXCEPT17;
+typedef ALCboolean     (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCSUSPENDCONTEXT)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCDESTROYCONTEXT)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef ALCcontext*    (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)(void) ALC_API_NOEXCEPT17;
+typedef ALCdevice*     (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef ALCdevice*     (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename) ALC_API_NOEXCEPT17;
+typedef ALCboolean     (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef ALCenum        (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef ALCboolean     (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname) ALC_API_NOEXCEPT17;
+typedef ALCvoid*       (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname) ALC_API_NOEXCEPT17;
+typedef ALCenum        (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname) ALC_API_NOEXCEPT17;
+typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values) ALC_API_NOEXCEPT17;
+typedef ALCdevice*     (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize) ALC_API_NOEXCEPT17;
+typedef ALCboolean     (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef void           (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) ALC_API_NOEXCEPT17;
 
-/** Capture function. */
-ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
-ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device);
-ALC_API void       ALC_APIENTRY alcCaptureStart(ALCdevice *device);
-ALC_API void       ALC_APIENTRY alcCaptureStop(ALCdevice *device);
-ALC_API void       ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
-
-/** Pointer-to-function type, useful for dynamically getting ALC entry points. */
-typedef ALCcontext*    (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist);
-typedef ALCboolean     (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context);
-typedef void           (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context);
-typedef void           (ALC_APIENTRY *LPALCSUSPENDCONTEXT)(ALCcontext *context);
-typedef void           (ALC_APIENTRY *LPALCDESTROYCONTEXT)(ALCcontext *context);
-typedef ALCcontext*    (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)(void);
-typedef ALCdevice*     (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)(ALCcontext *context);
-typedef ALCdevice*     (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename);
-typedef ALCboolean     (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device);
-typedef ALCenum        (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device);
-typedef ALCboolean     (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname);
-typedef void*          (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname);
-typedef ALCenum        (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname);
-typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param);
-typedef void           (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
-typedef ALCdevice*     (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
-typedef ALCboolean     (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)(ALCdevice *device);
-typedef void           (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device);
-typedef void           (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device);
-typedef void           (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
-
-#if defined(__cplusplus)
-}
+#ifdef __cplusplus
+} /* extern "C" */
 #endif
+/* NOLINTEND */
 
 #endif /* AL_ALC_H */

code/AL/alext.h

@@ -1,38 +1,22 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2008 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
 #ifndef AL_ALEXT_H
 #define AL_ALEXT_H
 
+/* NOLINTBEGIN */
 #include <stddef.h>
-/* Define int64_t and uint64_t types */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#include <inttypes.h>
-#elif defined(_WIN32) && defined(__GNUC__)
+/* Define int64 and uint64 types */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) ||             \
+    (defined(__cplusplus) && __cplusplus >= 201103L)
 #include <stdint.h>
+typedef int64_t _alsoft_int64_t;
+typedef uint64_t _alsoft_uint64_t;
 #elif defined(_WIN32)
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
+typedef __int64 _alsoft_int64_t;
+typedef unsigned __int64 _alsoft_uint64_t;
 #else
 /* Fallback if nothing above works */
-#include <inttypes.h>
+#include <stdint.h>
+typedef int64_t _alsoft_int64_t;
+typedef uint64_t _alsoft_uint64_t;
 #endif
 
 #include "alc.h"
@@ -42,6 +26,8 @@ typedef unsigned __int64 uint64_t;
 extern "C" {
 #endif
 
+struct _GUID;
+
 #ifndef AL_LOKI_IMA_ADPCM_format
 #define AL_LOKI_IMA_ADPCM_format 1
 #define AL_FORMAT_IMA_ADPCM_MONO16_EXT           0x10000
@@ -97,6 +83,31 @@ extern "C" {
 
 #ifndef AL_EXT_MCFORMATS
 #define AL_EXT_MCFORMATS 1
+/* Provides support for surround sound buffer formats with 8, 16, and 32-bit
+ * samples.
+ *
+ * QUAD8: Unsigned 8-bit, Quadraphonic (Front Left, Front Right, Rear Left,
+ *        Rear Right).
+ * QUAD16: Signed 16-bit, Quadraphonic.
+ * QUAD32: 32-bit float, Quadraphonic.
+ * REAR8: Unsigned 8-bit, Rear Stereo (Rear Left, Rear Right).
+ * REAR16: Signed 16-bit, Rear Stereo.
+ * REAR32: 32-bit float, Rear Stereo.
+ * 51CHN8: Unsigned 8-bit, 5.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Side Left, Side Right). Note that some audio systems may label
+ *         5.1's Side channels as Rear or Surround; they are equivalent for the
+ *         purposes of this extension.
+ * 51CHN16: Signed 16-bit, 5.1 Surround.
+ * 51CHN32: 32-bit float, 5.1 Surround.
+ * 61CHN8: Unsigned 8-bit, 6.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Rear Center, Side Left, Side Right).
+ * 61CHN16: Signed 16-bit, 6.1 Surround.
+ * 61CHN32: 32-bit float, 6.1 Surround.
+ * 71CHN8: Unsigned 8-bit, 7.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Rear Left, Rear Right, Side Left, Side Right).
+ * 71CHN16: Signed 16-bit, 7.1 Surround.
+ * 71CHN32: 32-bit float, 7.1 Surround.
+ */
 #define AL_FORMAT_QUAD8                          0x1204
 #define AL_FORMAT_QUAD16                         0x1205
 #define AL_FORMAT_QUAD32                         0x1206
@@ -133,9 +144,9 @@ extern "C" {
 
 #ifndef AL_EXT_STATIC_BUFFER
 #define AL_EXT_STATIC_BUFFER 1
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei);
+typedef void (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALuint,ALenum,ALvoid*,ALsizei,ALsizei) AL_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq);
+void AL_APIENTRY alBufferDataStatic(const ALuint buffer, ALenum format, ALvoid *data, ALsizei size, ALsizei freq) AL_API_NOEXCEPT;
 #endif
 #endif
 
@@ -151,11 +162,11 @@ AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format,
 
 #ifndef ALC_EXT_thread_local_context
 #define ALC_EXT_thread_local_context 1
-typedef ALCboolean  (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context);
-typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void);
+typedef ALCboolean  (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context) ALC_API_NOEXCEPT17;
+typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void) ALC_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-ALC_API ALCboolean  ALC_APIENTRY alcSetThreadContext(ALCcontext *context);
-ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
+ALC_API ALCboolean  ALC_APIENTRY alcSetThreadContext(ALCcontext *context) ALC_API_NOEXCEPT;
+ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void) ALC_API_NOEXCEPT;
 #endif
 #endif
 
@@ -168,9 +179,9 @@ ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
 #define AL_SOFT_buffer_sub_data 1
 #define AL_BYTE_RW_OFFSETS_SOFT                  0x1031
 #define AL_SAMPLE_RW_OFFSETS_SOFT                0x1032
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
+typedef void (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei) AL_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
+AL_API void AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length) AL_API_NOEXCEPT;
 #endif
 #endif
 
@@ -187,12 +198,12 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const
 #define AL_FOLDBACK_EVENT_STOP                   0x4113
 #define AL_FOLDBACK_MODE_MONO                    0x4101
 #define AL_FOLDBACK_MODE_STEREO                  0x4102
-typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei);
-typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK);
-typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void);
+typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void) AL_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback);
-AL_API void AL_APIENTRY alRequestFoldbackStop(void);
+AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alRequestFoldbackStop(void) AL_API_NOEXCEPT;
 #endif
 #endif
 
@@ -255,15 +266,15 @@ AL_API void AL_APIENTRY alRequestFoldbackStop(void);
 #define AL_SAMPLE_LENGTH_SOFT                    0x200A
 #define AL_SEC_LENGTH_SOFT                       0x200B
 
-typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*);
-typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*);
-typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*);
-typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum);
+typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum) AL_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
-AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
-AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data);
-AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format);
+AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format) AL_API_NOEXCEPT;
 #endif
 #endif
 
@@ -294,13 +305,13 @@ AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format);
 #define ALC_6POINT1_SOFT                         0x1505
 #define ALC_7POINT1_SOFT                         0x1506
 
-typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*);
-typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum);
-typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei);
+typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*) ALC_API_NOEXCEPT17;
+typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum) ALC_API_NOEXCEPT17;
+typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei) ALC_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName);
-ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type);
-ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName) AL_API_NOEXCEPT;
+ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type) AL_API_NOEXCEPT;
+ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) AL_API_NOEXCEPT;
 #endif
 #endif
 
@@ -318,38 +329,764 @@ ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffe
 #define AL_SOFT_source_latency 1
 #define AL_SAMPLE_OFFSET_LATENCY_SOFT            0x1200
 #define AL_SEC_OFFSET_LATENCY_SOFT               0x1201
-typedef int64_t ALint64SOFT;
-typedef uint64_t ALuint64SOFT;
-typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble);
-typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble);
-typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
-typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT);
-typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT);
-typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
+typedef _alsoft_int64_t ALint64SOFT;
+typedef _alsoft_uint64_t ALuint64SOFT;
+typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*) AL_API_NOEXCEPT17;
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value);
-AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3);
-AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values);
-AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value);
-AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3);
-AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values);
-AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value);
-AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3);
-AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values);
-AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
-AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
-AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
+AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values) AL_API_NOEXCEPT;
 #endif
 #endif
 
+#ifndef ALC_EXT_DEFAULT_FILTER_ORDER
+#define ALC_EXT_DEFAULT_FILTER_ORDER 1
+#define ALC_DEFAULT_FILTER_ORDER                 0x1100
+#endif
+
+#ifndef AL_SOFT_deferred_updates
+#define AL_SOFT_deferred_updates 1
+#define AL_DEFERRED_UPDATES_SOFT                 0xC002
+typedef void (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alDeferUpdatesSOFT(void) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alProcessUpdatesSOFT(void) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_block_alignment
+#define AL_SOFT_block_alignment 1
+#define AL_UNPACK_BLOCK_ALIGNMENT_SOFT           0x200C
+#define AL_PACK_BLOCK_ALIGNMENT_SOFT             0x200D
+#endif
+
+#ifndef AL_SOFT_MSADPCM
+#define AL_SOFT_MSADPCM 1
+#define AL_FORMAT_MONO_MSADPCM_SOFT              0x1302
+#define AL_FORMAT_STEREO_MSADPCM_SOFT            0x1303
+#endif
+
+#ifndef AL_SOFT_source_length
+#define AL_SOFT_source_length 1
+/*#define AL_BYTE_LENGTH_SOFT                      0x2009*/
+/*#define AL_SAMPLE_LENGTH_SOFT                    0x200A*/
+/*#define AL_SEC_LENGTH_SOFT                       0x200B*/
+#endif
+
+#ifndef AL_SOFT_buffer_length_query
+#define AL_SOFT_buffer_length_query 1
+/*#define AL_BYTE_LENGTH_SOFT                      0x2009*/
+/*#define AL_SAMPLE_LENGTH_SOFT                    0x200A*/
+/*#define AL_SEC_LENGTH_SOFT                       0x200B*/
+#endif
+
+#ifndef ALC_SOFT_pause_device
+#define ALC_SOFT_pause_device 1
+typedef void (ALC_APIENTRY*LPALCDEVICEPAUSESOFT)(ALCdevice *device) ALC_API_NOEXCEPT17;
+typedef void (ALC_APIENTRY*LPALCDEVICERESUMESOFT)(ALCdevice *device) ALC_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device) ALC_API_NOEXCEPT;
+ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device) ALC_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_EXT_BFORMAT
+#define AL_EXT_BFORMAT 1
+/* Provides support for B-Format ambisonic buffers (first-order, FuMa scaling
+ * and layout).
+ *
+ * BFORMAT2D_8: Unsigned 8-bit, 3-channel non-periphonic (WXY).
+ * BFORMAT2D_16: Signed 16-bit, 3-channel non-periphonic (WXY).
+ * BFORMAT2D_FLOAT32: 32-bit float, 3-channel non-periphonic (WXY).
+ * BFORMAT3D_8: Unsigned 8-bit, 4-channel periphonic (WXYZ).
+ * BFORMAT3D_16: Signed 16-bit, 4-channel periphonic (WXYZ).
+ * BFORMAT3D_FLOAT32: 32-bit float, 4-channel periphonic (WXYZ).
+ */
+#define AL_FORMAT_BFORMAT2D_8                    0x20021
+#define AL_FORMAT_BFORMAT2D_16                   0x20022
+#define AL_FORMAT_BFORMAT2D_FLOAT32              0x20023
+#define AL_FORMAT_BFORMAT3D_8                    0x20031
+#define AL_FORMAT_BFORMAT3D_16                   0x20032
+#define AL_FORMAT_BFORMAT3D_FLOAT32              0x20033
+#endif
+
+#ifndef AL_EXT_MULAW_BFORMAT
+#define AL_EXT_MULAW_BFORMAT 1
+#define AL_FORMAT_BFORMAT2D_MULAW                0x10031
+#define AL_FORMAT_BFORMAT3D_MULAW                0x10032
+#endif
+
+#ifndef ALC_SOFT_HRTF
+#define ALC_SOFT_HRTF 1
+#define ALC_HRTF_SOFT                            0x1992
+#define ALC_DONT_CARE_SOFT                       0x0002
+#define ALC_HRTF_STATUS_SOFT                     0x1993
+#define ALC_HRTF_DISABLED_SOFT                   0x0000
+#define ALC_HRTF_ENABLED_SOFT                    0x0001
+#define ALC_HRTF_DENIED_SOFT                     0x0002
+#define ALC_HRTF_REQUIRED_SOFT                   0x0003
+#define ALC_HRTF_HEADPHONES_DETECTED_SOFT        0x0004
+#define ALC_HRTF_UNSUPPORTED_FORMAT_SOFT         0x0005
+#define ALC_NUM_HRTF_SPECIFIERS_SOFT             0x1994
+#define ALC_HRTF_SPECIFIER_SOFT                  0x1995
+#define ALC_HRTF_ID_SOFT                         0x1996
+typedef const ALCchar* (ALC_APIENTRY*LPALCGETSTRINGISOFT)(ALCdevice *device, ALCenum paramName, ALCsizei index) ALC_API_NOEXCEPT17;
+typedef ALCboolean (ALC_APIENTRY*LPALCRESETDEVICESOFT)(ALCdevice *device, const ALCint *attribs) ALC_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index) ALC_API_NOEXCEPT;
+ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs) ALC_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_gain_clamp_ex
+#define AL_SOFT_gain_clamp_ex 1
+#define AL_GAIN_LIMIT_SOFT                       0x200E
+#endif
+
+#ifndef AL_SOFT_source_resampler
+#define AL_SOFT_source_resampler
+#define AL_NUM_RESAMPLERS_SOFT                   0x1210
+#define AL_DEFAULT_RESAMPLER_SOFT                0x1211
+#define AL_SOURCE_RESAMPLER_SOFT                 0x1212
+#define AL_RESAMPLER_NAME_SOFT                   0x1213
+typedef const ALchar* (AL_APIENTRY*LPALGETSTRINGISOFT)(ALenum pname, ALsizei index) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_source_spatialize
+#define AL_SOFT_source_spatialize
+#define AL_SOURCE_SPATIALIZE_SOFT                0x1214
+#define AL_AUTO_SOFT                             0x0002
+#endif
+
+#ifndef ALC_SOFT_output_limiter
+#define ALC_SOFT_output_limiter
+#define ALC_OUTPUT_LIMITER_SOFT                  0x199A
+#endif
+
+#ifndef ALC_SOFT_device_clock
+#define ALC_SOFT_device_clock 1
+typedef _alsoft_int64_t ALCint64SOFT;
+typedef _alsoft_uint64_t ALCuint64SOFT;
+#define ALC_DEVICE_CLOCK_SOFT                    0x1600
+#define ALC_DEVICE_LATENCY_SOFT                  0x1601
+#define ALC_DEVICE_CLOCK_LATENCY_SOFT            0x1602
+#define AL_SAMPLE_OFFSET_CLOCK_SOFT              0x1202
+#define AL_SEC_OFFSET_CLOCK_SOFT                 0x1203
+typedef void (ALC_APIENTRY*LPALCGETINTEGER64VSOFT)(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values) ALC_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values) ALC_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_direct_channels_remix
+#define AL_SOFT_direct_channels_remix 1
+#define AL_DROP_UNMATCHED_SOFT                   0x0001
+#define AL_REMIX_UNMATCHED_SOFT                  0x0002
+#endif
+
+#ifndef AL_SOFT_bformat_ex
+#define AL_SOFT_bformat_ex 1
+#define AL_AMBISONIC_LAYOUT_SOFT                 0x1997
+#define AL_AMBISONIC_SCALING_SOFT                0x1998
+
+/* Ambisonic layouts */
+#define AL_FUMA_SOFT                             0x0000
+#define AL_ACN_SOFT                              0x0001
+
+/* Ambisonic scalings (normalization) */
+/*#define AL_FUMA_SOFT*/
+#define AL_SN3D_SOFT                             0x0001
+#define AL_N3D_SOFT                              0x0002
+#endif
+
+#ifndef ALC_SOFT_loopback_bformat
+#define ALC_SOFT_loopback_bformat 1
+#define ALC_AMBISONIC_LAYOUT_SOFT                0x1997
+#define ALC_AMBISONIC_SCALING_SOFT               0x1998
+#define ALC_AMBISONIC_ORDER_SOFT                 0x1999
+#define ALC_MAX_AMBISONIC_ORDER_SOFT             0x199B
+
+#define ALC_BFORMAT3D_SOFT                       0x1507
+
+/* Ambisonic layouts */
+#define ALC_FUMA_SOFT                            0x0000
+#define ALC_ACN_SOFT                             0x0001
+
+/* Ambisonic scalings (normalization) */
+/*#define ALC_FUMA_SOFT*/
+#define ALC_SN3D_SOFT                            0x0001
+#define ALC_N3D_SOFT                             0x0002
+#endif
+
+#ifndef AL_SOFT_effect_target
+#define AL_SOFT_effect_target
+#define AL_EFFECTSLOT_TARGET_SOFT                0x199C
+#endif
+
+#ifndef AL_SOFT_events
+#define AL_SOFT_events 1
+#define AL_EVENT_CALLBACK_FUNCTION_SOFT          0x19A2
+#define AL_EVENT_CALLBACK_USER_PARAM_SOFT        0x19A3
+#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT      0x19A4
+#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT  0x19A5
+#define AL_EVENT_TYPE_DISCONNECTED_SOFT          0x19A6
+typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param,
+    ALsizei length, const ALchar *message, void *userParam) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam) AL_API_NOEXCEPT17;
+typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam) AL_API_NOEXCEPT;
+AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef ALC_SOFT_reopen_device
+#define ALC_SOFT_reopen_device
+typedef ALCboolean (ALC_APIENTRY*LPALCREOPENDEVICESOFT)(ALCdevice *device,
+    const ALCchar *deviceName, const ALCint *attribs) ALC_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALCboolean ALC_APIENTRY alcReopenDeviceSOFT(ALCdevice *device, const ALCchar *deviceName,
+    const ALCint *attribs) ALC_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_callback_buffer
+#define AL_SOFT_callback_buffer
+#define AL_BUFFER_CALLBACK_FUNCTION_SOFT         0x19A0
+#define AL_BUFFER_CALLBACK_USER_PARAM_SOFT       0x19A1
+typedef ALsizei (AL_APIENTRY*ALBUFFERCALLBACKTYPESOFT)(ALvoid *userptr, ALvoid *sampledata, ALsizei numbytes) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALBUFFERCALLBACKSOFT)(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETBUFFERPTRSOFT)(ALuint buffer, ALenum param, ALvoid **value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETBUFFER3PTRSOFT)(ALuint buffer, ALenum param, ALvoid **value1, ALvoid **value2, ALvoid **value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETBUFFERPTRVSOFT)(ALuint buffer, ALenum param, ALvoid **values) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alBufferCallbackSOFT(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferPtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBuffer3PtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr0, ALvoid **ptr1, ALvoid **ptr2) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetBufferPtrvSOFT(ALuint buffer, ALenum param, ALvoid **ptr) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_UHJ
+#define AL_SOFT_UHJ
+#define AL_FORMAT_UHJ2CHN8_SOFT                  0x19A2
+#define AL_FORMAT_UHJ2CHN16_SOFT                 0x19A3
+#define AL_FORMAT_UHJ2CHN_FLOAT32_SOFT           0x19A4
+#define AL_FORMAT_UHJ3CHN8_SOFT                  0x19A5
+#define AL_FORMAT_UHJ3CHN16_SOFT                 0x19A6
+#define AL_FORMAT_UHJ3CHN_FLOAT32_SOFT           0x19A7
+#define AL_FORMAT_UHJ4CHN8_SOFT                  0x19A8
+#define AL_FORMAT_UHJ4CHN16_SOFT                 0x19A9
+#define AL_FORMAT_UHJ4CHN_FLOAT32_SOFT           0x19AA
+
+#define AL_STEREO_MODE_SOFT                      0x19B0
+#define AL_NORMAL_SOFT                           0x0000
+#define AL_SUPER_STEREO_SOFT                     0x0001
+#define AL_SUPER_STEREO_WIDTH_SOFT               0x19B1
+#endif
+
+#ifndef AL_SOFT_UHJ_ex
+#define AL_SOFT_UHJ_ex
+#define AL_FORMAT_UHJ2CHN_MULAW_SOFT             0x19B3
+#define AL_FORMAT_UHJ2CHN_ALAW_SOFT              0x19B4
+#define AL_FORMAT_UHJ2CHN_IMA4_SOFT              0x19B5
+#define AL_FORMAT_UHJ2CHN_MSADPCM_SOFT           0x19B6
+#define AL_FORMAT_UHJ3CHN_MULAW_SOFT             0x19B7
+#define AL_FORMAT_UHJ3CHN_ALAW_SOFT              0x19B8
+#define AL_FORMAT_UHJ4CHN_MULAW_SOFT             0x19B9
+#define AL_FORMAT_UHJ4CHN_ALAW_SOFT              0x19BA
+#endif
+
+#ifndef ALC_SOFT_output_mode
+#define ALC_SOFT_output_mode
+#define ALC_OUTPUT_MODE_SOFT                     0x19AC
+#define ALC_ANY_SOFT                             0x19AD
+/*#define ALC_MONO_SOFT                            0x1500*/
+/*#define ALC_STEREO_SOFT                          0x1501*/
+#define ALC_STEREO_BASIC_SOFT                    0x19AE
+#define ALC_STEREO_UHJ_SOFT                      0x19AF
+#define ALC_STEREO_HRTF_SOFT                     0x19B2
+/*#define ALC_QUAD_SOFT                            0x1503*/
+#define ALC_SURROUND_5_1_SOFT                    0x1504
+#define ALC_SURROUND_6_1_SOFT                    0x1505
+#define ALC_SURROUND_7_1_SOFT                    0x1506
+#endif
+
+#ifndef AL_SOFT_source_start_delay
+#define AL_SOFT_source_start_delay
+typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMESOFT)(ALuint source, ALint64SOFT start_time) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMEVSOFT)(ALsizei n, const ALuint *sources, ALint64SOFT start_time) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+void AL_APIENTRY alSourcePlayAtTimeSOFT(ALuint source, ALint64SOFT start_time) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePlayAtTimevSOFT(ALsizei n, const ALuint *sources, ALint64SOFT start_time) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef ALC_EXT_debug
+#define ALC_EXT_debug
+#define ALC_CONTEXT_FLAGS_EXT                    0x19CF
+#define ALC_CONTEXT_DEBUG_BIT_EXT                0x0001
+#endif
+
+#ifndef AL_EXT_debug
+#define AL_EXT_debug
+#define AL_DONT_CARE_EXT                         0x0002
+#define AL_DEBUG_OUTPUT_EXT                      0x19B2
+#define AL_DEBUG_CALLBACK_FUNCTION_EXT           0x19B3
+#define AL_DEBUG_CALLBACK_USER_PARAM_EXT         0x19B4
+#define AL_DEBUG_SOURCE_API_EXT                  0x19B5
+#define AL_DEBUG_SOURCE_AUDIO_SYSTEM_EXT         0x19B6
+#define AL_DEBUG_SOURCE_THIRD_PARTY_EXT          0x19B7
+#define AL_DEBUG_SOURCE_APPLICATION_EXT          0x19B8
+#define AL_DEBUG_SOURCE_OTHER_EXT                0x19B9
+#define AL_DEBUG_TYPE_ERROR_EXT                  0x19BA
+#define AL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_EXT    0x19BB
+#define AL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_EXT     0x19BC
+#define AL_DEBUG_TYPE_PORTABILITY_EXT            0x19BD
+#define AL_DEBUG_TYPE_PERFORMANCE_EXT            0x19BE
+#define AL_DEBUG_TYPE_MARKER_EXT                 0x19BF
+#define AL_DEBUG_TYPE_PUSH_GROUP_EXT             0x19C0
+#define AL_DEBUG_TYPE_POP_GROUP_EXT              0x19C1
+#define AL_DEBUG_TYPE_OTHER_EXT                  0x19C2
+#define AL_DEBUG_SEVERITY_HIGH_EXT               0x19C3
+#define AL_DEBUG_SEVERITY_MEDIUM_EXT             0x19C4
+#define AL_DEBUG_SEVERITY_LOW_EXT                0x19C5
+#define AL_DEBUG_SEVERITY_NOTIFICATION_EXT       0x19C6
+#define AL_DEBUG_LOGGED_MESSAGES_EXT             0x19C7
+#define AL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_EXT  0x19C8
+#define AL_MAX_DEBUG_MESSAGE_LENGTH_EXT          0x19C9
+#define AL_MAX_DEBUG_LOGGED_MESSAGES_EXT         0x19CA
+#define AL_MAX_DEBUG_GROUP_STACK_DEPTH_EXT       0x19CB
+#define AL_MAX_LABEL_LENGTH_EXT                  0x19CC
+#define AL_STACK_OVERFLOW_EXT                    0x19CD
+#define AL_STACK_UNDERFLOW_EXT                   0x19CE
+#define AL_CONTEXT_FLAGS_EXT                     0x19CF
+#define AL_BUFFER_EXT                            0x1009 /* Same as AL_BUFFER */
+#define AL_SOURCE_EXT                            0x19D0
+#define AL_FILTER_EXT                            0x19D1
+#define AL_EFFECT_EXT                            0x19D2
+#define AL_AUXILIARY_EFFECT_SLOT_EXT             0x19D3
+
+typedef void (AL_APIENTRY*ALDEBUGPROCEXT)(ALenum source, ALenum type, ALuint id, ALenum severity, ALsizei length, const ALchar *message, void *userParam) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGECALLBACKEXT)(ALDEBUGPROCEXT callback, void *userParam) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGEINSERTEXT)(ALenum source, ALenum type, ALuint id, ALenum severity, ALsizei length, const ALchar *message) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGECONTROLEXT)(ALenum source, ALenum type, ALenum severity, ALsizei count, const ALuint *ids, ALboolean enable) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALPUSHDEBUGGROUPEXT)(ALenum source, ALuint id, ALsizei length, const ALchar *message) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALPOPDEBUGGROUPEXT)(void) AL_API_NOEXCEPT17;
+typedef ALuint (AL_APIENTRY*LPALGETDEBUGMESSAGELOGEXT)(ALuint count, ALsizei logBufSize, ALenum *sources, ALenum *types, ALuint *ids, ALenum *severities, ALsizei *lengths, ALchar *logBuf) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALOBJECTLABELEXT)(ALenum identifier, ALuint name, ALsizei length, const ALchar *label) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETOBJECTLABELEXT)(ALenum identifier, ALuint name, ALsizei bufSize, ALsizei *length, ALchar *label) AL_API_NOEXCEPT17;
+typedef void* (AL_APIENTRY*LPALGETPOINTEREXT)(ALenum pname) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETPOINTERVEXT)(ALenum pname, void **values) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+void AL_APIENTRY alDebugMessageCallbackEXT(ALDEBUGPROCEXT callback, void *userParam) AL_API_NOEXCEPT;
+void AL_APIENTRY alDebugMessageInsertEXT(ALenum source, ALenum type, ALuint id, ALenum severity, ALsizei length, const ALchar *message) AL_API_NOEXCEPT;
+void AL_APIENTRY alDebugMessageControlEXT(ALenum source, ALenum type, ALenum severity, ALsizei count, const ALuint *ids, ALboolean enable) AL_API_NOEXCEPT;
+void AL_APIENTRY alPushDebugGroupEXT(ALenum source, ALuint id, ALsizei length, const ALchar *message) AL_API_NOEXCEPT;
+void AL_APIENTRY alPopDebugGroupEXT(void) AL_API_NOEXCEPT;
+ALuint AL_APIENTRY alGetDebugMessageLogEXT(ALuint count, ALsizei logBufSize, ALenum *sources, ALenum *types, ALuint *ids, ALenum *severities, ALsizei *lengths, ALchar *logBuf) AL_API_NOEXCEPT;
+void AL_APIENTRY alObjectLabelEXT(ALenum identifier, ALuint name, ALsizei length, const ALchar *label) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetObjectLabelEXT(ALenum identifier, ALuint name, ALsizei bufSize, ALsizei *length, ALchar *label) AL_API_NOEXCEPT;
+void* AL_APIENTRY alGetPointerEXT(ALenum pname) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetPointervEXT(ALenum pname, void **values) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef ALC_SOFT_system_events
+#define ALC_SOFT_system_events
+#define ALC_PLAYBACK_DEVICE_SOFT                 0x19D4
+#define ALC_CAPTURE_DEVICE_SOFT                  0x19D5
+#define ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT 0x19D6
+#define ALC_EVENT_TYPE_DEVICE_ADDED_SOFT         0x19D7
+#define ALC_EVENT_TYPE_DEVICE_REMOVED_SOFT       0x19D8
+#define ALC_EVENT_SUPPORTED_SOFT                 0x19D9
+#define ALC_EVENT_NOT_SUPPORTED_SOFT             0x19DA
+typedef void (ALC_APIENTRY*ALCEVENTPROCTYPESOFT)(ALCenum eventType, ALCenum deviceType,
+    ALCdevice *device, ALCsizei length, const ALCchar *message, void *userParam) ALC_API_NOEXCEPT17;
+typedef ALCenum (ALC_APIENTRY*LPALCEVENTISSUPPORTEDSOFT)(ALCenum eventType, ALCenum deviceType) ALC_API_NOEXCEPT17;
+typedef ALCboolean (ALC_APIENTRY*LPALCEVENTCONTROLSOFT)(ALCsizei count, const ALCenum *events, ALCboolean enable) ALC_API_NOEXCEPT17;
+typedef void (ALC_APIENTRY*LPALCEVENTCALLBACKSOFT)(ALCEVENTPROCTYPESOFT callback, void *userParam) ALC_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALCenum ALC_APIENTRY alcEventIsSupportedSOFT(ALCenum eventType, ALCenum deviceType) ALC_API_NOEXCEPT;
+ALCboolean ALC_APIENTRY alcEventControlSOFT(ALCsizei count, const ALCenum *events, ALCboolean enable) ALC_API_NOEXCEPT;
+void ALC_APIENTRY alcEventCallbackSOFT(ALCEVENTPROCTYPESOFT callback, void *userParam) ALC_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_EXT_direct_context
+#define AL_EXT_direct_context
+typedef ALCvoid* (ALC_APIENTRY *LPALCGETPROCADDRESS2)(ALCdevice *device, const ALCchar *funcname) AL_API_NOEXCEPT17;
+
+typedef void (AL_APIENTRY *LPALENABLEDIRECT)(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDISABLEDIRECT)(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISENABLEDDIRECT)(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDOPPLERFACTORDIRECT)(ALCcontext *context, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSPEEDOFSOUNDDIRECT)(ALCcontext *context, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDISTANCEMODELDIRECT)(ALCcontext *context, ALenum distanceModel) AL_API_NOEXCEPT17;
+typedef const ALchar* (AL_APIENTRY *LPALGETSTRINGDIRECT)(ALCcontext *context, ALenum param) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBOOLEANVDIRECT)(ALCcontext *context, ALenum param, ALboolean *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETINTEGERVDIRECT)(ALCcontext *context, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFLOATVDIRECT)(ALCcontext *context, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETDOUBLEVDIRECT)(ALCcontext *context, ALenum param, ALdouble *values) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALGETBOOLEANDIRECT)(ALCcontext *context, ALenum param) AL_API_NOEXCEPT17;
+typedef ALint (AL_APIENTRY *LPALGETINTEGERDIRECT)(ALCcontext *context, ALenum param) AL_API_NOEXCEPT17;
+typedef ALfloat (AL_APIENTRY *LPALGETFLOATDIRECT)(ALCcontext *context, ALenum param) AL_API_NOEXCEPT17;
+typedef ALdouble (AL_APIENTRY *LPALGETDOUBLEDIRECT)(ALCcontext *context, ALenum param) AL_API_NOEXCEPT17;
+typedef ALenum (AL_APIENTRY *LPALGETERRORDIRECT)(ALCcontext *context) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISEXTENSIONPRESENTDIRECT)(ALCcontext *context, const ALchar *extname) AL_API_NOEXCEPT17;
+typedef void* (AL_APIENTRY *LPALGETPROCADDRESSDIRECT)(ALCcontext *context, const ALchar *fname) AL_API_NOEXCEPT17;
+typedef ALenum (AL_APIENTRY *LPALGETENUMVALUEDIRECT)(ALCcontext *context, const ALchar *ename) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENERFDIRECT)(ALCcontext *context, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENER3FDIRECT)(ALCcontext *context, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENERFVDIRECT)(ALCcontext *context, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENERIDIRECT)(ALCcontext *context, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENER3IDIRECT)(ALCcontext *context, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALLISTENERIVDIRECT)(ALCcontext *context, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENERFDIRECT)(ALCcontext *context, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENER3FDIRECT)(ALCcontext *context, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENERFVDIRECT)(ALCcontext *context, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENERIDIRECT)(ALCcontext *context, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENER3IDIRECT)(ALCcontext *context, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETLISTENERIVDIRECT)(ALCcontext *context, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGENSOURCESDIRECT)(ALCcontext *context, ALsizei n, ALuint *sources) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETESOURCESDIRECT)(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISSOURCEDIRECT)(ALCcontext *context, ALuint source) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEFDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCE3FDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEFVDIRECT)(ALCcontext *context, ALuint source, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEIDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCE3IDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEIVDIRECT)(ALCcontext *context, ALuint source, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEFDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCE3FDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEFVDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEIDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCE3IDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEIVDIRECT)(ALCcontext *context, ALuint source, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEPLAYDIRECT)(ALCcontext *context, ALuint source) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCESTOPDIRECT)(ALCcontext *context, ALuint source) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEREWINDDIRECT)(ALCcontext *context, ALuint source) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEPAUSEDIRECT)(ALCcontext *context, ALuint source) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEPLAYVDIRECT)(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCESTOPVDIRECT)(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEREWINDVDIRECT)(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEPAUSEVDIRECT)(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEQUEUEBUFFERSDIRECT)(ALCcontext *context, ALuint source, ALsizei nb, const ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERSDIRECT)(ALCcontext *context, ALuint source, ALsizei nb, ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGENBUFFERSDIRECT)(ALCcontext *context, ALsizei n, ALuint *buffers) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEBUFFERSDIRECT)(ALCcontext *context, ALsizei n, const ALuint *buffers) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISBUFFERDIRECT)(ALCcontext *context, ALuint buffer) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFERDATADIRECT)(ALCcontext *context, ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFERFDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFER3FDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFERFVDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFERIDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFER3IDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALBUFFERIVDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERFDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFER3FDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERFVDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERIDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFER3IDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERIVDIRECT)(ALCcontext *context, ALuint buffer, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+/* ALC_EXT_EFX */
+typedef void (AL_APIENTRY *LPALGENEFFECTSDIRECT)(ALCcontext *context, ALsizei n, ALuint *effects) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEEFFECTSDIRECT)(ALCcontext *context, ALsizei n, const ALuint *effects) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISEFFECTDIRECT)(ALCcontext *context, ALuint effect) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTIDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTIVDIRECT)(ALCcontext *context, ALuint effect, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTFDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTFVDIRECT)(ALCcontext *context, ALuint effect, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTIDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTIVDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTFDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTFVDIRECT)(ALCcontext *context, ALuint effect, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGENFILTERSDIRECT)(ALCcontext *context, ALsizei n, ALuint *filters) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEFILTERSDIRECT)(ALCcontext *context, ALsizei n, const ALuint *filters) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISFILTERDIRECT)(ALCcontext *context, ALuint filter) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERIDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERIVDIRECT)(ALCcontext *context, ALuint filter, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERFDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERFVDIRECT)(ALCcontext *context, ALuint filter, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERIDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERIVDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERFDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERFVDIRECT)(ALCcontext *context, ALuint filter, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTSDIRECT)(ALCcontext *context, ALsizei n, ALuint *effectslots) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTSDIRECT)(ALCcontext *context, ALsizei n, const ALuint *effectslots) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOTDIRECT)(ALCcontext *context, ALuint effectslot) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALint value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIVDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, const ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFVDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, const ALfloat *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALint *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIVDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALint *values) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat *value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFVDIRECT)(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat *values) AL_API_NOEXCEPT17;
+/* AL_EXT_BUFFER_DATA_STATIC */
+typedef void (AL_APIENTRY *LPALBUFFERDATASTATICDIRECT)(ALCcontext *context, ALuint buffer, ALenum format, ALvoid *data, ALsizei size, ALsizei freq) AL_API_NOEXCEPT17;
+/* AL_EXT_debug */
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGECALLBACKDIRECTEXT)(ALCcontext *context, ALDEBUGPROCEXT callback, void *userParam) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGEINSERTDIRECTEXT)(ALCcontext *context, ALenum source, ALenum type, ALuint id, ALenum severity, ALsizei length, const ALchar *message) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALDEBUGMESSAGECONTROLDIRECTEXT)(ALCcontext *context, ALenum source, ALenum type, ALenum severity, ALsizei count, const ALuint *ids, ALboolean enable) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALPUSHDEBUGGROUPDIRECTEXT)(ALCcontext *context, ALenum source, ALuint id, ALsizei length, const ALchar *message) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALPOPDEBUGGROUPDIRECTEXT)(ALCcontext *context) AL_API_NOEXCEPT17;
+typedef ALuint (AL_APIENTRY*LPALGETDEBUGMESSAGELOGDIRECTEXT)(ALCcontext *context, ALuint count, ALsizei logBufSize, ALenum *sources, ALenum *types, ALuint *ids, ALenum *severities, ALsizei *lengths, ALchar *logBuf) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALOBJECTLABELDIRECTEXT)(ALCcontext *context, ALenum identifier, ALuint name, ALsizei length, const ALchar *label) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETOBJECTLABELDIRECTEXT)(ALCcontext *context, ALenum identifier, ALuint name, ALsizei bufSize, ALsizei *length, ALchar *label) AL_API_NOEXCEPT17;
+typedef void* (AL_APIENTRY*LPALGETPOINTERDIRECTEXT)(ALCcontext *context, ALenum pname) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY*LPALGETPOINTERVDIRECTEXT)(ALCcontext *context, ALenum pname, void **values) AL_API_NOEXCEPT17;
+/* AL_EXT_FOLDBACK */
+typedef void (AL_APIENTRY *LPALREQUESTFOLDBACKSTARTDIRECT)(ALCcontext *context, ALenum mode, ALsizei count, ALsizei length, ALfloat *mem, LPALFOLDBACKCALLBACK callback) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALREQUESTFOLDBACKSTOPDIRECT)(ALCcontext *context) AL_API_NOEXCEPT17;
+/* AL_SOFT_buffer_sub_data */
+typedef void (AL_APIENTRY *LPALBUFFERSUBDATADIRECTSOFT)(ALCcontext *context, ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length) AL_API_NOEXCEPT17;
+/* AL_SOFT_source_latency */
+typedef void (AL_APIENTRY *LPALSOURCEDDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALdouble) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCE3DDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALdouble,ALdouble,ALdouble) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEDVDIRECTSOFT)(ALCcontext*,ALuint,ALenum,const ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEDDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCE3DDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEDVDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALdouble*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEI64DIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALint64SOFT) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCE3I64DIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEI64VDIRECTSOFT)(ALCcontext*,ALuint,ALenum,const ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEI64DIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCE3I64DIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETSOURCEI64VDIRECTSOFT)(ALCcontext*,ALuint,ALenum,ALint64SOFT*) AL_API_NOEXCEPT17;
+/* AL_SOFT_deferred_updates */
+typedef void (AL_APIENTRY *LPALDEFERUPDATESDIRECTSOFT)(ALCcontext *context) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALPROCESSUPDATESDIRECTSOFT)(ALCcontext *context) AL_API_NOEXCEPT17;
+/* AL_SOFT_source_resampler */
+typedef const ALchar* (AL_APIENTRY *LPALGETSTRINGIDIRECTSOFT)(ALCcontext *context, ALenum pname, ALsizei index) AL_API_NOEXCEPT17;
+/* AL_SOFT_events */
+typedef void (AL_APIENTRY *LPALEVENTCONTROLDIRECTSOFT)(ALCcontext *context, ALsizei count, const ALenum *types, ALboolean enable) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEVENTCALLBACKDIRECTSOFT)(ALCcontext *context, ALEVENTPROCSOFT callback, void *userParam) AL_API_NOEXCEPT17;
+typedef void* (AL_APIENTRY *LPALGETPOINTERDIRECTSOFT)(ALCcontext *context, ALenum pname) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETPOINTERVDIRECTSOFT)(ALCcontext *context, ALenum pname, void **values) AL_API_NOEXCEPT17;
+/* AL_SOFT_callback_buffer */
+typedef void (AL_APIENTRY *LPALBUFFERCALLBACKDIRECTSOFT)(ALCcontext *context, ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERPTRDIRECTSOFT)(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **value) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFER3PTRDIRECTSOFT)(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **value1, ALvoid **value2, ALvoid **value3) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETBUFFERPTRVDIRECTSOFT)(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **values) AL_API_NOEXCEPT17;
+/* AL_SOFT_source_start_delay */
+typedef void (AL_APIENTRY *LPALSOURCEPLAYATTIMEDIRECTSOFT)(ALCcontext *context, ALuint source, ALint64SOFT start_time) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALSOURCEPLAYATTIMEVDIRECTSOFT)(ALCcontext *context, ALsizei n, const ALuint *sources, ALint64SOFT start_time) AL_API_NOEXCEPT17;
+/* EAX */
+typedef ALenum (AL_APIENTRY *LPEAXSETDIRECT)(ALCcontext *context, const struct _GUID *property_set_id, ALuint property_id, ALuint source_id, ALvoid *value, ALuint value_size) AL_API_NOEXCEPT17;
+typedef ALenum (AL_APIENTRY *LPEAXGETDIRECT)(ALCcontext *context, const struct _GUID *property_set_id, ALuint property_id, ALuint source_id, ALvoid *value, ALuint value_size) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPEAXSETBUFFERMODEDIRECT)(ALCcontext *context, ALsizei n, const ALuint *buffers, ALint value) AL_API_NOEXCEPT17;
+typedef ALenum (AL_APIENTRY *LPEAXGETBUFFERMODEDIRECT)(ALCcontext *context, ALuint buffer, ALint *pReserved) AL_API_NOEXCEPT17;
+#ifdef AL_ALEXT_PROTOTYPES
+ALCvoid* ALC_APIENTRY alcGetProcAddress2(ALCdevice *device, const ALCchar *funcName) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alEnableDirect(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT;
+void AL_APIENTRY alDisableDirect(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsEnabledDirect(ALCcontext *context, ALenum capability) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alDopplerFactorDirect(ALCcontext *context, ALfloat value) AL_API_NOEXCEPT;
+void AL_APIENTRY alSpeedOfSoundDirect(ALCcontext *context, ALfloat value) AL_API_NOEXCEPT;
+void AL_APIENTRY alDistanceModelDirect(ALCcontext *context, ALenum distanceModel) AL_API_NOEXCEPT;
+
+const ALchar* AL_APIENTRY alGetStringDirect(ALCcontext *context, ALenum param) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBooleanvDirect(ALCcontext *context, ALenum param, ALboolean *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetIntegervDirect(ALCcontext *context, ALenum param, ALint *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetFloatvDirect(ALCcontext *context, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetDoublevDirect(ALCcontext *context, ALenum param, ALdouble *values) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alGetBooleanDirect(ALCcontext *context, ALenum param) AL_API_NOEXCEPT;
+ALint AL_APIENTRY alGetIntegerDirect(ALCcontext *context, ALenum param) AL_API_NOEXCEPT;
+ALfloat AL_APIENTRY alGetFloatDirect(ALCcontext *context, ALenum param) AL_API_NOEXCEPT;
+ALdouble AL_APIENTRY alGetDoubleDirect(ALCcontext *context, ALenum param) AL_API_NOEXCEPT;
+
+ALenum AL_APIENTRY alGetErrorDirect(ALCcontext *context) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsExtensionPresentDirect(ALCcontext *context, const ALchar *extname) AL_API_NOEXCEPT;
+void* AL_APIENTRY alGetProcAddressDirect(ALCcontext *context, const ALchar *fname) AL_API_NOEXCEPT;
+ALenum AL_APIENTRY alGetEnumValueDirect(ALCcontext *context, const ALchar *ename) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alListenerfDirect(ALCcontext *context, ALenum param, ALfloat value) AL_API_NOEXCEPT;
+void AL_APIENTRY alListener3fDirect(ALCcontext *context, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alListenerfvDirect(ALCcontext *context, ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alListeneriDirect(ALCcontext *context, ALenum param, ALint value) AL_API_NOEXCEPT;
+void AL_APIENTRY alListener3iDirect(ALCcontext *context, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alListenerivDirect(ALCcontext *context, ALenum param, const ALint *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListenerfDirect(ALCcontext *context, ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListener3fDirect(ALCcontext *context, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListenerfvDirect(ALCcontext *context, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListeneriDirect(ALCcontext *context, ALenum param, ALint *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListener3iDirect(ALCcontext *context, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetListenerivDirect(ALCcontext *context, ALenum param, ALint *values) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alGenSourcesDirect(ALCcontext *context, ALsizei n, ALuint *sources) AL_API_NOEXCEPT;
+void AL_APIENTRY alDeleteSourcesDirect(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsSourceDirect(ALCcontext *context, ALuint source) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcefDirect(ALCcontext *context, ALuint source, ALenum param, ALfloat value) AL_API_NOEXCEPT;
+void AL_APIENTRY alSource3fDirect(ALCcontext *context, ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcefvDirect(ALCcontext *context, ALuint source, ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceiDirect(ALCcontext *context, ALuint source, ALenum param, ALint value) AL_API_NOEXCEPT;
+void AL_APIENTRY alSource3iDirect(ALCcontext *context, ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceivDirect(ALCcontext *context, ALuint source, ALenum param, const ALint *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcefDirect(ALCcontext *context, ALuint source, ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSource3fDirect(ALCcontext *context, ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcefvDirect(ALCcontext *context, ALuint source, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourceiDirect(ALCcontext *context, ALuint source,  ALenum param, ALint *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSource3iDirect(ALCcontext *context, ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourceivDirect(ALCcontext *context, ALuint source,  ALenum param, ALint *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePlayDirect(ALCcontext *context, ALuint source) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceStopDirect(ALCcontext *context, ALuint source) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceRewindDirect(ALCcontext *context, ALuint source) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePauseDirect(ALCcontext *context, ALuint source) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePlayvDirect(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceStopvDirect(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceRewindvDirect(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePausevDirect(ALCcontext *context, ALsizei n, const ALuint *sources) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceQueueBuffersDirect(ALCcontext *context, ALuint source, ALsizei nb, const ALuint *buffers) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourceUnqueueBuffersDirect(ALCcontext *context, ALuint source, ALsizei nb, ALuint *buffers) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alGenBuffersDirect(ALCcontext *context, ALsizei n, ALuint *buffers) AL_API_NOEXCEPT;
+void AL_APIENTRY alDeleteBuffersDirect(ALCcontext *context, ALsizei n, const ALuint *buffers) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsBufferDirect(ALCcontext *context, ALuint buffer) AL_API_NOEXCEPT;
+void AL_APIENTRY alBufferDataDirect(ALCcontext *context, ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate) AL_API_NOEXCEPT;
+void AL_APIENTRY alBufferfDirect(ALCcontext *context, ALuint buffer, ALenum param, ALfloat value) AL_API_NOEXCEPT;
+void AL_APIENTRY alBuffer3fDirect(ALCcontext *context, ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alBufferfvDirect(ALCcontext *context, ALuint buffer, ALenum param, const ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alBufferiDirect(ALCcontext *context, ALuint buffer, ALenum param, ALint value) AL_API_NOEXCEPT;
+void AL_APIENTRY alBuffer3iDirect(ALCcontext *context, ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alBufferivDirect(ALCcontext *context, ALuint buffer, ALenum param, const ALint *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferfDirect(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBuffer3fDirect(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferfvDirect(ALCcontext *context, ALuint buffer, ALenum param, ALfloat *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferiDirect(ALCcontext *context, ALuint buffer, ALenum param, ALint *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBuffer3iDirect(ALCcontext *context, ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferivDirect(ALCcontext *context, ALuint buffer, ALenum param, ALint *values) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alGenEffectsDirect(ALCcontext *context, ALsizei n, ALuint *effects) AL_API_NOEXCEPT;
+void AL_APIENTRY alDeleteEffectsDirect(ALCcontext *context, ALsizei n, const ALuint *effects) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsEffectDirect(ALCcontext *context, ALuint effect) AL_API_NOEXCEPT;
+void AL_APIENTRY alEffectiDirect(ALCcontext *context, ALuint effect, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alEffectivDirect(ALCcontext *context, ALuint effect, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alEffectfDirect(ALCcontext *context, ALuint effect, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alEffectfvDirect(ALCcontext *context, ALuint effect, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetEffectiDirect(ALCcontext *context, ALuint effect, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetEffectivDirect(ALCcontext *context, ALuint effect, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetEffectfDirect(ALCcontext *context, ALuint effect, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetEffectfvDirect(ALCcontext *context, ALuint effect, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alGenFiltersDirect(ALCcontext *context, ALsizei n, ALuint *filters) AL_API_NOEXCEPT;
+void AL_APIENTRY alDeleteFiltersDirect(ALCcontext *context, ALsizei n, const ALuint *filters) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsFilterDirect(ALCcontext *context, ALuint filter) AL_API_NOEXCEPT;
+void AL_APIENTRY alFilteriDirect(ALCcontext *context, ALuint filter, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alFilterivDirect(ALCcontext *context, ALuint filter, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alFilterfDirect(ALCcontext *context, ALuint filter, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alFilterfvDirect(ALCcontext *context, ALuint filter, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetFilteriDirect(ALCcontext *context, ALuint filter, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetFilterivDirect(ALCcontext *context, ALuint filter, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetFilterfDirect(ALCcontext *context, ALuint filter, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetFilterfvDirect(ALCcontext *context, ALuint filter, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alGenAuxiliaryEffectSlotsDirect(ALCcontext *context, ALsizei n, ALuint *effectslots) AL_API_NOEXCEPT;
+void AL_APIENTRY alDeleteAuxiliaryEffectSlotsDirect(ALCcontext *context, ALsizei n, const ALuint *effectslots) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY alIsAuxiliaryEffectSlotDirect(ALCcontext *context, ALuint effectslot) AL_API_NOEXCEPT;
+void AL_APIENTRY alAuxiliaryEffectSlotiDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alAuxiliaryEffectSlotivDirect(ALCcontext *context, ALuint effectslot, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alAuxiliaryEffectSlotfDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alAuxiliaryEffectSlotfvDirect(ALCcontext *context, ALuint effectslot, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetAuxiliaryEffectSlotiDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetAuxiliaryEffectSlotivDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetAuxiliaryEffectSlotfDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetAuxiliaryEffectSlotfvDirect(ALCcontext *context, ALuint effectslot, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alBufferDataStaticDirect(ALCcontext *context, ALuint buffer, ALenum format, ALvoid *data, ALsizei size, ALsizei freq) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alDebugMessageCallbackDirectEXT(ALCcontext *context, ALDEBUGPROCEXT callback, void *userParam) AL_API_NOEXCEPT;
+void AL_APIENTRY alDebugMessageInsertDirectEXT(ALCcontext *context, ALenum source, ALenum type, ALuint id, ALenum severity, ALsizei length, const ALchar *message) AL_API_NOEXCEPT;
+void AL_APIENTRY alDebugMessageControlDirectEXT(ALCcontext *context, ALenum source, ALenum type, ALenum severity, ALsizei count, const ALuint *ids, ALboolean enable) AL_API_NOEXCEPT;
+void AL_APIENTRY alPushDebugGroupDirectEXT(ALCcontext *context, ALenum source, ALuint id, ALsizei length, const ALchar *message) AL_API_NOEXCEPT;
+void AL_APIENTRY alPopDebugGroupDirectEXT(ALCcontext *context) AL_API_NOEXCEPT;
+ALuint AL_APIENTRY alGetDebugMessageLogDirectEXT(ALCcontext *context, ALuint count, ALsizei logBufSize, ALenum *sources, ALenum *types, ALuint *ids, ALenum *severities, ALsizei *lengths, ALchar *logBuf) AL_API_NOEXCEPT;
+void AL_APIENTRY alObjectLabelDirectEXT(ALCcontext *context, ALenum identifier, ALuint name, ALsizei length, const ALchar *label) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetObjectLabelDirectEXT(ALCcontext *context, ALenum identifier, ALuint name, ALsizei bufSize, ALsizei *length, ALchar *label) AL_API_NOEXCEPT;
+void* AL_APIENTRY alGetPointerDirectEXT(ALCcontext *context, ALenum pname) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetPointervDirectEXT(ALCcontext *context, ALenum pname, void **values) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alRequestFoldbackStartDirect(ALCcontext *context, ALenum mode, ALsizei count, ALsizei length, ALfloat *mem, LPALFOLDBACKCALLBACK callback) AL_API_NOEXCEPT;
+void AL_APIENTRY alRequestFoldbackStopDirect(ALCcontext *context) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alBufferSubDataDirectSOFT(ALCcontext *context, ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alSourcedDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALdouble value) AL_API_NOEXCEPT;
+void AL_APIENTRY alSource3dDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcedvDirectSOFT(ALCcontext *context, ALuint source, ALenum param, const ALdouble *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcedDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALdouble *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSource3dDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcedvDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALdouble *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcei64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT value) AL_API_NOEXCEPT;
+void AL_APIENTRY alSource3i64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcei64vDirectSOFT(ALCcontext *context, ALuint source, ALenum param, const ALint64SOFT *values) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcei64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT *value) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSource3i64DirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetSourcei64vDirectSOFT(ALCcontext *context, ALuint source, ALenum param, ALint64SOFT *values) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alDeferUpdatesDirectSOFT(ALCcontext *context) AL_API_NOEXCEPT;
+void AL_APIENTRY alProcessUpdatesDirectSOFT(ALCcontext *context) AL_API_NOEXCEPT;
+
+const ALchar* AL_APIENTRY alGetStringiDirectSOFT(ALCcontext *context, ALenum pname, ALsizei index) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alEventControlDirectSOFT(ALCcontext *context, ALsizei count, const ALenum *types, ALboolean enable) AL_API_NOEXCEPT;
+void AL_APIENTRY alEventCallbackDirectSOFT(ALCcontext *context, ALEVENTPROCSOFT callback, void *userParam) AL_API_NOEXCEPT;
+void* AL_APIENTRY alGetPointerDirectSOFT(ALCcontext *context, ALenum pname) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetPointervDirectSOFT(ALCcontext *context, ALenum pname, void **values) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alBufferCallbackDirectSOFT(ALCcontext *context, ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferPtrDirectSOFT(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **ptr) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBuffer3PtrDirectSOFT(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **ptr0, ALvoid **ptr1, ALvoid **ptr2) AL_API_NOEXCEPT;
+void AL_APIENTRY alGetBufferPtrvDirectSOFT(ALCcontext *context, ALuint buffer, ALenum param, ALvoid **ptr) AL_API_NOEXCEPT;
+
+void AL_APIENTRY alSourcePlayAtTimeDirectSOFT(ALCcontext *context, ALuint source, ALint64SOFT start_time) AL_API_NOEXCEPT;
+void AL_APIENTRY alSourcePlayAtTimevDirectSOFT(ALCcontext *context, ALsizei n, const ALuint *sources, ALint64SOFT start_time) AL_API_NOEXCEPT;
+
+ALenum AL_APIENTRY EAXSetDirect(ALCcontext *context, const struct _GUID *property_set_id, ALuint property_id, ALuint source_id, ALvoid *value, ALuint value_size) AL_API_NOEXCEPT;
+ALenum AL_APIENTRY EAXGetDirect(ALCcontext *context, const struct _GUID *property_set_id, ALuint property_id, ALuint source_id, ALvoid *value, ALuint value_size) AL_API_NOEXCEPT;
+ALboolean AL_APIENTRY EAXSetBufferModeDirect(ALCcontext *context, ALsizei n, const ALuint *buffers, ALint value) AL_API_NOEXCEPT;
+ALenum AL_APIENTRY EAXGetBufferModeDirect(ALCcontext *context, ALuint buffer, ALint *pReserved) AL_API_NOEXCEPT;
+#endif
+#endif
+
+#ifndef AL_SOFT_bformat_hoa
+#define AL_SOFT_bformat_hoa
+#define AL_UNPACK_AMBISONIC_ORDER_SOFT           0x199D
+#endif
+
 #ifdef __cplusplus
 }
 #endif
+/* NOLINTEND */
 
 #endif

code/AL/efx-presets.h

@@ -2,6 +2,7 @@
 
 #ifndef EFX_PRESETS_H
 #define EFX_PRESETS_H
+/* NOLINTBEGIN */
 
 #ifndef EFXEAXREVERBPROPERTIES_DEFINED
 #define EFXEAXREVERBPROPERTIES_DEFINED
@@ -345,7 +346,7 @@ typedef struct {
 /* Driving Presets */
 
 #define EFX_REVERB_PRESET_DRIVING_COMMENTATOR \
-    { 1.0000f, 0.0000f, 3.1623f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+    { 1.0000f, 0.0000f, 0.3162f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
 
 #define EFX_REVERB_PRESET_DRIVING_PITGARAGE \
     { 0.4287f, 0.5900f, 0.3162f, 0.7079f, 0.5623f, 1.7200f, 0.9300f, 0.8700f, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
@@ -399,4 +400,5 @@ typedef struct {
 #define EFX_REVERB_PRESET_SMALLWATERROOM \
     { 1.0000f, 0.7000f, 0.3162f, 0.4477f, 1.0000f, 1.5100f, 1.2500f, 1.1400f, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
 
+/* NOLINTEND */
 #endif /* EFX_PRESETS_H */

code/AL/efx.h

@@ -1,6 +1,8 @@
 #ifndef AL_EFX_H
 #define AL_EFX_H
 
+/* NOLINTBEGIN */
+#include <float.h>
 
 #include "alc.h"
 #include "al.h"
@@ -203,80 +205,80 @@ extern "C" {
 
 
 /* Effect object function types. */
-typedef void (AL_APIENTRY *LPALGENEFFECTS)(ALsizei, ALuint*);
-typedef void (AL_APIENTRY *LPALDELETEEFFECTS)(ALsizei, const ALuint*);
-typedef ALboolean (AL_APIENTRY *LPALISEFFECT)(ALuint);
-typedef void (AL_APIENTRY *LPALEFFECTI)(ALuint, ALenum, ALint);
-typedef void (AL_APIENTRY *LPALEFFECTIV)(ALuint, ALenum, const ALint*);
-typedef void (AL_APIENTRY *LPALEFFECTF)(ALuint, ALenum, ALfloat);
-typedef void (AL_APIENTRY *LPALEFFECTFV)(ALuint, ALenum, const ALfloat*);
-typedef void (AL_APIENTRY *LPALGETEFFECTI)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETEFFECTIV)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*);
-typedef void (AL_APIENTRY *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGENEFFECTS)(ALsizei, ALuint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEEFFECTS)(ALsizei, const ALuint*) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISEFFECT)(ALuint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTI)(ALuint, ALenum, ALint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTIV)(ALuint, ALenum, const ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTF)(ALuint, ALenum, ALfloat) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALEFFECTFV)(ALuint, ALenum, const ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTI)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTIV)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
 
 /* Filter object function types. */
-typedef void (AL_APIENTRY *LPALGENFILTERS)(ALsizei, ALuint*);
-typedef void (AL_APIENTRY *LPALDELETEFILTERS)(ALsizei, const ALuint*);
-typedef ALboolean (AL_APIENTRY *LPALISFILTER)(ALuint);
-typedef void (AL_APIENTRY *LPALFILTERI)(ALuint, ALenum, ALint);
-typedef void (AL_APIENTRY *LPALFILTERIV)(ALuint, ALenum, const ALint*);
-typedef void (AL_APIENTRY *LPALFILTERF)(ALuint, ALenum, ALfloat);
-typedef void (AL_APIENTRY *LPALFILTERFV)(ALuint, ALenum, const ALfloat*);
-typedef void (AL_APIENTRY *LPALGETFILTERI)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETFILTERIV)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETFILTERF)(ALuint, ALenum, ALfloat*);
-typedef void (AL_APIENTRY *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGENFILTERS)(ALsizei, ALuint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEFILTERS)(ALsizei, const ALuint*) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISFILTER)(ALuint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERI)(ALuint, ALenum, ALint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERIV)(ALuint, ALenum, const ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERF)(ALuint, ALenum, ALfloat) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALFILTERFV)(ALuint, ALenum, const ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERI)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERIV)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERF)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
 
 /* Auxiliary Effect Slot object function types. */
-typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*);
-typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const ALuint*);
-typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint);
-typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint);
-typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const ALint*);
-typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat);
-typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const ALfloat*);
-typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*);
-typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*);
-typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const ALuint*) AL_API_NOEXCEPT17;
+typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*) AL_API_NOEXCEPT17;
 
 #ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
-AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects);
-AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect);
-AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
+AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
 
-AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
-AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters);
-AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter);
-AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
+AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
 
-AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
-AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots);
-AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
+AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots) AL_API_NOEXCEPT;
+AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue) AL_API_NOEXCEPT;
+AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues) AL_API_NOEXCEPT;
 #endif
 
 /* Filter ranges and defaults. */
@@ -757,5 +759,6 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum p
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif
+/* NOLINTEND */
 
 #endif /* AL_EFX_H */

code/Launcher/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.12)
+
+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}")
+        set_target_properties(openmohaa_launcher_${name} PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
+
+        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}")
+    #set_target_properties(omohaaded_launcher_${name} PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
+    #
+    #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

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2025 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -20,19 +20,13 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
-#include "../tr_local.h"
+// launch.h: Base interface for starting programs
 
-static backEndCounters_t pc_save;
+#include "q_platform.h"
 
-/*
-=====================
-R_PerformanceCounters
-=====================
-*/
-void R_SavePerformanceCounters(void) {
-    memcpy(&pc_save, &backEnd.pc, sizeof(pc_save));
-}
+#include <filesystem>
+#include <string>
+#include <vector>
 
-void R_SyncRenderThread() {
-    R_IssuePendingRenderCommands();
-}
+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) 2025 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,63 @@
+/*
+===========================================================================
+Copyright (C) 2025 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" DLL_SUFFIX EXE_EXT;
+#else
+    const char *programName = "omohaaded" 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) 2025 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 = L"\"" + path.wstring() + L"\"";
+    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/cgame/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.12)
 project(cgame)
 
 # Shared source files for modules
@@ -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_commands.cpp

@@ -564,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
 (
@@ -985,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
@@ -1085,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",
@@ -1122,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
 (
@@ -1195,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;
 
@@ -1261,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                 },
@@ -1323,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                  },
@@ -1394,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;
@@ -1413,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;
     }
 
@@ -1449,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;
         }
     }
 }
@@ -1473,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")) {
@@ -1552,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 {
@@ -1562,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)
@@ -2599,7 +2645,9 @@ void ClientGameCommandManager::SetColorRange(Event *ev)
         return;
     }
 
-    // FIXME: unused stub??
+    //
+    // Unused
+    //
 }
 
 //=============
@@ -2825,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)
@@ -3054,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;
@@ -3816,7 +3866,7 @@ void ClientGameCommandManager::PlaySound(
     }
 
     if (!name || !soundAlias) {
-        Com_Printf(
+        cgi.DPrintf(
             "\nERROR PlaySound: %s needs an alias in ubersound.scr or uberdialog.scr - Please fix.\n",
             sound_name.c_str()
         );
@@ -3873,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()
                 );
             }
@@ -3987,6 +4037,9 @@ void ClientGameCommandManager::StopSound(Event *ev)
     cgi.S_StopSound(current_entity_number, channel);
 }
 
+//===============
+// StopAliasChannel
+//===============
 void ClientGameCommandManager::StopAliasChannel(Event *ev)
 {
     str              sound_name;
@@ -4013,7 +4066,7 @@ void ClientGameCommandManager::StopAliasChannel(Event *ev)
     }
 
     if (!name || !soundAlias) {
-        Com_Printf("\nERROR stopaliaschannel: couldn't find alias %s\n", sound_name.c_str());
+        cgi.DPrintf("\nERROR stopaliaschannel: couldn't find alias %s\n", sound_name.c_str());
         return;
     }
 
@@ -4082,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;
+    }
+
+    cgi.DPrintf("\n\nClientGameCommandManager::StopLoopSound\n\n");
+    current_centity->tikiLoopSound = (sfxHandle_t)0;
+}
+
+//===============
+// 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
 //===============
@@ -4121,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());
 }
 
 //===============
@@ -4134,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)
@@ -4163,7 +4265,7 @@ qboolean bLoadForMap(const char *psMapsBuffer, const char *name)
     }
 
     if (!token || !token[0]) {
-        Com_Printf("ERROR bLoadForMap: %s alias with empty maps specification.\n", name);
+        cgi.DPrintf("ERROR bLoadForMap: %s alias with empty maps specification.\n", name);
         return false;
     }
 
@@ -4203,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));
     }
 }
@@ -4245,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))) {
@@ -4952,6 +5072,10 @@ void ClientGameCommandManager::RemoveClientEntity(int number, dtiki_t *tiki, cen
     if (p && p->cgd.flags & T_ASSIGNED_NUMBER) {
         m_command_time_manager.RemoveEntity(number);
     }
+
+    // Fixed in OPM
+    //  Also make sure to remove all pending events for that entity
+    RemovePendingEventsForEntity(number);
 }
 
 bool ClientGameCommandManager::GetTagPositionAndOrientation(int tagnum, orientation_t *new_or)
@@ -4998,7 +5122,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;
+    }
 }
 
 //===============
@@ -5007,6 +5139,10 @@ void ClientGameCommandManager::RestartAllEmitters(void)
 void CG_RestartCommandManager()
 {
     commandManager.FreeAllTempModels();
+
+    // Added in OPM
+    //  Clean up all effect events when the server restarts
+    commandManager.ResetPendingEvents();
 }
 
 //=================
@@ -5051,7 +5187,7 @@ void CG_ProcessInitCommands(dtiki_t *tiki, refEntity_t *ent)
         }
 
         if (!commandManager.SelectProcessEvent(ev)) {
-            Com_Printf(
+            cgi.DPrintf(
                 "^~^~^ CG_ProcessInitCommands: Bad init client command '%s' in '%s'\n", pcmd->args[0], tiki->name
             );
         }
@@ -5097,7 +5233,7 @@ void CG_ProcessCacheInitCommands(dtiki_t *tiki)
             }
 
             if (!commandManager.SelectProcessEvent(ev)) {
-                Com_Printf(
+                cgi.DPrintf(
                     "^~^~^ CG_ProcessInitCommands: Bad init client command '%s' in '%s'\n", pcmd->args[0], tiki->name
                 );
             }
@@ -5170,7 +5306,7 @@ qboolean CG_ProcessEntityCommands(int frame, int anim, int entnum, refEntity_t *
         current_centity       = cent;
         current_entity_number = entnum;
         current_tiki          = ent->tiki;
-        CG_AnimationDebugMessage(entnum, "Processing Ent Commands: Entity: %3d Anim:#(%i) Frame:#(%i)\n", anim, frame);
+        CG_AnimationDebugMessage(entnum, "Processing Ent Commands: Entity: %3d Anim:#(%i) Frame:#(%i)\n", entnum, anim, frame);
 
         for (i = 0; i < tikicmds.num_cmds; i++) {
             Event *ev;
@@ -5209,7 +5345,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)) {
@@ -5364,7 +5500,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;
@@ -5373,7 +5509,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;
         }
@@ -5381,7 +5517,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;
                 }
@@ -5394,7 +5530,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;
             }
@@ -5406,7 +5542,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;
@@ -5712,7 +5848,7 @@ void ClientGameCommandManager::SetCurrentTiki(Event *ev)
     str tikiName;
 
     if (ev->NumArgs() != 1) {
-        Com_Printf("ERROR: settiki command takes 1 parameter.\n");
+        cgi.DPrintf("ERROR: settiki command takes 1 parameter.\n");
         return;
     }
 
@@ -6258,3 +6394,41 @@ void commandtime_t::ArchiveToMemory(MemArchiver& archiver)
     archiver.ArchiveInteger(&command_number);
     archiver.ArchiveTime(&last_command_time);
 }
+
+void ClientGameCommandManager::ResetPendingEvents()
+{
+    EffectsEventQueueNode *event, *tmp;
+
+    event = EffectsEventQueue.next;
+    while (event != &EffectsEventQueue) {
+        tmp = event->next;
+
+        delete event->event;
+        delete event;
+
+        event = tmp;
+    }
+
+    LL_Reset(&EffectsEventQueue, next, prev);
+}
+
+void ClientGameCommandManager::RemovePendingEventsForEntity(int number)
+{
+    EffectsEventQueueNode *event, *tmp;
+
+    event = EffectsEventQueue.next;
+    while (event != &EffectsEventQueue) {
+        if (event->entity_num != number) {
+            event = event->next;
+            continue;
+        }
+
+        tmp = event->next;
+        LL_Remove(event, next, prev);
+
+        delete event->event;
+        delete event;
+
+        event = tmp;
+    }
+}

code/cgame/cg_commands.h

@@ -764,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);
@@ -851,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);
@@ -893,8 +895,8 @@ private:
     void          FreeTempModel(ctempmodel_t *le);
     void          AnimateTempModel(ctempmodel_t *ent, Vector origin, refEntity_t *newEnt);
     void          OtherTempModelEffects(ctempmodel_t *p, Vector origin, refEntity_t *newEnt);
-    qboolean      IsBlockCommand(const str     &name);
-    void          SetBaseAndAmplitude(Event *ev, Vector         &base, Vector         &amplitude);
+    qboolean      IsBlockCommand(const str& name);
+    void          SetBaseAndAmplitude(Event *ev, Vector& base, Vector& amplitude);
 
     // Beam stuff
     void SetSubdivisions(Event *ev);
@@ -967,6 +969,9 @@ public:
     void     ProcessPendingEventsForEntity();
     qboolean PostEventForEntity(Event *ev, float fWait);
     qboolean SelectProcessEvent(Event *ev);
+    // Added in OPM
+    void ResetPendingEvents();
+    void RemovePendingEventsForEntity(int number);
 
     void TestEffectEndFunc();
     void AddVSSSources();

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.
 
@@ -160,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)
@@ -216,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");
@@ -340,65 +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          },
+    {"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         },
 };
 
 /*
@@ -565,5 +705,5 @@ int CG_WeaponCommandButtonBits(void)
         cg.iWeaponCommand = 0;
     }
 
-    return iShiftedWeaponCommand & WEAPON_COMMAND_MASK;
+    return iShiftedWeaponCommand & GetWeaponCommandMask(cg_protocol >= PROTOCOL_MOHTA_MIN ? WEAPON_COMMAND_MAX_VER17 : WEAPON_COMMAND_MAX_VER6);
 }

code/cgame/cg_drawtools.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2025 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -191,8 +191,8 @@ void CG_DrawDisconnect(void)
     }
 
     handle = cgi.R_RegisterShader("gfx/2d/net.tga");
-    w      = cgi.R_GetShaderWidth(handle);
-    h      = cgi.R_GetShaderHeight(handle);
+    w      = cgi.R_GetShaderWidth(handle) * cgs.uiHiResScale[0];
+    h      = cgi.R_GetShaderHeight(handle) * cgs.uiHiResScale[1];
     x      = ((float)cgs.glconfig.vidWidth - w) * 0.5;
     y      = (float)cgs.glconfig.vidHeight - h;
 
@@ -331,7 +331,7 @@ static void CG_DrawPauseIcon()
     x = (cgs.glconfig.vidWidth - w) / 2.f;
 
     cgi.R_SetColor(colorWhite);
-    cgi.R_DrawStretchPic(x, y, w, h, 0, 0, 1, 1, handle);
+    cgi.R_DrawStretchPic(x, y, w * cgs.uiHiResScale[0], h * cgs.uiHiResScale[1], 0, 0, 1, 1, handle);
 }
 
 static void CG_DrawServerLag()
@@ -362,8 +362,8 @@ static void CG_DrawServerLag()
     }
 
     handle = cgi.R_RegisterShader("gfx/2d/slowserver");
-    w      = (float)cgi.R_GetShaderWidth(handle) / 4;
-    h      = (float)cgi.R_GetShaderHeight(handle) / 4;
+    w      = (float)cgi.R_GetShaderWidth(handle) * cgs.uiHiResScale[0] / 4;
+    h      = (float)cgi.R_GetShaderHeight(handle) * cgs.uiHiResScale[1] / 4;
     x      = ((float)cgs.glconfig.vidWidth - w) / 2;
     y      = (float)cgs.glconfig.vidHeight - h;
     cgi.R_DrawStretchPic(x, y, w, h, 0.0, 0.0, 1.0, 1.0, handle);
@@ -577,14 +577,18 @@ void CG_RefreshHudDrawElements()
 
 void CG_HudDrawElements()
 {
-    int   i;
-    float fX, fY;
-    float fWidth, fHeight;
+    int    i;
+    float  fX, fY;
+    float  fWidth, fHeight;
+    vec2_t virtualScale;
 
     if (!cg_huddraw_force->integer && !cg_hud->integer) {
         return;
     }
 
+    virtualScale[0] = cgs.glconfig.vidWidth / 640.0;
+    virtualScale[1] = cgs.glconfig.vidHeight / 480.0;
+
     for (i = 0; i < MAX_HUDDRAW_ELEMENTS; i++) {
         if ((!cgi.HudDrawElements[i].hShader && !cgi.HudDrawElements[i].string[0])
             || !cgi.HudDrawElements[i].vColor[3]) {
@@ -597,6 +601,13 @@ void CG_HudDrawElements()
         fWidth  = cgi.HudDrawElements[i].iWidth;
         fHeight = cgi.HudDrawElements[i].iHeight;
 
+        if (!cgi.HudDrawElements[i].bVirtualScreen) {
+            fWidth *= cgs.uiHiResScale[0];
+            fHeight *= cgs.uiHiResScale[1];
+            fX *= cgs.uiHiResScale[0];
+            fY *= cgs.uiHiResScale[1];
+        }
+
         if (cgi.HudDrawElements[i].iHorizontalAlign == HUD_ALIGN_X_CENTER) {
             if (cgi.HudDrawElements[i].bVirtualScreen) {
                 fX += 320.0 - fWidth * 0.5;
@@ -627,23 +638,21 @@ void CG_HudDrawElements()
 
         cgi.R_SetColor(cgi.HudDrawElements[i].vColor);
         if (cgi.HudDrawElements[i].string[0]) {
-            if (cgi.HudDrawElements[i].pFont) {
-                cgi.R_DrawString(
-                    cgi.HudDrawElements[i].pFont,
-                    cgi.LV_ConvertString(cgi.HudDrawElements[i].string),
-                    fX,
-                    fY,
-                    -1,
-                    cgi.HudDrawElements[i].bVirtualScreen
-                );
+            fontheader_t *pFont = cgi.HudDrawElements[i].pFont;
+            if (!pFont) {
+                pFont = cgs.media.hudDrawFont;
+            }
+
+            if (cgi.HudDrawElements[i].bVirtualScreen) {
+                cgi.R_DrawString(pFont, cgi.LV_ConvertString(cgi.HudDrawElements[i].string), fX, fY, -1, virtualScale);
             } else {
                 cgi.R_DrawString(
-                    cgs.media.hudDrawFont,
+                    pFont,
                     cgi.LV_ConvertString(cgi.HudDrawElements[i].string),
-                    fX,
-                    fY,
+                    fX / cgs.uiHiResScale[0],
+                    fY / cgs.uiHiResScale[1],
                     -1,
-                    cgi.HudDrawElements[i].bVirtualScreen
+                    cgs.uiHiResScale
                 );
             }
         } else {
@@ -675,14 +684,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,50 +714,78 @@ 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;
     vColor[3] = cg.ObjectivesCurrentAlpha * 0.75;
     cgi.R_SetColor(vColor);
-    cgi.R_DrawStretchPic(fX, fY, 450.0, fWidth, 0.0, 0.0, 1.0, 1.0, cgs.media.objectivesBackShader);
+    cgi.R_DrawStretchPic(
+        fX,
+        fY,
+        450.0 * cgs.uiHiResScale[0],
+        fWidth * cgs.uiHiResScale[1],
+        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;
     vColor[3] = cg.ObjectivesCurrentAlpha;
     cgi.R_SetColor(vColor);
-    cgi.R_DrawString(cgs.media.objectiveFont, cgi.LV_ConvertString("Mission Objectives:"), fX, fY, -1, 0);
+    cgi.R_DrawString(
+        cgs.media.objectiveFont,
+        cgi.LV_ConvertString("Mission Objectives:"),
+        fX,
+        fY / cgs.uiHiResScale[1],
+        -1,
+        cgs.uiHiResScale
+    );
     fY = fY + 5.0;
 
-    cgi.R_DrawString(cgs.media.objectiveFont, "_______________________________________________________", fX, fY, -1, 0);
-    fHeight = 155.0;
+    cgi.R_DrawString(
+        cgs.media.objectiveFont,
+        "_______________________________________________________",
+        fX,
+        fY / cgs.uiHiResScale[1],
+        -1,
+        cgs.uiHiResScale
+    );
+    fHeight = fObjectivesTop + 35 * cgs.uiHiResScale[1];
 
     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;
         }
 
@@ -778,7 +818,14 @@ void CG_DrawObjectives()
         cgi.R_SetColor(vColor);
         fX = 55.0;
         fY = fHeight;
-        cgi.R_DrawString(cgs.media.objectiveFont, cgi.LV_ConvertString(cg.Objectives[i].text), 55.0, fHeight, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.objectiveFont,
+            cgi.LV_ConvertString(cg.Objectives[i].text),
+            55.0,
+            fY / cgs.uiHiResScale[1],
+            -1,
+            cgs.uiHiResScale
+        );
 
         fX        = 30.0;
         fY        = fHeight;
@@ -787,9 +834,19 @@ void CG_DrawObjectives()
         vColor[2] = 1.0;
         vColor[3] = cg.ObjectivesCurrentAlpha;
         cgi.R_SetColor(vColor);
-        cgi.R_DrawStretchPic(fX, fY, 16.0, 16.0, 0.0, 0.0, 1.0, 1.0, hBoxShader);
+        cgi.R_DrawStretchPic(
+            fX * cgs.uiHiResScale[0],
+            fY,
+            16.0 * cgs.uiHiResScale[0],
+            16.0 * cgs.uiHiResScale[1],
+            0.0,
+            0.0,
+            1.0,
+            1.0,
+            hBoxShader
+        );
 
-        fHeight += 25 * iNumLines[i];
+        fHeight += iNumLines[i] * 12 + 25 * cgs.uiHiResScale[1];
     }
 }
 
@@ -813,7 +870,17 @@ void CG_DrawPlayerTeam()
 
     if (handle) {
         cgi.R_SetColor(NULL);
-        cgi.R_DrawStretchPic(96.0, cgs.glconfig.vidHeight - 46, 24.0, 24.0, 0.0, 0.0, 1.0, 1.0, handle);
+        cgi.R_DrawStretchPic(
+            96.0 * cgs.uiHiResScale[0],
+            cgs.glconfig.vidHeight - 46 * cgs.uiHiResScale[1],
+            24.0 * cgs.uiHiResScale[0],
+            24.0 * cgs.uiHiResScale[1],
+            0.0,
+            0.0,
+            1.0,
+            1.0,
+            handle
+        );
     }
 }
 
@@ -855,13 +922,28 @@ void CG_DrawPlayerEntInfo()
 
     if (handle) {
         cgi.R_SetColor(0);
-        cgi.R_DrawStretchPic(56.0, fY, 16.0, 16.0, 0.0, 0.0, 1.0, 1.0, handle);
-        fX = 56.0 + 24.0;
+        cgi.R_DrawStretchPic(
+            fX, fY, 16.0 * cgs.uiHiResScale[0], 16.0 * cgs.uiHiResScale[1], 0.0, 0.0, 1.0, 1.0, handle
+        );
     }
 
     cgi.R_SetColor(color);
-    cgi.R_DrawString(cgs.media.hudDrawFont, (char *)pszName, fX, fY, -1, 0);
-    cgi.R_DrawString(cgs.media.hudDrawFont, va("%i", cg.snap->ps.stats[STAT_INFOCLIENT_HEALTH]), fX, fY + 20.0, -1, 0);
+    cgi.R_DrawString(
+        cgs.media.hudDrawFont,
+        (char *)pszName,
+        fX / cgs.uiHiResScale[0] + 24.0,
+        fY / cgs.uiHiResScale[1],
+        -1,
+        cgs.uiHiResScale
+    );
+    cgi.R_DrawString(
+        cgs.media.hudDrawFont,
+        va("%i", cg.snap->ps.stats[STAT_INFOCLIENT_HEALTH]),
+        fX / cgs.uiHiResScale[0] + 24.0,
+        fY / cgs.uiHiResScale[1] + 20.0,
+        -1,
+        cgs.uiHiResScale
+    );
 }
 
 void CG_UpdateAttackerDisplay()
@@ -900,7 +982,17 @@ void CG_UpdateAttackerDisplay()
 
         if (handle) {
             cgi.R_SetColor(0);
-            cgi.R_DrawStretchPic(56.0, fY, 24.0, 24.0, 0.0, 0.0, 1.0, 1.0, handle);
+            cgi.R_DrawStretchPic(
+                56.0 * cgs.uiHiResScale[0],
+                fY,
+                24.0 * cgs.uiHiResScale[0],
+                24.0 * cgs.uiHiResScale[1],
+                0.0,
+                0.0,
+                1.0,
+                1.0,
+                handle
+            );
         }
 
         if ((cg.snap->ps.stats[STAT_TEAM] == TEAM_ALLIES || cg.snap->ps.stats[STAT_TEAM] == TEAM_AXIS)
@@ -914,7 +1006,7 @@ void CG_UpdateAttackerDisplay()
             color[2] = 0.5;
         }
 
-        fX = 56.0 + 32.0;
+        fX = 56.0;
     } else {
         color[0] = 1.0;
         color[1] = 0.5;
@@ -922,11 +1014,15 @@ void CG_UpdateAttackerDisplay()
     }
 
     cgi.R_SetColor(color);
-    cgi.R_DrawString(cgs.media.attackerFont, pszName, fX, fY, -1, 0);
+    cgi.R_DrawString(
+        cgs.media.attackerFont, pszName, fX / cgs.uiHiResScale[0] + 32.0, fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+    );
 }
 
 void CG_UpdateCountdown()
 {
+    const char *message = "";
+
     if (!cg.snap) {
         return;
     }
@@ -937,16 +1033,25 @@ 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 +1059,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()
@@ -1009,7 +1131,9 @@ void CG_DrawInstantMessageMenu()
     x = 8.0;
     y = ((float)cgs.glconfig.vidHeight - h) * 0.5;
     cgi.R_SetColor(0);
-    cgi.R_DrawStretchPic(x, y, w, h, 0.0, 0.0, 1.0, 1.0, handle);
+    cgi.R_DrawStretchPic(
+        x * cgs.uiHiResScale[0], y, w * cgs.uiHiResScale[0], h * cgs.uiHiResScale[1], 0.0, 0.0, 1.0, 1.0, handle
+    );
 }
 
 void CG_DrawSpectatorView_ver_15()
@@ -1032,10 +1156,14 @@ void CG_DrawSpectatorView_ver_15()
     if (!bOnTeam) {
         cgi.Key_GetKeysForCommand("+attackprimary", &iKey1, &iKey2);
         pszString = cgi.LV_ConvertString(va("Press Fire(%s) to join the battle!", cgi.Key_KeynumToBindString(iKey1)));
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-        fY = cgs.glconfig.vidHeight - 64.0;
+        fX        = (float)(cgs.glconfig.vidWidth
+                     - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = cgs.glconfig.vidHeight - 64.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(NULL);
-        cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, qfalse);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
     }
 
     if (cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW) {
@@ -1048,10 +1176,14 @@ void CG_DrawSpectatorView_ver_15()
                cgi.Key_KeynumToBindString(iKey1b))
         );
 
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-        fY = (float)cgs.glconfig.vidHeight - 40.0;
+        fX = (float)(cgs.glconfig.vidWidth
+                     - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = (float)cgs.glconfig.vidHeight - 40.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(0);
-        cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
     }
 
     if (!bOnTeam && (cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)) {
@@ -1059,10 +1191,14 @@ void CG_DrawSpectatorView_ver_15()
         pszString =
             cgi.LV_ConvertString(va("Press Use(%s) to enter free spectate mode.", cgi.Key_KeynumToBindString(iKey1)));
 
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-        fY = (float)cgs.glconfig.vidHeight - 24.0;
+        fX = (float)(cgs.glconfig.vidWidth
+                     - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = (float)cgs.glconfig.vidHeight - 24.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(0);
-        cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
     }
 
     if (!(cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)) {
@@ -1072,20 +1208,27 @@ void CG_DrawSpectatorView_ver_15()
             va("Press Use(%s) to enter player following spectate mode.", cgi.Key_KeynumToBindString(iKey1))
         );
 
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-        fY = (float)cgs.glconfig.vidHeight - 24.0;
+        fX = (float)(cgs.glconfig.vidWidth
+                     - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = (float)cgs.glconfig.vidHeight - 24.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(0);
-        cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
     }
 
-    if ((cg.predicted_player_state.pm_flags & 0x80) != 0 && cg.snap && cg.snap->ps.stats[STAT_INFOCLIENT] != -1) {
+    if ((cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW) != 0 && cg.snap
+        && cg.snap->ps.stats[STAT_INFOCLIENT] != -1) {
         int       iClientNum;
         qhandle_t hShader;
         vec4_t    color;
         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;
@@ -1093,10 +1236,14 @@ void CG_DrawSpectatorView_ver_15()
         color[2] = 0.5;
         color[3] = 1.0;
 
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) - 16) * 0.5;
-        fY = (float)cgs.glconfig.vidHeight - 80.0;
+        fX = (float)(cgs.glconfig.vidWidth
+                     - (cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) - 16) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = (float)cgs.glconfig.vidHeight - 80.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(color);
-        cgi.R_DrawString(cgs.media.attackerFont, buf, fX, fY, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, buf, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
 
         if (cg.clientinfo[iClientNum].team == TEAM_ALLIES) {
             hShader = cgi.R_RegisterShader("textures/hud/allies");
@@ -1105,9 +1252,18 @@ void CG_DrawSpectatorView_ver_15()
         }
 
         if (hShader) {
-            fX -= 20.0;
             cgi.R_SetColor(NULL);
-            cgi.R_DrawStretchPic(fX, fY, 16.0, 16.0, 0.0, 0.0, 1.0, 1.0, hShader);
+            cgi.R_DrawStretchPic(
+                fX - 20.0 * cgs.uiHiResScale[0],
+                fY,
+                16.0 * cgs.uiHiResScale[0],
+                16.0 * cgs.uiHiResScale[1],
+                0.0,
+                0.0,
+                1.0,
+                1.0,
+                hShader
+            );
         }
     }
 }
@@ -1139,10 +1295,14 @@ void CG_DrawSpectatorView_ver_6()
         pszString = cgi.LV_ConvertString(va("Press Use(%s) to follow a player.", cgi.Key_KeynumToBindString(iKey1)));
     }
 
-    fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-    fY = (float)cgs.glconfig.vidHeight - 40.0;
+    fX = (float)(cgs.glconfig.vidWidth
+                 - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+       * 0.5;
+    fY = (float)cgs.glconfig.vidHeight - 40.0 * cgs.uiHiResScale[1];
     cgi.R_SetColor(0);
-    cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+    cgi.R_DrawString(
+        cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+    );
 
     if (!bOnTeam && (cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)) {
         cgi.Key_GetKeysForCommand("+moveup", &iKey1, &iKey2);
@@ -1153,10 +1313,14 @@ void CG_DrawSpectatorView_ver_6()
                cgi.Key_KeynumToBindString(iKey1b))
         );
 
-        fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
-        fY = (float)cgs.glconfig.vidHeight - 24.0;
+        fX = (float)(cgs.glconfig.vidWidth
+                     - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) * cgs.uiHiResScale[0])
+           * 0.5;
+        fY = (float)cgs.glconfig.vidHeight - 24.0 * cgs.uiHiResScale[1];
         cgi.R_SetColor(0);
-        cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, pszString, fX / cgs.uiHiResScale[0], fY / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
     }
 }
 
@@ -1190,7 +1354,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;
     }
 
@@ -1199,6 +1363,9 @@ void CG_DrawCrosshair()
         return;
     }
 
+    // Fixed in OPM: R_RegisterShaderNoMip
+    //  Use R_RegisterShaderNoMip, as it's UI stuff
+
     if (cgs.gametype != GT_FFA) {
         AngleVectorsLeft(cg.refdefViewAngles, forward, NULL, NULL);
 
@@ -1226,23 +1393,23 @@ void CG_DrawCrosshair()
                 || ((myFlags & EF_AXIS) && (friendEnt->currentState.eFlags & EF_AXIS))) {
                 // friend
                 if (cg.snap->ps.stats[STAT_CROSSHAIR]) {
-                    shader = cgi.R_RegisterShader(cg_crosshair_friend->string);
+                    shader = cgi.R_RegisterShaderNoMip(cg_crosshair_friend->string);
                 }
             } else {
                 // enemy
                 if (cg.snap->ps.stats[STAT_CROSSHAIR]) {
-                    shader = cgi.R_RegisterShader(cg_crosshair->string);
+                    shader = cgi.R_RegisterShaderNoMip(cg_crosshair->string);
                 }
             }
         } else {
             if (cg.snap->ps.stats[STAT_CROSSHAIR]) {
-                shader = cgi.R_RegisterShader(cg_crosshair->string);
+                shader = cgi.R_RegisterShaderNoMip(cg_crosshair->string);
             }
         }
     } else {
         // FFA
         if (cg.snap->ps.stats[STAT_CROSSHAIR]) {
-            shader = cgi.R_RegisterShader(cg_crosshair->string);
+            shader = cgi.R_RegisterShaderNoMip(cg_crosshair->string);
         }
     }
 
@@ -1253,7 +1420,7 @@ void CG_DrawCrosshair()
         y      = (cgs.glconfig.vidHeight - height) * 0.5f;
 
         cgi.R_SetColor(NULL);
-        cgi.R_DrawStretchPic(x, y, width, height, 0, 0, 1, 1, shader);
+        cgi.R_DrawStretchPic(x, y, width * cgs.uiHiResScale[0], height * cgs.uiHiResScale[1], 0, 0, 1, 1, shader);
     }
 }
 
@@ -1284,15 +1451,17 @@ void CG_DrawVote()
     percentNo        = cgs.numVotesNo * 100 / (cgs.numUndecidedVotes + cgs.numVotesNo + cgs.numVotesYes);
     percentUndecided = cgs.numUndecidedVotes * 100 / (cgs.numUndecidedVotes + cgs.numVotesNo + cgs.numVotesYes);
 
-    x = 8;
-    y = (cgs.glconfig.vidHeight > 480) ? (cgs.glconfig.vidHeight * 0.725f) : (cgs.glconfig.vidHeight * 0.75f);
+    x = 8 * cgs.uiHiResScale[0];
+    y = ((cgs.glconfig.vidHeight > 480) ? (cgs.glconfig.vidHeight * 0.725f) : (cgs.glconfig.vidHeight * 0.75f));
 
     cgi.R_SetColor(NULL);
 
     text = va("%s: %s", cgi.LV_ConvertString("Vote Running"), cgs.voteString);
-    cgi.R_DrawString(cgs.media.attackerFont, text, x, y, -1, qfalse);
+    cgi.R_DrawString(
+        cgs.media.attackerFont, text, x / cgs.uiHiResScale[0], y / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+    );
 
-    y += 12;
+    y += 12 * cgs.uiHiResScale[1];
 
     text =
         va("%s: %isec  %s: %i%%  %s: %i%%  %s: %i%%",
@@ -1304,7 +1473,9 @@ void CG_DrawVote()
            percentNo,
            cgi.LV_ConvertString("Undecided"),
            percentUndecided);
-    cgi.R_DrawString(cgs.media.attackerFont, text, x, y, -1, qfalse);
+    cgi.R_DrawString(
+        cgs.media.attackerFont, text, x / cgs.uiHiResScale[0], y / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+    );
 
     if (cg.snap && !cg.snap->ps.voted) {
         col[0] = 0.5;
@@ -1313,15 +1484,19 @@ void CG_DrawVote()
         col[3] = 1.0;
         cgi.R_SetColor(col);
 
-        y += 12;
+        y += 12 * cgs.uiHiResScale[1];
 
         text = cgi.LV_ConvertString("Vote now, it's your patriotic duty!");
-        cgi.R_DrawString(cgs.media.attackerFont, text, x, y, -1, qfalse);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, text, x / cgs.uiHiResScale[0], y / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
 
-        y += 12;
+        y += 12 * cgs.uiHiResScale[1];
 
         text = cgi.LV_ConvertString("To vote Yes, press F1. To vote No, press F2.");
-        cgi.R_DrawString(cgs.media.attackerFont, text, x, y, -1, qfalse);
+        cgi.R_DrawString(
+            cgs.media.attackerFont, text, x / cgs.uiHiResScale[0], y / cgs.uiHiResScale[1], -1, cgs.uiHiResScale
+        );
         cgi.R_SetColor(NULL);
     }
 }

code/cgame/cg_local.h

@@ -270,6 +270,8 @@ extern "C" {
         qhandle_t hAlliedPlayerModelHandle;
         dtiki_t  *pAxisPlayerModel;
         qhandle_t hAxisPlayerModelHandle;
+        qboolean  serverAlliedModelValid;
+        qboolean  serverAxisModelValid;
 
         // view eyes
         vec3_t vOffsetViewAngles;
@@ -380,6 +382,7 @@ extern "C" {
         float       screenXScale; // derived from glconfig
         float       screenYScale;
         float       screenXBias;
+        vec2_t      uiHiResScale;
 
         int serverCommandSequence; // reliable command stream counter
         int processedSnapshotNum;  // the number of snapshots cgame has requested
@@ -503,10 +506,18 @@ extern "C" {
     extern cvar_t *voiceChat;
     extern cvar_t *cg_shadowscount;
     extern cvar_t *cg_shadowdebug;
+    extern cvar_t *ui_timemessage;
+
+    //
+    // Added in OPM
+    //
+    extern cvar_t *cg_fov;
+    extern cvar_t *cg_cheats;
 
     //
     // cg_main.c
     //
+    qboolean    CG_UseLargeLightmaps(const char* mapName);
     void        CG_ProcessConfigString(int num, qboolean modelOnly);
     const char *CG_ConfigString(int index);
     void        CG_AddToTeamChat(const char *str);
@@ -522,6 +533,9 @@ extern "C" {
     //
     // cg_modelanim.cpp
     //
+    void CG_ProcessPlayerModel();
+    void CG_ServerModelLoaded(const char* name, qhandle_t handle);
+    void CG_ServerModelUnloaded(qhandle_t handle);
     void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime);
     void CG_AttachEntity(
         refEntity_t *entity, refEntity_t *parent, dtiki_t *tiki, int tagnum, qboolean use_angles, vec3_t attach_offset
@@ -729,8 +743,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,
@@ -923,7 +937,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

@@ -110,6 +110,13 @@ cvar_t *vm_lean_lower;
 cvar_t *voiceChat;
 cvar_t *cg_shadowscount;
 cvar_t *cg_shadowdebug;
+cvar_t *ui_timemessage;
+
+//
+// Added in OPM
+//
+cvar_t *cg_fov;
+cvar_t *cg_cheats;
 
 /*
 =================
@@ -197,53 +204,113 @@ 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;
+
+    //
+    // Added in OPM
+    //
+
+    cg_fov = cgi.Cvar_Get("cg_fov", "80", CVAR_ARCHIVE);
+    cg_cheats = cgi.Cvar_Get("cheats", "0", CVAR_USERINFO | CVAR_SERVERINFO | CVAR_LATCH);
+}
+/*
+===============
+CG_UseLargeLightmaps
+
+Added in 2.0
+Returns true if the standard BSP file should be used, false if the smaller lightmap BSP file should be used
+===============
+*/
+qboolean CG_UseLargeLightmaps(const char* mapName) {
+	char buffer[MAX_QPATH];
+
+	Com_sprintf(buffer, sizeof(buffer), "maps/%s_sml.bsp", mapName);
+
+	if (cgi.FS_ReadFile(buffer, NULL, qtrue) == -1) {
+		return qtrue;
+	}
+
+	return cgi.Cvar_Get("r_largemap", "0", 0)->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);
 }
 
 /*
@@ -300,13 +367,20 @@ void CG_ProcessConfigString(int num, qboolean modelOnly)
             if (tiki) {
                 CG_ProcessCacheInitCommands(tiki);
             }
+
+            CG_ServerModelLoaded(str, hModel);
         } else {
             // clear out the model
-            if (hOldModel && CG_IsHandleUnique(hOldModel)) {
-                // Handle uniqueness added in OPM
+            if (hOldModel) {
+                assert(CG_IsHandleUnique(hOldModel));
                 cgi.R_UnregisterServerModel(hOldModel);
             }
+
             cgs.model_draw[num - CS_MODELS] = 0;
+
+            if (!str || !str[0]) {
+                CG_ServerModelUnloaded(hOldModel);
+            }
         }
     }
 
@@ -338,7 +412,7 @@ void CG_ProcessConfigString(int num, qboolean modelOnly)
             if (cg.rain.numshaders) {
                 // Fixed in OPM
                 //  not sure why some maps set a digit at the end...
-                int len = strlen(cg.rain.currentShader);
+                size_t len = strlen(cg.rain.currentShader);
                 if (isdigit(cg.rain.currentShader[len - 1])) {
                     cg.rain.currentShader[len - 1] = 0;
                 }
@@ -366,7 +440,7 @@ void CG_ProcessConfigString(int num, qboolean modelOnly)
         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) {
@@ -421,7 +495,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;
@@ -535,6 +609,7 @@ void CG_GetRendererConfig(void)
     cgi.GetGlconfig(&cgs.glconfig);
     cgs.screenXScale = cgs.glconfig.vidWidth / 640.0;
     cgs.screenYScale = cgs.glconfig.vidHeight / 480.0;
+    cgi.UI_GetHighResolutionScale(cgs.uiHiResScale);
 }
 
 /*
@@ -823,7 +898,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);
@@ -835,7 +910,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

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2025 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -26,6 +26,33 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "cg_local.h"
 #include "tiki.h"
 
+static qboolean cg_forceModelAllowed = qfalse;
+
+/*
+===============
+CG_GetPlayerModelTiki
+===============
+*/
+const char *CG_GetPlayerModelTiki(const char *modelName)
+{
+    return va("models/player/%s.tik", modelName);
+}
+
+/*
+===============
+CG_GetPlayerLocalModelTiki
+===============
+*/
+const char *CG_GetPlayerLocalModelTiki(const char *modelName)
+{
+    return va("models/player/%s_fps.tik", modelName);
+}
+
+/*
+===============
+CG_PlayerTeamIcon
+===============
+*/
 void CG_PlayerTeamIcon(refEntity_t *pModel, entityState_t *pPlayerState)
 {
     qboolean bInArtillery, bInTeam, bSpecialIcon;
@@ -180,6 +207,118 @@ 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
@@ -187,20 +326,20 @@ CG_CastFootShadow
 Cast complex foot shadow using lights
 ===============
 */
-void CG_CastFootShadow(const vec_t* vLightPos, vec_t* vLightIntensity, int iTag, refEntity_t* model)
+void CG_CastFootShadow(const vec_t *vLightPos, vec_t *vLightIntensity, int iTag, refEntity_t *model)
 {
-    int i;
-    float fAlpha;
-    float fLength;
-    float fWidth;
-    float fAlphaOfs;
-    float fOfs;
-    float fPitchCos;
-    vec3_t vPos;
-    vec3_t vEnd;
-    vec3_t vDelta;
-    vec3_t vLightAngles;
-    trace_t trace;
+    int           i;
+    float         fAlpha;
+    float         fLength;
+    float         fWidth;
+    float         fAlphaOfs;
+    float         fOfs;
+    float         fPitchCos;
+    vec3_t        vPos;
+    vec3_t        vEnd;
+    vec3_t        vDelta;
+    vec3_t        vLightAngles;
+    trace_t       trace;
     orientation_t oFoot;
 
     VectorCopy(model->origin, vPos);
@@ -210,8 +349,7 @@ void CG_CastFootShadow(const vec_t* vLightPos, vec_t* vLightIntensity, int iTag,
         VectorMA(vPos, vEnd[i], model->axis[i], vPos);
     }
 
-    if (cg_shadowdebug->integer)
-    {
+    if (cg_shadowdebug->integer) {
         vec3_t vDir;
 
         //
@@ -262,12 +400,11 @@ void CG_CastFootShadow(const vec_t* vLightPos, vec_t* vLightIntensity, int iTag,
     }
 
     fLength = fPitchCos * fPitchCos * 32.0 + fPitchCos * 8.0 + 10.0;
-    fOfs = 0.5 - (-4.1 / tan(DEG2RAD(vLightAngles[0])) + 4.0 - fLength) / fLength * 0.5;
+    fOfs    = 0.5 - (-4.1 / tan(DEG2RAD(vLightAngles[0])) + 4.0 - fLength) / fLength * 0.5;
     VectorMA(vPos, -96.0, vDelta, vEnd);
     CG_Trace(&trace, vPos, vec3_origin, vec3_origin, vEnd, 0, MASK_FOOTSHADOW, qfalse, qtrue, "CG_CastFootShadow");
-   
-    if (cg_shadowdebug->integer)
-    {
+
+    if (cg_shadowdebug->integer) {
         cgi.R_DebugLine(vPos, vLightPos, 0.75, 0.75, 0.5, 1.0);
         cgi.R_DebugLine(vPos, vEnd, 1.0, 1.0, 1.0, 1.0);
     }
@@ -281,7 +418,7 @@ void CG_CastFootShadow(const vec_t* vLightPos, vec_t* vLightIntensity, int iTag,
         trace.fraction = 0;
     }
 
-    fWidth = 10.f - (1.f - trace.fraction) * 6.f;
+    fWidth    = 10.f - (1.f - trace.fraction) * 6.f;
     fAlphaOfs = (1.f - trace.fraction) * fAlpha;
 
     fAlpha = Q_max(vLightIntensity[0], Q_max(vLightIntensity[1], vLightIntensity[2]));
@@ -334,13 +471,21 @@ CG_CastSimpleFeetShadow
 Cast basic feet shadow
 ===============
 */
-void CG_CastSimpleFeetShadow(const trace_t* pTrace, float fWidth, float fAlpha, int iRightTag, int iLeftTag, const dtiki_t* tiki, refEntity_t* model)
+void CG_CastSimpleFeetShadow(
+    const trace_t *pTrace,
+    float          fWidth,
+    float          fAlpha,
+    int            iRightTag,
+    int            iLeftTag,
+    const dtiki_t *tiki,
+    refEntity_t   *model
+)
 {
-    int i;
-    float fShadowYaw;
-    float fLength;
-    vec3_t vPos, vRightPos, vLeftPos;
-    vec3_t vDelta;
+    int           i;
+    float         fShadowYaw;
+    float         fLength;
+    vec3_t        vPos, vRightPos, vLeftPos;
+    vec3_t        vDelta;
     orientation_t oFoot;
 
     //
@@ -374,7 +519,7 @@ void CG_CastSimpleFeetShadow(const trace_t* pTrace, float fWidth, float fAlpha,
 
     // get the facing yaw
     fShadowYaw = vectoyaw(vDelta);
-    fLength = VectorNormalize(vDelta) * 0.5 + 12;
+    fLength    = VectorNormalize(vDelta) * 0.5 + 12;
     if (fLength < fWidth * 0.7) {
         fLength = fWidth * 0.7;
     }
@@ -439,15 +584,13 @@ qboolean CG_EntityShadow(centity_t *cent, refEntity_t *model)
         }
 
         if (iTagR != -1) {
-            int iNumLights, iCurrLight;
+            int    iNumLights, iCurrLight;
             vec3_t avLightPos[16], avLightIntensity[16];
 
             iNumLights = Q_clamp(cg_shadowscount->integer, 1, 8);
             iNumLights = cgi.R_GatherLightSources(model->origin, avLightPos, avLightIntensity, iNumLights);
-            if (iNumLights)
-            {
-                for (iCurrLight = 0; iCurrLight < iNumLights; iCurrLight++)
-                {
+            if (iNumLights) {
+                for (iCurrLight = 0; iCurrLight < iNumLights; iCurrLight++) {
                     CG_CastFootShadow(avLightPos[iCurrLight], avLightIntensity[iCurrLight], iTagL, model);
                     CG_CastFootShadow(avLightPos[iCurrLight], avLightIntensity[iCurrLight], iTagR, model);
                 }
@@ -550,7 +693,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)) {
@@ -614,6 +757,11 @@ void CG_AttachEntity(
     VectorAdd(entity->origin, vOrigin, entity->lightingOrigin);
 }
 
+/*
+===============
+CG_AttachEyeEntity
+===============
+*/
 void CG_AttachEyeEntity(
     refEntity_t *entity, refEntity_t *parent, dtiki_t *tiki, int tagnum, qboolean use_angles, vec_t *attach_offset
 )
@@ -626,8 +774,7 @@ void CG_AttachEyeEntity(
         AnglesToAxis(cg.refdefViewAngles, entity->axis);
     }
 
-    if (attach_offset[0] || attach_offset[1] || attach_offset[2])
-    {
+    if (attach_offset[0] || attach_offset[1] || attach_offset[2]) {
         for (i = 0; i < 3; i++) {
             VectorMA(entity->origin, attach_offset[i], entity->axis[i], entity->origin);
         }
@@ -639,56 +786,219 @@ void CG_AttachEyeEntity(
     VectorCopy(parent->lightingOrigin, entity->lightingOrigin);
 }
 
+/*
+===============
+CG_IsValidServerModel
+===============
+*/
+qboolean CG_IsValidServerModel(const char *modelpath)
+{
+    const char *str;
+    int         i;
+
+    for (i = 1; i < MAX_MODELS; i++) {
+        str = CG_ConfigString(CS_MODELS + i);
+        if (!Q_stricmp(str, modelpath)) {
+            return qtrue;
+        }
+    }
+
+    return qfalse;
+}
+
+/*
+===============
+CG_CheckValidModels
+
+This verifies the allied player model and the german player model:
+- If they don't exist on the client, reset to the default allied player model
+- If they don't exist on the server, don't allow forceModel so the client explicitly know the skin isn't supported
+===============
+*/
+void CG_CheckValidModels()
+{
+    const char *modelpath;
+    qboolean    isDirty = qfalse;
+
+    if (dm_playermodel->modified) {
+        // Check for allied model
+        modelpath = va("models/player/%s.tik", dm_playermodel->string);
+        if (!cgi.R_RegisterModel(modelpath)) {
+            cgi.Printf(
+                "Allied model '%s' is invalid, resetting to '%s'\n", dm_playermodel->string, dm_playermodel->resetString
+            );
+
+            cgi.Cvar_Set("dm_playermodel", dm_playermodel->resetString);
+            modelpath = va("models/player/%s.tik", dm_playermodel->string);
+        }
+
+        cg.serverAlliedModelValid = CG_IsValidServerModel(modelpath);
+    }
+
+    if (dm_playergermanmodel->modified) {
+        // Check for axis model
+        modelpath = va("models/player/%s.tik", dm_playergermanmodel->string);
+        if (!cgi.R_RegisterModel(modelpath)) {
+            cgi.Printf(
+                "Allied model '%s' is invalid, resetting to '%s'\n",
+                dm_playergermanmodel->string,
+                dm_playergermanmodel->resetString
+            );
+
+            cgi.Cvar_Set("dm_playergermanmodel", dm_playergermanmodel->resetString);
+            modelpath = va("models/player/%s.tik", dm_playergermanmodel->string);
+        }
+
+        cg.serverAxisModelValid = CG_IsValidServerModel(modelpath);
+    }
+
+    if (dm_playermodel->modified || dm_playergermanmodel->modified) {
+        cg_forceModelAllowed = cg.serverAlliedModelValid && cg.serverAxisModelValid;
+    }
+}
+
+/*
+===============
+CG_ServerModelLoaded
+===============
+*/
+void CG_ServerModelLoaded(const char *name, qhandle_t handle)
+{
+    if (!Q_stricmpn(name, "models/player/", 14) && (!cg.serverAlliedModelValid || !cg.serverAxisModelValid)) {
+        char modelName[MAX_QPATH];
+        COM_StripExtension(name + 14, modelName, sizeof(modelName));
+
+        //
+        // The player model has been loaded on the server
+        // so try again parsing
+        //
+        if (!Q_stricmp(modelName, dm_playermodel->string)) {
+            dm_playermodel->modified = qtrue;
+        }
+        if (!Q_stricmp(modelName, dm_playergermanmodel->string)) {
+            dm_playergermanmodel->modified = qtrue;
+        }
+    }
+}
+
+/*
+===============
+CG_ServerModelUnloaded
+===============
+*/
+void CG_ServerModelUnloaded(qhandle_t handle)
+{
+#if 0
+    if (cg.serverAlliedModelValid && handle == cg.hAlliedPlayerModelHandle) {
+        dm_playermodel->modified = qtrue;
+    }
+    if (cg.serverAxisModelValid && handle == cg.hAxisPlayerModelHandle) {
+        dm_playergermanmodel->modified = qtrue;
+    }
+#endif
+}
+
+/*
+===============
+CG_UpdateForceModels
+===============
+*/
 void CG_UpdateForceModels()
 {
     qhandle_t hModel;
-    char* pszAlliesPartial;
-    char* pszAxisPartial;
-    char szAlliesModel[256];
-    char szAxisModel[256];
+    char     *pszAlliesPartial;
+    char     *pszAxisPartial;
+    char      szAlliesModel[256];
+    char      szAxisModel[256];
+    qboolean  isDirty;
 
-    if (cg.pAlliedPlayerModel && cg.pAxisPlayerModel && !dm_playermodel->modified && !dm_playergermanmodel->modified) {
+    isDirty = dm_playermodel->modified || dm_playergermanmodel->modified || cg_forceModel->modified;
+
+    if (!cg_forceModelAllowed) {
+        if (isDirty) {
+            cgi.Printf(
+                "One or more of the selected players model don't exist on the server or are not loaded, using the "
+                "default skin\n"
+            );
+        }
+
+        return;
+    }
+
+    if (cg.pAlliedPlayerModel && cg.pAxisPlayerModel && !isDirty) {
         return;
     }
 
     pszAlliesPartial = dm_playermodel->string;
-    pszAxisPartial = dm_playergermanmodel->string;
+    pszAxisPartial   = dm_playergermanmodel->string;
 
-    sprintf(szAlliesModel, "models/player/%s.tik", pszAlliesPartial);
-    sprintf(szAxisModel, "models/player/%s.tik", pszAxisPartial);
-    hModel = cgi.R_RegisterModel(szAlliesModel);
-    if (!hModel) hModel = cgi.R_RegisterModel("models/player/american_army.tik");
+    Com_sprintf(szAlliesModel, sizeof(szAlliesModel), "models/player/%s.tik", pszAlliesPartial);
+    Com_sprintf(szAxisModel, sizeof(szAxisModel), "models/player/%s.tik", pszAxisPartial);
+
+    hModel = cg.serverAlliedModelValid ? cgi.R_RegisterModel(szAlliesModel) : 0;
+    if (!hModel) {
+        Com_sprintf(szAlliesModel, sizeof(szAlliesModel), "models/player/%s.tik", dm_playermodel->resetString);
+        hModel = cgi.R_RegisterModel(szAlliesModel);
+    }
 
     if (hModel) {
         cg.hAlliedPlayerModelHandle = hModel;
-        cg.pAlliedPlayerModel = cgi.R_Model_GetHandle(hModel);
+        cg.pAlliedPlayerModel       = cgi.R_Model_GetHandle(hModel);
         if (!cg.pAlliedPlayerModel) {
             cg.hAlliedPlayerModelHandle = 0;
         }
     } else {
         cg.hAlliedPlayerModelHandle = 0;
-        cg.pAlliedPlayerModel = 0;
+        cg.pAlliedPlayerModel       = NULL;
     }
 
-    hModel = cgi.R_RegisterModel(szAxisModel);
-    if (!hModel) hModel = cgi.R_RegisterModel("models/player/german_wehrmacht_soldier.tik");
+    hModel = cg.serverAxisModelValid ? cgi.R_RegisterModel(szAxisModel) : 0;
+    if (!hModel) {
+        Com_sprintf(szAxisModel, sizeof(szAxisModel), "models/player/%s.tik", dm_playergermanmodel->resetString);
+        hModel = cgi.R_RegisterModel(szAxisModel);
+    }
 
     if (hModel) {
         cg.hAxisPlayerModelHandle = hModel;
-        cg.pAxisPlayerModel = cgi.R_Model_GetHandle(hModel);
+        cg.pAxisPlayerModel       = cgi.R_Model_GetHandle(hModel);
         if (!cg.pAxisPlayerModel) {
             cg.hAxisPlayerModelHandle = 0;
         }
     } else {
         cg.hAxisPlayerModelHandle = 0;
-        cg.pAxisPlayerModel = 0;
+        cg.pAxisPlayerModel       = 0;
     }
 
     // Clear modified flag
-    dm_playermodel->modified = qfalse;
-    dm_playergermanmodel->modified = qfalse;
+    //dm_playermodel->modified       = qfalse;
+    //dm_playergermanmodel->modified = qfalse;
 }
 
+/*
+===============
+CG_ProcessPlayerModel
+
+Checks player models, and update force models
+===============
+*/
+void CG_ProcessPlayerModel()
+{
+    CG_CheckValidModels();
+    if (cg_forceModel->integer) {
+        CG_UpdateForceModels();
+    }
+
+    // Clear modified flag
+    dm_playermodel->modified       = qfalse;
+    dm_playergermanmodel->modified = qfalse;
+    cg_forceModel->modified        = qfalse;
+}
+
+/*
+===============
+CG_ModelAnim
+===============
+*/
 void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
 {
     entityState_t *s1;
@@ -697,22 +1007,23 @@ 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;
+    qboolean       bThirdPerson = qfalse;
 
     s1 = &cent->currentState;
 
-    if ((cg.snap->ps.pm_flags & PMF_INTERMISSION) && s1->number == cg.snap->ps.clientNum && !cg_3rd_person->integer) {
-        // don't render if in intermission and the client is self without 3rd person
+    bThirdPerson |= cg_3rd_person->integer ? qtrue : qfalse;
+    // Fixed in OPM
+    //  Draw world model body when in camera
+    bThirdPerson |= (cg.snap->ps.pm_flags & PMF_CAMERA_VIEW && !(cg.snap->ps.pm_flags & PMF_TURRET));
+
+    if ((cg.snap->ps.pm_flags & PMF_INTERMISSION) && s1->number == cg.snap->ps.clientNum && !bThirdPerson) {
+        // Don't render the first-person model during intermission
         return;
     }
 
     memset(&model, 0, sizeof(model));
 
-    if (!vmEntity) {
-        vmEntity = cgi.Cvar_Get("viewmodelanim", "1", 0);
-    }
-
     if (cent->interpolate) {
         sNext = &cent->nextState;
     }
@@ -770,7 +1081,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     model.radius = VectorLength(vTmp) * 0.5;
 
     if (s1->number == cg.snap->ps.clientNum) {
-        if (!cg_3rd_person->integer) {
+        if (!bThirdPerson) {
             PmoveAdjustAngleSettings_Client(
                 cg.refdefViewAngles, cent->lerpAngles, &cg.predicted_player_state, &cent->currentState
             );
@@ -834,8 +1145,8 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     model.tiki      = cgi.R_Model_GetHandle(cgs.model_draw[s1->modelindex]);
 
     if (s1->number != cg.snap->ps.clientNum && (s1->eType == ET_PLAYER || (s1->eFlags & EF_DEAD))) {
-        if (cg_forceModel->integer) {
-            CG_UpdateForceModels();
+        if (cg_forceModel->integer && cg_forceModelAllowed) {
+            //CG_UpdateForceModels();
 
             if (s1->eFlags & EF_AXIS) {
                 model.hModel = cg.hAxisPlayerModelHandle;
@@ -859,9 +1170,9 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
         if (!model.hModel || !model.tiki) {
             // Use a model in case it still doesn't exist
             if (s1->eFlags & EF_AXIS) {
-                model.hModel = cgi.R_RegisterModel("models/player/german_wehrmacht_soldier.tik");
+                model.hModel = cgi.R_RegisterModel(CG_GetPlayerModelTiki(dm_playergermanmodel->resetString));
             } else {
-                model.hModel = cgi.R_RegisterModel("models/player/american_army.tik");
+                model.hModel = cgi.R_RegisterModel(CG_GetPlayerModelTiki(dm_playermodel->resetString));
             }
             model.tiki      = cgi.R_Model_GetHandle(model.hModel);
             model.hOldModel = cgs.model_draw[s1->modelindex];
@@ -880,103 +1191,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;
@@ -992,13 +1207,21 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             return;
         }
 
-        if (s1->parent != cg.snap->ps.clientNum || cg_3rd_person->integer) {
+        if (s1->parent != cg.snap->ps.clientNum || bThirdPerson) {
             // attach the model to the world model
-            if (parent->hOldModel) {
-                tiki      = cgi.R_Model_GetHandle(parent->hOldModel);
+
+            // Fixed in OPM
+            //  Added checks to make sure the old model's tiki is valid
+            if (parent->hOldModel && (tiki = cgi.R_Model_GetHandle(parent->hOldModel))) {
                 szTagName = cgi.Tag_NameForNum(tiki, s1->tag_num & TAG_MASK);
-                tiki      = cgi.R_Model_GetHandle(parent->hModel);
-                iTagNum   = cgi.Tag_NumForName(tiki, szTagName);
+                // Fixed in OPM
+                //  Added checks to make sure the tag name is valid
+                if (szTagName) {
+                    tiki    = cgi.R_Model_GetHandle(parent->hModel);
+                    iTagNum = cgi.Tag_NumForName(tiki, szTagName);
+                } else {
+                    iTagNum = 0;
+                }
             } else {
                 tiki    = cgi.R_Model_GetHandle(parent->hModel);
                 iTagNum = s1->tag_num;
@@ -1066,8 +1289,8 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     // set surfaces
     memcpy(model.surfaces, s1->surfaces, MAX_MODEL_SURFACES);
 
-    if (!(s1->renderfx & RF_VIEWMODEL) && s1->parent != ENTITYNUM_NONE && s1->parent == cg.snap->ps.clientNum
-        && ((!cg_drawviewmodel->integer && !cg_3rd_person->integer) || cg.snap->ps.stats[STAT_INZOOM])) {
+    if (!(s1->renderfx & RF_ALWAYSDRAW) && s1->parent != ENTITYNUM_NONE && s1->parent == cg.snap->ps.clientNum
+        && ((!cg_drawviewmodel->integer && !bThirdPerson) || cg.snap->ps.stats[STAT_INZOOM])) {
         // hide all surfaces while zooming or if the viewmodel shouldn't be shown
         for (i = 0; i < MAX_MODEL_SURFACES; i++) {
             model.surfaces[i] |= MDL_SURFACE_NODRAW;
@@ -1152,7 +1375,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
     }
 
     if (s1->number == cg.snap->ps.clientNum) {
-        if ((!cg.bFPSModelLastFrame && !cg_3rd_person->integer) || (cg.bFPSModelLastFrame && cg_3rd_person->integer)) {
+        if ((!cg.bFPSModelLastFrame && !bThirdPerson) || (cg.bFPSModelLastFrame && bThirdPerson)) {
             // reset the animations when toggling 3rd person
             for (i = 0; i < MAX_FRAMEINFOS; i++) {
                 cent->animLast[i] = -1;
@@ -1161,7 +1384,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             cent->animLastWeight = 0;
             cent->usageIndexLast = 0;
 
-            cg.bFPSModelLastFrame = !cg_3rd_person->integer;
+            cg.bFPSModelLastFrame = !bThirdPerson;
         }
 
         // player footsteps, walking/falling
@@ -1178,7 +1401,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             }
         }
 
-        if (!cg_3rd_person->integer) {
+        if (!bThirdPerson) {
             // first person view
 
             if (!(cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)
@@ -1190,7 +1413,9 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             if (!cg.pLastPlayerWorldModel || cg.pLastPlayerWorldModel != model.tiki) {
                 qhandle_t hModel;
                 char      fpsname[128];
+
                 COM_StripExtension(model.tiki->a->name, fpsname, sizeof(fpsname));
+                Q_strcat(fpsname, sizeof(fpsname), "_fps.tik");
 
                 hModel = cgi.R_RegisterModel(fpsname);
                 if (hModel) {
@@ -1201,9 +1426,9 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
                     }
                 } else {
                     if (cg.snap->ps.stats[STAT_TEAM] == TEAM_AXIS) {
-                        hModel = cgi.R_RegisterModel("models/player/german_wehrmacht_soldier_fps.tik");
+                        hModel = cgi.R_RegisterModel(CG_GetPlayerLocalModelTiki(dm_playergermanmodel->resetString));
                     } else {
-                        hModel = cgi.R_RegisterModel("models/player/american_army_fps.tik");
+                        hModel = cgi.R_RegisterModel(CG_GetPlayerLocalModelTiki(dm_playermodel->resetString));
                     }
 
                     if (hModel) {
@@ -1227,6 +1452,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
@@ -1324,7 +1550,7 @@ void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime)
             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);
                 if (cent->animLastTimes[i] == -1) {
-                    cent->animLast[i] = model.frameInfo[i].index;
+                    cent->animLast[i]      = model.frameInfo[i].index;
                     cent->animLastTimes[i] = model.frameInfo[i].time;
                 } else {
                     cent->animLastTimes[i] = 0;

code/cgame/cg_nature.cpp

@@ -51,7 +51,7 @@ void RainTouch(ctempmodel_t *ct, trace_t *trace)
 
 void ClientGameCommandManager::RainTouch(Event *ev)
 {
-    // FIXME: unimplemented
+    // Nothing to do
 }
 
 void ClientGameCommandManager::InitializeRainCvars()
@@ -60,7 +60,7 @@ void ClientGameCommandManager::InitializeRainCvars()
 
     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;
@@ -102,26 +102,29 @@ void CG_Rain(centity_t *cent)
 
     cgi.R_ModelBounds(cgs.inlineDrawModel[cent->currentState.modelindex], mins, maxs);
 
+    // Fixed in 2.0
+    //  Use cg.refdef.vieworg instead of cg.snap.ps.origin
+
     vOmins[0] = mins[0] + cent->lerpOrigin[0];
-    if (vOmins[0] < cg.snap->ps.origin[0] - cg.rain.min_dist) {
-        vOmins[0] = cg.snap->ps.origin[0] - cg.rain.min_dist;
+    if (vOmins[0] < cg.refdef.vieworg[0] - cg.rain.min_dist) {
+        vOmins[0] = cg.refdef.vieworg[0] - cg.rain.min_dist;
     }
 
     vOmins[1] = mins[1] + cent->lerpOrigin[1];
-    if (vOmins[1] < cg.snap->ps.origin[1] - cg.rain.min_dist) {
-        vOmins[1] = cg.snap->ps.origin[1] - cg.rain.min_dist;
+    if (vOmins[1] < cg.refdef.vieworg[1] - cg.rain.min_dist) {
+        vOmins[1] = cg.refdef.vieworg[1] - cg.rain.min_dist;
     }
 
     vOmins[2] = mins[2] + cent->lerpOrigin[2];
 
     vOmaxs[0] = maxs[0] + cent->lerpOrigin[0];
-    if (vOmaxs[0] > cg.rain.min_dist + cg.snap->ps.origin[0]) {
-        vOmaxs[0] = cg.rain.min_dist + cg.snap->ps.origin[0];
+    if (vOmaxs[0] > cg.refdef.vieworg[0] + cg.rain.min_dist) {
+        vOmaxs[0] = cg.refdef.vieworg[0] + cg.rain.min_dist;
     }
 
     vOmaxs[1] = maxs[1] + cent->lerpOrigin[1];
-    if (vOmaxs[1] > cg.rain.min_dist + cg.snap->ps.origin[1]) {
-        vOmaxs[1] = cg.rain.min_dist + cg.snap->ps.origin[1];
+    if (vOmaxs[1] > cg.refdef.vieworg[1] + cg.rain.min_dist) {
+        vOmaxs[1] = cg.refdef.vieworg[1] + cg.rain.min_dist;
     }
 
     vOmaxs[2] = maxs[2] + cent->lerpOrigin[2];
@@ -168,26 +171,37 @@ void CG_Rain(centity_t *cent)
     }
 
     for (i = 0; i < iNumSpawn; ++i) {
-        iLife     = (int)(vOe[2] / ((float)(iRandom % cg.rain.speed_vary) + cg.rain.speed) * 1000.0);
         vStart[0] = (float)(iRandom % (int)(vOe[0] + 1.0)) + vOmins[0];
         iRandom   = ((214013 * iRandom + 2531011) >> 16) & 0x7FFF;
         vStart[1] = (float)(iRandom % (int)(vOe[1] + 1.0)) + vOmins[1];
-        vStart[2] = vOmaxs[2];
+        iRandom   = ((214013 * iRandom + 2531011) >> 16) & 0x7FFF;
+        // Fixed in 2.0
+        //  Use random height instead of the max height to avoid waiting for it to fall down
+        vStart[2] = (float)(iRandom % (int)(vOe[2] + 1.0)) + vOmins[2];
 
-        if (cg.snap) {
-            vLength[0] = cg.snap->ps.origin[0] - vStart[0];
-            vLength[1] = cg.snap->ps.origin[1] - vStart[1];
-            vLength[2] = 0.0;
-            if (cg.rain.min_dist * cg.rain.min_dist < VectorLengthSquared(vLength)) {
-                continue;
-            }
+        VectorSubtract(cg.refdef.vieworg, vStart, vLength);
+        vLength[2] = 0;
+
+        if (VectorLengthSquared(vLength) > Square(cg.rain.min_dist)) {
+            continue;
         }
 
+        iRandom = ((214013 * iRandom + 2531011) >> 16) & 0x7FFF;
+
         vEnd[0] = (float)(iRandom % cg.rain.slant) + vStart[0] + vss_wind_x->value;
         iRandom = ((214013 * iRandom + 2531011) >> 16) & 0x7FFF;
         vEnd[1] = (float)(iRandom % cg.rain.slant) + vStart[1] + vss_wind_y->value;
         vEnd[2] = vOmins[2];
 
+        // Fixed in 2.0
+        //  Use individual particle's origin to determine the life rather than the bounding box
+        iLife = (int)((vStart[2] - vOmins[2]) / ((float)(iRandom % cg.rain.speed_vary) + cg.rain.speed) * 1000.0);
+        if (iLife > 10000) {
+            // Fixed in 2.0
+            //  Rain particles must not last longer than 10 seconds
+            iLife = 10000;
+        }
+
         CG_CreateBeam(
             vStart,
             vec_zero,

code/cgame/cg_parsemsg.cpp

@@ -26,6 +26,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "cg_local.h"
 #include "cg_parsemsg.h"
 #include "cg_specialfx.h"
+#include "cg_radar.h"
 
 #include "str.h"
 
@@ -84,7 +85,12 @@ void CG_MakeBulletHoleSound(const vec3_t i_vPos, const vec3_t i_vNorm, int iLarg
         iSurfType = SURF_PUDDLE;
     }
 
-    if (trace.fraction == 1.0f || trace.startsolid || (trace.surfaceFlags & SURF_SKY)) {
+    if (trace.fraction == 1) {
+        // no reason to make a sound if it nothing was hit
+        return;
+    }
+
+    if ((trace.surfaceFlags & SURF_SKY) || !CG_CheckMakeMarkOnEntity(trace.entityNum)) {
         return;
     }
 
@@ -252,7 +258,12 @@ CG_MakeBulletHole(const vec3_t i_vPos, const vec3_t i_vNorm, int iLarge, trace_t
         iSurfType = SURF_PUDDLE;
     }
 
-    if (trace.fraction == 1.0f || trace.startsolid || (trace.surfaceFlags & SURF_SKY)) {
+    if (trace.fraction == 1.0f || trace.startsolid) {
+        return;
+    }
+
+    if (trace.surfaceFlags & SURF_SKY) {
+        // ignore sky surfaces
         return;
     }
 
@@ -426,7 +437,7 @@ static void CG_BulletTracerEffect(const vec3_t i_vStart, const vec3_t i_vEnd, in
         0,
         1,
         1.0,
-        1.0,
+        scale,
         BEAM_INVERTED,
         1000.0,
         iLife,
@@ -459,35 +470,36 @@ static void CG_MakeBulletTracerInternal(
     float         alpha
 )
 {
-    vec3_t       vPos;
-    int          iBullet;
-    int          iContinueCount;
-    int          iDist;
-    int          iHeadDist;
-    int          iTravelDist;
-    float        fLen, fDist;
-    trace_t      trace;
-    qboolean     bStartInWater, bInWater;
-    qboolean     bBulletDone;
-    qboolean     bMadeTracer;
-    vec3_t       vDir;
-    vec3_t       vTrailStart;
-    vec3_t       vTraceStart;
-    vec3_t       vTraceEnd;
-    vec3_t       vTmp;
-    int          iNumImpacts;
-    trace_t      tImpacts[128];
-    float        fImpSndDistRA;
-    static float fImpSndDistLA;
-    float        fImpSndDistRB;
-    float        fImpSndDistLB;
-    int          iImpSndIndexRA;
-    int          iImpSndIndexRB;
-    int          iImpSndIndexLB;
-    float        fVolume;
-    float        fPitch;
-    float        fZingDistA, fZingDistB, fZingDistC;
-    vec3_t       vZingPosA, vZingPosB, vZingPosC;
+    vec3_t   vPos;
+    int      iBullet;
+    int      iContinueCount;
+    int      iDist;
+    int      iHeadDist;
+    int      iTravelDist;
+    float    fLen, fDist;
+    trace_t  trace;
+    qboolean bStartInWater, bInWater;
+    qboolean bBulletDone;
+    qboolean bMadeTracer;
+    vec3_t   vDir;
+    vec3_t   vTrailStart;
+    vec3_t   vTraceStart;
+    vec3_t   vTraceEnd;
+    vec3_t   vTmp;
+    int      iNumImpacts;
+    trace_t  tImpacts[128];
+    float    fImpSndDistRA;
+    float    fImpSndDistLA;
+    float    fImpSndDistRB;
+    float    fImpSndDistLB;
+    int      iImpSndIndexRA;
+    int      iImpSndIndexLA;
+    int      iImpSndIndexRB;
+    int      iImpSndIndexLB;
+    float    fVolume;
+    float    fPitch;
+    float    fZingDistA, fZingDistB, fZingDistC;
+    vec3_t   vZingPosA, vZingPosB, vZingPosC;
 
     fZingDistB  = 9999.0;
     fZingDistA  = 9999.0;
@@ -583,7 +595,8 @@ static void CG_MakeBulletTracerInternal(
                              || (trace.contents & CONTENTS_WATER))
                             && iContinueCount < 5) {
                             if (bInWater) {
-                                VectorSubtract(trace.endpos, vDir, vTmp);
+                                VectorMA(trace.endpos, -1.0, vDir, vTmp);
+
                                 if (!(trace.contents & CONTENTS_FLUID) && !(trace.surfaceFlags & SURF_PUDDLE)
                                     && !(cgi.CM_PointContents(vTmp, 0) & CONTENTS_FLUID)) {
                                     CG_MakeBubbleTrail(vTrailStart, trace.endpos, iLarge, alpha);
@@ -595,8 +608,7 @@ static void CG_MakeBulletTracerInternal(
                                 bInWater = qtrue;
                             }
 
-                            VectorAdd(vDir, vDir, vTraceStart);
-                            VectorAdd(vTraceStart, vTraceStart, trace.endpos);
+                            VectorMA(trace.endpos, 2.0, vDir, vTraceStart);
 
                             iContinueCount++;
                         } else {
@@ -658,46 +670,46 @@ static void CG_MakeBulletTracerInternal(
     if (iNumImpacts > 2) {
         fImpSndDistRA  = 9999.0f;
         fImpSndDistRB  = 9999.0f;
-        iImpSndIndexRA = 0;
-        iImpSndIndexRB = 0;
+        fImpSndDistLA  = 9999.0f;
         fImpSndDistLB  = 9999.0f;
+        iImpSndIndexRA = 0;
+        iImpSndIndexLA = 0;
+        iImpSndIndexRB = 0;
         iImpSndIndexLB = 0;
 
         for (iBullet = 0; iBullet < iNumImpacts; iBullet++) {
             CG_MakeBulletHole(
-                tImpacts[iImpSndIndexLB].endpos,
-                tImpacts[iImpSndIndexLB].plane.normal,
-                iLarge,
-                &tImpacts[iImpSndIndexLB],
-                qfalse
+                tImpacts[iBullet].endpos, tImpacts[iBullet].plane.normal, iLarge, &tImpacts[iBullet], qfalse
             );
 
-            VectorSubtract(tImpacts[iImpSndIndexLB].endpos, cg.SoundOrg, vTmp);
+            VectorSubtract(tImpacts[iBullet].endpos, cg.SoundOrg, vTmp);
             iHeadDist = VectorLength(vTmp);
 
             if (DotProduct(vTmp, cg.SoundAxis[1]) <= 0.f) {
-                if (iHeadDist < 9999.0f || iHeadDist < fImpSndDistLB) {
-                    if (iHeadDist < 9999.0f) {
-                        fImpSndDistRA  = iHeadDist;
-                        fImpSndDistLB  = 9999.0;
+                if (iHeadDist < fImpSndDistLA || iHeadDist < fImpSndDistLB) {
+                    if (iHeadDist < fImpSndDistLA) {
+                        iImpSndIndexLB = iImpSndIndexLA;
+                        fImpSndDistLB  = fImpSndDistLA;
                         iImpSndIndexRA = iBullet;
+                        fImpSndDistRA  = iHeadDist;
                     } else if (iHeadDist < fImpSndDistLB) {
-                        fImpSndDistLB = iHeadDist;
+                        iImpSndIndexLB = iBullet;
+                        fImpSndDistLB  = iHeadDist;
                     }
                 }
             } else {
                 if (iHeadDist < fImpSndDistRA || iHeadDist < fImpSndDistRB) {
                     if (iHeadDist < fImpSndDistRA) {
                         iImpSndIndexRB = iImpSndIndexRA;
+                        fImpSndDistRB  = fImpSndDistRA;
                         iImpSndIndexRA = iBullet;
+                        fImpSndDistRA  = iHeadDist;
                     } else if (iHeadDist < fImpSndDistRB) {
-                        fImpSndDistRB  = iHeadDist;
                         iImpSndIndexRB = iBullet;
+                        fImpSndDistRB  = iHeadDist;
                     }
                 }
             }
-
-            iImpSndIndexLB++;
         }
 
         if (fImpSndDistRA < 9999.0f) {
@@ -717,6 +729,24 @@ static void CG_MakeBulletTracerInternal(
                 );
             }
         }
+
+        if (fImpSndDistLA < 9999.0f) {
+            CG_MakeBulletHoleSound(
+                tImpacts[iImpSndIndexLA].endpos,
+                tImpacts[iImpSndIndexLA].plane.normal,
+                iLarge,
+                &tImpacts[iImpSndIndexLA]
+            );
+
+            if (fImpSndDistLB < 9999.0f) {
+                CG_MakeBulletHoleSound(
+                    tImpacts[iImpSndIndexLB].endpos,
+                    tImpacts[iImpSndIndexLB].plane.normal,
+                    iLarge,
+                    &tImpacts[iImpSndIndexLB]
+                );
+            }
+        }
     } else {
         for (iBullet = 0; iBullet < iNumImpacts; iBullet++) {
             CG_MakeBulletHole(
@@ -735,8 +765,14 @@ static void CG_MakeBulletTracerInternal(
         }
 
         commandManager.PlaySound("snd_b_zing", vZingPosA, -1, fVolume, -1.0f, fPitch, 1);
-        commandManager.PlaySound("snd_b_zing", vZingPosB, -1, fVolume, -1.0f, fPitch, 1);
-        commandManager.PlaySound("snd_b_zing", vZingPosC, -1, fVolume, -1.0f, fPitch, 1);
+
+        if (fZingDistB != 9999) {
+            commandManager.PlaySound("snd_b_zing", vZingPosB, -1, fVolume, -1.0f, fPitch, 1);
+
+            if (fZingDistC != 9999) {
+                commandManager.PlaySound("snd_b_zing", vZingPosC, -1, fVolume, -1.0f, fPitch, 1);
+            }
+        }
     }
 }
 
@@ -866,7 +902,8 @@ void CG_AddBulletImpacts()
                         fVolume = 0.75f;
                     }
 
-                    if (wall_impact_type[iImpSndIndexRA] == SFX_BHIT_WOOD_LITE || wall_impact_type[iImpSndIndexRA] == SFX_BHIT_WOOD_HARD) {
+                    if (wall_impact_type[iImpSndIndexRA] == SFX_BHIT_WOOD_LITE
+                        || wall_impact_type[iImpSndIndexRA] == SFX_BHIT_WOOD_HARD) {
                         sSoundName = "snd_bh_metal";
                     } else {
                         sSoundName = "snd_bh_wood";
@@ -897,7 +934,8 @@ void CG_AddBulletImpacts()
                             fVolume = 0.75f;
                         }
 
-                        if (wall_impact_type[iImpSndIndexRB] == SFX_BHIT_WOOD_LITE || wall_impact_type[iImpSndIndexRB] == SFX_BHIT_WOOD_HARD) {
+                        if (wall_impact_type[iImpSndIndexRB] == SFX_BHIT_WOOD_LITE
+                            || wall_impact_type[iImpSndIndexRB] == SFX_BHIT_WOOD_HARD) {
                             sSoundName = "snd_bh_metal";
                         } else {
                             sSoundName = "snd_bh_wood";
@@ -952,7 +990,8 @@ void CG_AddBulletImpacts()
                         fVolume = 0.75f;
                     }
 
-                    if (wall_impact_type[iImpSndIndexLB] == SFX_BHIT_WOOD_LITE || wall_impact_type[iImpSndIndexLB] == SFX_BHIT_WOOD_HARD) {
+                    if (wall_impact_type[iImpSndIndexLB] == SFX_BHIT_WOOD_LITE
+                        || wall_impact_type[iImpSndIndexLB] == SFX_BHIT_WOOD_HARD) {
                         sSoundName = "snd_bh_metal";
                     } else {
                         sSoundName = "snd_bh_wood";
@@ -1482,7 +1521,7 @@ void CG_ParseCGMessage_ver_15()
             vStart[2] = cgi.MSG_ReadCoord();
             cgi.MSG_ReadDir(vEnd);
 
-            sfxManager.MakeEffect_Normal(SFX_EXP_GREN_PUDDLE + iType, vStart, vEnd);
+            sfxManager.MakeEffect_Normal((iType - CGM_MAKE_EFFECT_1) + SFX_OIL_LEAK_BIG, vStart, vEnd);
             break;
 
         case CGM_MAKE_CRATE_DEBRIS:
@@ -1549,7 +1588,7 @@ void CG_ParseCGMessage_ver_15()
             vEndArray[0][0] = cgi.MSG_ReadCoord();
             vEndArray[0][1] = cgi.MSG_ReadCoord();
             vEndArray[0][2] = cgi.MSG_ReadCoord();
-            iLarge          = cgi.MSG_ReadBits(1);
+            iLarge          = cgi.MSG_ReadBits(2);
 
             if (cgi.MSG_ReadBits(1)) {
                 int iAlpha = cgi.MSG_ReadBits(10);
@@ -1566,7 +1605,11 @@ void CG_ParseCGMessage_ver_15()
 
         case CGM_HUDDRAW_SHADER:
             iInfo = cgi.MSG_ReadByte();
-            strcpy(cgi.HudDrawElements[iInfo].shaderName, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].shaderName,
+                cgi.MSG_ReadString(),
+                sizeof(cgi.HudDrawElements[iInfo].shaderName)
+            );
             cgi.HudDrawElements[iInfo].string[0]   = 0;
             cgi.HudDrawElements[iInfo].pFont       = NULL;
             cgi.HudDrawElements[iInfo].fontName[0] = 0;
@@ -1608,26 +1651,32 @@ void CG_ParseCGMessage_ver_15()
         case CGM_HUDDRAW_STRING:
             iInfo                              = cgi.MSG_ReadByte();
             cgi.HudDrawElements[iInfo].hShader = 0;
-            strcpy(cgi.HudDrawElements[iInfo].string, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].string, cgi.MSG_ReadString(), sizeof(cgi.HudDrawElements[iInfo].string)
+            );
             break;
 
         case CGM_HUDDRAW_FONT:
             iInfo = cgi.MSG_ReadByte();
-            strcpy(cgi.HudDrawElements[iInfo].fontName, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].fontName, cgi.MSG_ReadString(), sizeof(cgi.HudDrawElements[iInfo].fontName)
+            );
             cgi.HudDrawElements[iInfo].hShader       = 0;
             cgi.HudDrawElements[iInfo].shaderName[0] = 0;
             // load the font
             CG_HudDrawFont(iInfo);
             break;
 
-        case CGM_NOTIFY_KILL:
         case CGM_NOTIFY_HIT:
-            {
-                int iOldEnt;
+        case CGM_NOTIFY_KILL:
+            if (cg.snap) {
+                const char *soundName;
+                int         iOldEnt;
+
+                iOldEnt = current_entity_number;
 
-                iOldEnt               = current_entity_number;
                 current_entity_number = cg.snap->ps.clientNum;
-                if (iType == CGM_NOTIFY_HIT) {
+                if (iType == CGM_NOTIFY_KILL) {
                     commandManager.PlaySound("dm_kill_notify", NULL, CHAN_LOCAL, 2.0, -1, -1, 1);
                 } else {
                     commandManager.PlaySound("dm_hit_notify", NULL, CHAN_LOCAL, 2.0, -1, -1, 1);
@@ -1639,43 +1688,73 @@ void CG_ParseCGMessage_ver_15()
 
         case CGM_VOICE_CHAT:
             {
+                qboolean bLocal;
                 int iOldEnt;
 
                 vStart[0] = cgi.MSG_ReadCoord();
                 vStart[1] = cgi.MSG_ReadCoord();
                 vStart[2] = cgi.MSG_ReadCoord();
-                iLarge    = cgi.MSG_ReadBits(1);
+                bLocal    = cgi.MSG_ReadBits(1);
                 iInfo     = cgi.MSG_ReadBits(6);
                 szTmp     = cgi.MSG_ReadString();
 
                 iOldEnt = current_entity_number;
 
-                if (iLarge) {
+                if (bLocal) {
                     current_entity_number = iInfo;
 
-                    commandManager.PlaySound(szTmp, vStart, CHAN_LOCAL, -1, -1, -1, 0);
-                } else {
+                    commandManager.PlaySound(szTmp, vStart, CHAN_AUTO, -1, -1, -1, 0);
+                } else if (cg.snap) {
                     current_entity_number = cg.snap->ps.clientNum;
 
-                    commandManager.PlaySound(szTmp, vStart, CHAN_AUTO, -1, -1, -1, 1);
+                    commandManager.PlaySound(szTmp, vStart, CHAN_LOCAL, -1, -1, -1, 1);
                 }
 
+                CG_RadarClientSpeaks(iInfo);
                 current_entity_number = iOldEnt;
             }
             break;
         case CGM_FENCEPOST:
-            vStart[0] = cgi.MSG_ReadCoord();
-            vStart[1] = cgi.MSG_ReadCoord();
-            vStart[2] = cgi.MSG_ReadCoord();
-            vEnd[0]   = cgi.MSG_ReadCoord();
-            vEnd[1]   = cgi.MSG_ReadCoord();
-            vEnd[2]   = cgi.MSG_ReadCoord();
-            cgi.MSG_ReadByte();
-            cgi.MSG_ReadByte();
-            VectorSubtract(vEnd, vStart, vTmp);
+            {
+                int    iHalf;
+                vec3_t vForward, vRight, vUp;
+                float  fLength;
 
-            // FIXME: unimplemented
-            // ?? can't figure out what is this
+                vStart[0] = cgi.MSG_ReadCoord();
+                vStart[1] = cgi.MSG_ReadCoord();
+                vStart[2] = cgi.MSG_ReadCoord();
+                vEnd[0]   = cgi.MSG_ReadCoord();
+                vEnd[1]   = cgi.MSG_ReadCoord();
+                vEnd[2]   = cgi.MSG_ReadCoord();
+                iHalf     = cgi.MSG_ReadByte();
+                cgi.MSG_ReadByte();
+
+                VectorSubtract(vEnd, vStart, vForward);
+                fLength = VectorNormalize(vForward);
+                iCount  = fLength / 2.0;
+
+                MakeNormalVectors(vForward, vRight, vUp);
+
+                for (i = 0; i < iCount; i++) {
+                    vec3_t vOrg;
+                    vec3_t vNormal;
+
+                    VectorCopy(vStart, vOrg);
+
+                    VectorMA(vOrg, random(), vForward, vOrg);
+                    VectorMA(vOrg, crandom() * iHalf, vRight, vOrg);
+                    VectorMA(vOrg, crandom() * iHalf, vUp, vOrg);
+
+                    //
+                    // Spawn the fence wood effect
+                    //
+
+                    VectorSubtract(vStart, vOrg, vNormal);
+                    VectorNormalize(vNormal);
+
+                    sfxManager.MakeEffect_Normal(SFX_FENCE_WOOD, vOrg, vNormal);
+                }
+            }
             break;
         default:
             cgi.Error(ERR_DROP, "CG_ParseCGMessage: Unknown CGM message type");
@@ -1853,7 +1932,7 @@ void CG_ParseCGMessage_ver_6()
             vStart[2] = cgi.MSG_ReadCoord();
             cgi.MSG_ReadDir(vEnd);
 
-            sfxManager.MakeEffect_Normal(SFX_EXP_GREN_PUDDLE + iType, vStart, vEnd);
+            sfxManager.MakeEffect_Normal((iType - CGM6_MAKE_EFFECT_1) + SFX_OIL_LEAK_BIG, vStart, vEnd);
             break;
 
         case CGM6_MAKE_CRATE_DEBRIS:
@@ -1917,7 +1996,11 @@ void CG_ParseCGMessage_ver_6()
 
         case CGM6_HUDDRAW_SHADER:
             iInfo = cgi.MSG_ReadByte();
-            strcpy(cgi.HudDrawElements[iInfo].shaderName, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].shaderName,
+                cgi.MSG_ReadString(),
+                sizeof(cgi.HudDrawElements[iInfo].shaderName)
+            );
             cgi.HudDrawElements[iInfo].string[0]   = 0;
             cgi.HudDrawElements[iInfo].pFont       = NULL;
             cgi.HudDrawElements[iInfo].fontName[0] = 0;
@@ -1959,26 +2042,31 @@ void CG_ParseCGMessage_ver_6()
         case CGM6_HUDDRAW_STRING:
             iInfo                              = cgi.MSG_ReadByte();
             cgi.HudDrawElements[iInfo].hShader = 0;
-            strcpy(cgi.HudDrawElements[iInfo].string, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].string, cgi.MSG_ReadString(), sizeof(cgi.HudDrawElements[iInfo].string)
+            );
             break;
 
         case CGM6_HUDDRAW_FONT:
             iInfo = cgi.MSG_ReadByte();
-            strcpy(cgi.HudDrawElements[iInfo].fontName, cgi.MSG_ReadString());
+            Q_strncpyz(
+                cgi.HudDrawElements[iInfo].fontName, cgi.MSG_ReadString(), sizeof(cgi.HudDrawElements[iInfo].fontName)
+            );
             cgi.HudDrawElements[iInfo].hShader       = 0;
             cgi.HudDrawElements[iInfo].shaderName[0] = 0;
             // load the font
             CG_HudDrawFont(iInfo);
             break;
 
-        case CGM6_NOTIFY_KILL:
         case CGM6_NOTIFY_HIT:
-            {
+        case CGM6_NOTIFY_KILL:
+            if (cg.snap) {
                 int iOldEnt;
 
-                iOldEnt               = current_entity_number;
+                iOldEnt = current_entity_number;
+
                 current_entity_number = cg.snap->ps.clientNum;
-                if (iType == CGM6_NOTIFY_HIT) {
+                if (iType == CGM6_NOTIFY_KILL) {
                     commandManager.PlaySound("dm_kill_notify", NULL, CHAN_LOCAL, 2.0, -1, -1, 1);
                 } else {
                     commandManager.PlaySound("dm_hit_notify", NULL, CHAN_LOCAL, 2.0, -1, -1, 1);
@@ -2005,10 +2093,10 @@ void CG_ParseCGMessage_ver_6()
                     current_entity_number = iInfo;
 
                     commandManager.PlaySound(szTmp, vStart, CHAN_LOCAL, -1, -1, -1, 0);
-                } else {
+                } else if (cg.snap) {
                     current_entity_number = cg.snap->ps.clientNum;
 
-                    commandManager.PlaySound(szTmp, vStart, CHAN_AUTO, -1, -1, -1, 1);
+                    commandManager.PlaySound(szTmp, vStart, CHAN_LOCAL, -1, -1, -1, 1);
                 }
 
                 current_entity_number = iOldEnt;

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,
@@ -329,8 +330,18 @@ static void CG_InterpolatePlayerStateCamera(void)
     //
     VectorCopy(cg.predicted_player_state.camera_angles, cg.camera_angles);
     VectorCopy(cg.predicted_player_state.camera_origin, cg.camera_origin);
-    cg.camera_fov = cg.predicted_player_state.fov;
 
+    //
+    // Added in OPM
+    //  Use the specified fov specified by the server
+    //  when zooming
+    //
+    if (cg.predicted_player_state.stats[STAT_INZOOM]) {
+        cg.camera_fov = cg.predicted_player_state.fov;
+    } else {
+        cg.camera_fov = cg_fov->value;
+    }
+    
     // if the next frame is a teleport, we can't lerp to it
     if (cg.nextFrameCameraCut) {
         return;
@@ -342,13 +353,24 @@ static void CG_InterpolatePlayerStateCamera(void)
 
     f = (float)(cg.time - prev->serverTime) / (next->serverTime - prev->serverTime);
 
-    // interpolate fov
-    cg.camera_fov = prev->ps.fov + f * (next->ps.fov - prev->ps.fov);
+    if (cg.predicted_player_state.stats[STAT_INZOOM]) {
+        // interpolate fov
+        cg.camera_fov = prev->ps.fov + f * (next->ps.fov - prev->ps.fov);
+    } else {
+        cg.camera_fov = cg_fov->value;
+    }
 
     if (!(cg.snap->ps.pm_flags & PMF_CAMERA_VIEW)) {
         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 +515,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 +542,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,7 +120,9 @@ 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);
+        void (*Cvar_CheckRange)(cvar_t* var, float min, float max, qboolean integral);
 
         // ClientCommand and ConsoleCommand parameter access
         int (*Argc)(void);
@@ -311,12 +313,12 @@ functions exported to the main executable
         ); // 0 = white
         fontheader_t *(*R_LoadFont)(const char *name);
         void (*R_DrawString)(
-            fontheader_t *font, const char *text, float x, float y, int maxLen, qboolean virtualScreen
+            fontheader_t *font, const char *text, float x, float y, int maxLen, const float *pvVirtualScreen
         );
         refEntity_t *(*R_GetRenderEntity)(int entityNumber);
         void (*R_ModelBounds)(clipHandle_t model, vec3_t mins, vec3_t maxs);
         float (*R_ModelRadius)(clipHandle_t model);
-        float (*R_Noise)(float x, float y, float z, float t);
+        float (*R_Noise)(float x, float y, float z, double t);
         void (*R_DebugLine)(const vec3_t start, const vec3_t end, float r, float g, float b, float alpha);
         baseshader_t *(*GetShader)(int shaderNum);
         // =========== Swipes =============
@@ -360,6 +362,9 @@ 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);
+        void (*UI_GetHighResolutionScale)(vec2_t scale);
 
         int (*Key_StringToKeynum)(const char *str);
         const char *(*Key_KeynumToBindString)(int keyNum);
@@ -465,8 +470,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.
 
@@ -25,12 +26,27 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cg_local.h"
 #include "../fgame/bg_voteoptions.h"
+#include "cg_servercmds_filter.h"
 
+/*
+================
+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 +150,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 +165,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,11 +186,15 @@ 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);
-
+    if (CG_UseLargeLightmaps(mapname)) {
+        Com_sprintf(cgs.mapname, sizeof(cgs.mapname), "maps/%s.bsp", map);
+    } else {
+        Com_sprintf(cgs.mapname, sizeof(cgs.mapname), "maps/%s_sml.bsp", map);
+    }
+    
     // hide/show huds
     if (cgs.gametype) {
         cgi.Cmd_Execute(EXEC_NOW, "ui_addhud hud_timelimit\n");
@@ -311,12 +332,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 +373,14 @@ static void CG_ServerCommand(qboolean modelOnly)
     }
 
     if (!strcmp(cmd, "stufftext")) {
-        cgi.Cmd_Stuff(cgi.Argv(1));
+        char *cmd = cgi.Argv(1);
+        if (!CG_IsStatementAllowed(cmd)) {
+            // Added in OPM
+            //  Don't execute filtered commands
+            return;
+        }
+
+        cgi.Cmd_Stuff(cmd);
         cgi.Cmd_Stuff("\n");
         return;
     }

code/cgame/cg_servercmds_filter.cpp

@@ -0,0 +1,302 @@
+/*
+===========================================================================
+Copyright (C) 2025 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
+===========================================================================
+*/
+
+// DESCRIPTION:
+// cg_servercmds_filter.c -- filtered server commands
+
+#include "cg_local.h"
+#include "cg_servercmds_filter.h"
+
+//
+// List of variables allowed to be changed by the server
+//
+static const char *whiteListedVariables[] = {
+    // some mods set this variable to make the sky uniform
+    "r_fastsky",
+
+    "ui_hud",
+    "subtitle0",
+    "subtitle1",
+    "subtitle2",
+    "subtitle3",
+    "name",
+
+    // for 3rd person server
+    "cg_3rd_person",
+    "cg_cameraverticaldisplacement"
+};
+
+//
+// List of 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[] = {
+    //
+    // HUD
+    //==========
+    "pushmenu",
+    "pushmenu_teamselect",
+    "pushmenu_weaponselect",
+    "popmenu",
+    "globalwidgetcommand", // used for mods adding custom HUDs
+    "ui_addhud",
+    "ui_removehud",
+    "echo", // to print stuff client-side
+
+    //
+    // Sounds
+    //==========
+    "tmstart",
+    "tmstartloop",
+    "tmstop",
+    "tmvolume",
+    "play",
+    "playmp3",
+    "stopmp3",
+
+    //
+    // Misc
+    //==========
+    "primarydmweapon",
+    "wait",
+    "+moveup", // workaround for mods that want to prevent inactivity when handling the spectate
+    "-moveup",
+    "screenshot",
+    "screenshotJPEG",
+    "levelshot",
+    "`stufftext" // Stufftext detection from Reborn, the player gets kicked without it
+};
+
+//
+// List of commands allowed to be executed locally
+// (when the client also runs the server)
+//
+static const char *whiteListedLocalServerCommands[] = {
+    // Used by briefings
+    "spmap",
+    "map",
+    "disconnect",
+
+    "cinematic",
+    "showmenu",
+    "hidemenu"
+};
+
+/*
+====================
+CG_IsVariableAllowed
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsVariableAllowed(const char *name)
+{
+    size_t i;
+
+    for (i = 0; i < ARRAY_LEN(whiteListedVariables); i++) {
+        if (!Q_stricmp(name, whiteListedVariables[i])) {
+            return qtrue;
+        }
+    }
+
+    if (cgs.localServer) {
+        for (i = 0; i < ARRAY_LEN(whiteListedLocalServerVariables); i++) {
+            if (!Q_stricmp(name, whiteListedLocalServerVariables[i])) {
+                return qtrue;
+            }
+        }
+    }
+
+    // Filtered
+    return qfalse;
+}
+
+/*
+====================
+CG_IsSetVariableFiltered
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsSetVariableAllowed(const char *name, char type)
+{
+    cvar_t *var;
+
+    if (CG_IsVariableAllowed(name)) {
+        return qtrue;
+    }
+
+    if (type != 'a' && type != 's') {
+        // Only allow ephemeral or userinfo variables
+
+        var = cgi.Cvar_Find(name);
+        if (!var) {
+            // Allow as it doesn't exist
+            return qtrue;
+        }
+
+        if (var->flags & CVAR_USER_CREATED) {
+            // Allow, it's user-created, wouldn't cause issues
+            return qtrue;
+        }
+    }
+
+    // Filtered
+    return qfalse;
+}
+
+/*
+====================
+CG_IsCommandAllowed
+
+Returns whether or not the variable should be filtered
+====================
+*/
+static qboolean CG_IsCommandAllowed(const char *name)
+{
+    size_t  i;
+    cvar_t *var;
+
+    for (i = 0; i < ARRAY_LEN(whiteListedCommands); i++) {
+        if (!Q_stricmp(name, whiteListedCommands[i])) {
+            return qtrue;
+        }
+    }
+
+    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 qtrue;
+            }
+        }
+    }
+
+    //
+    // Test variables
+    //
+    if (CG_IsVariableAllowed(name)) {
+        return qtrue;
+    }
+
+    var = cgi.Cvar_Find(name);
+    if (var && (var->flags & CVAR_USER_CREATED)) {
+        // Allow, it's user-created, wouldn't cause issues
+        return qtrue;
+    }
+
+    return qfalse;
+}
+
+/*
+====================
+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_IsStatementAllowed
+
+Returns whether or not the statement is filtered
+====================
+*/
+qboolean CG_IsStatementAllowed(char *cmd)
+{
+    char    *parsed;
+    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") || !Q_stricmp(com_token, "append")) {
+            char type;
+
+            if (Q_stricmp(com_token, "append")) {
+                type = com_token[3];
+            } else {
+                type = 0;
+            }
+
+            //
+            // variable
+            //
+            Q_strncpyz(com_token, COM_ParseExt(&parsed, qfalse), sizeof(com_token));
+            bNextStatement |= RemoveEndToken(com_token);
+            if (com_token[0] == ';') {
+                continue;
+            }
+
+            if (!CG_IsSetVariableAllowed(com_token, type)) {
+                return qfalse;
+            }
+        } else {
+            //
+            // normal command
+            //
+            if (!CG_IsCommandAllowed(com_token)) {
+                return qfalse;
+            }
+        }
+
+        if (!bNextStatement) {
+            // Skip up to the next statement
+            while (parsed && parsed[0]) {
+                char c = parsed[0];
+
+                parsed++;
+                if (c == '\n' || c == ';') {
+                    break;
+                }
+            }
+        }
+    }
+
+    return qtrue;
+}

code/cgame/cg_servercmds_filter.h

@@ -0,0 +1,45 @@
+/*
+===========================================================================
+Copyright (C) 2025 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
+===========================================================================
+*/
+
+// DESCRIPTION:
+// cg_servercmds_filter.h -- filtered server commands
+
+#pragma once
+
+#include "cg_local.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Determines whether or not the full statement is allowed.
+ * The statement will be allowed if conditions are met:
+ *  - Contains a whitelisted command
+ *  - Trying to set a whitelisted variable
+ *  - Trying to set variable that doesn't exist (user created variables)
+ */
+qboolean CG_IsStatementAllowed(char *cmd);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -95,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";
@@ -512,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;
                 }
 
@@ -1194,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;
+    }
 }
 
 //===============
@@ -110,10 +131,10 @@ void ClientGameCommandManager::FreeAllTempModels(void)
 //===============
 void ClientGameCommandManager::FreeSomeTempModels(void)
 {
-    ctempmodel_t* model;
-    int count = 0;
-    unsigned int i;
-    unsigned int numToFree;
+    ctempmodel_t *model;
+    int           count = 0;
+    unsigned int  i;
+    unsigned int  numToFree;
 
     if (!m_free_tempmodels) {
         return;
@@ -138,10 +159,10 @@ void ClientGameCommandManager::FreeSomeTempModels(void)
 //===============
 // FreeSpawnthing
 //===============
-void ClientGameCommandManager::FreeSpawnthing(spawnthing_t* sp)
+void ClientGameCommandManager::FreeSpawnthing(spawnthing_t *sp)
 {
-    ctempmodel_t* model;
-    ctempmodel_t* prev;
+    ctempmodel_t *model;
+    ctempmodel_t *prev;
 
     if (sp->numtempmodels) {
         for (model = m_active_tempmodels.prev; model != &m_active_tempmodels; model = prev) {
@@ -178,7 +199,7 @@ void ClientGameCommandManager::ResetTempModels(void)
 }
 
 static int lastTempModelFrameTime = 0;
-int next_tempmodel_warning = 0;
+int        next_tempmodel_warning = 0;
 
 void CG_ResetTempModels(void)
 {
@@ -207,11 +228,16 @@ void ClientGameCommandManager::InitializeTempModels(void)
 
 void ClientGameCommandManager::InitializeTempModelCvars(void)
 {
-    cg_showtempmodels     = cgi.Cvar_Get("cg_showtempmodels", "0", 0);
-    cg_detail             = cgi.Cvar_Get("detail", "1", CVAR_ARCHIVE);
-    cg_effectdetail       = cgi.Cvar_Get("cg_effectdetail", "0.2", CVAR_ARCHIVE);
+    cg_showtempmodels = cgi.Cvar_Get("cg_showtempmodels", "0", 0);
+    cg_detail         = cgi.Cvar_Get("detail", "1", CVAR_ARCHIVE);
+
+    cg_effectdetail = cgi.Cvar_Get("cg_effectdetail", "0.2", CVAR_ARCHIVE);
+    cgi.Cvar_CheckRange(cg_effectdetail, 0.2, 1.0, qfalse);
+
     cg_effect_physicsrate = cgi.Cvar_Get("cg_effect_physicsrate", "10", CVAR_ARCHIVE);
     cg_max_tempmodels     = cgi.Cvar_Get("cg_max_tempmodels", "1100", CVAR_ARCHIVE);
+    cgi.Cvar_CheckRange(cg_max_tempmodels, 200, MAX_TEMPMODELS, qtrue);
+
     cg_reserve_tempmodels = cgi.Cvar_Get("cg_reserve_tempmodels", "200", CVAR_ARCHIVE);
 
     if (cg_max_tempmodels->integer > MAX_TEMPMODELS) {
@@ -232,9 +258,9 @@ void ClientGameCommandManager::InitializeTempModelCvars(void)
 //===============
 void ClientGameCommandManager::AnimateTempModel(ctempmodel_t *p, Vector origin, refEntity_t *newEnt)
 {
-    int numframes;
-    int deltatime;
-    int frametime;
+    int   numframes;
+    int   deltatime;
+    int   frametime;
     float prev;
 
     // This code is for animating tempmodels that are spawned from the client
@@ -418,9 +444,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
@@ -468,16 +496,16 @@ void ClientGameCommandManager::OtherTempModelEffects(ctempmodel_t *p, Vector ori
     if (p->number != -1) {
         refEntity_t *old_entity;
         dtiki_t     *old_tiki;
-        int         oldnum;
-        float       oldscale;
+        int          oldnum;
+        float        oldscale;
 
         // Set the axis
         AnglesToAxis(p->cgd.angles, axis);
 
         old_entity = current_entity;
-        old_tiki = current_tiki;
-        oldnum = current_entity_number;
-        oldscale = current_scale;
+        old_tiki   = current_tiki;
+        oldnum     = current_entity_number;
+        oldscale   = current_scale;
 
         current_scale         = newEnt->scale;
         current_entity        = newEnt;
@@ -502,7 +530,7 @@ void ClientGameCommandManager::OtherTempModelEffects(ctempmodel_t *p, Vector ori
 
     if (p->cgd.flags2 & T2_ALIGNSTRETCH) {
         Vector vDelta;
-        float fScale;
+        float  fScale;
 
         vDelta = p->cgd.origin - p->cgd.oldorigin;
         fScale = vDelta.length() * p->cgd.scale2;
@@ -518,6 +546,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);
@@ -538,8 +567,8 @@ qboolean ClientGameCommandManager::TempModelPhysics(ctempmodel_t *p, float ftime
 
     // If linked to the parent or hardlinked, get the parent's origin
     if ((p->cgd.flags & (T_PARENTLINK | T_HARDLINK)) && (p->cgd.parent != ENTITYNUM_NONE)) {
-        centity_t* pc;
-        refEntity_t* e;
+        centity_t   *pc;
+        refEntity_t *e;
 
         pc = &cg_entities[p->cgd.parent];
         if (!pc->currentValid) {
@@ -553,8 +582,7 @@ qboolean ClientGameCommandManager::TempModelPhysics(ctempmodel_t *p, float ftime
 
         parentOrigin = e->origin;
         vectoangles(e->axis[0], parentAngles);
-    }
-    else if (p->cgd.flags & T_SWARM) {
+    } else if (p->cgd.flags & T_SWARM) {
         p->cgd.parentOrigin = p->cgd.velocity + p->cgd.accel * ftime * scale;
     }
 
@@ -633,9 +661,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 +676,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;
@@ -829,10 +895,11 @@ void ClientGameCommandManager::AddTempModels(void)
     refEntity_t  *old_ent;
 
     // To counteract cg.time going backwards
-    if (lastTempModelFrameTime && ((cg.time < lastTempModelFrameTime) || (cg.time - lastTempModelFrameTime > TOO_MUCH_TIME_PASSED))) {
+    if (lastTempModelFrameTime
+        && ((cg.time < lastTempModelFrameTime) || (cg.time - lastTempModelFrameTime > TOO_MUCH_TIME_PASSED))) {
         p = m_active_tempmodels.prev;
         for (; p != &m_active_tempmodels; p = next) {
-            next = p->prev;
+            next               = p->prev;
             p->lastPhysicsTime = cg.time;
         }
         lastTempModelFrameTime = cg.time;
@@ -913,7 +980,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;
@@ -927,7 +999,7 @@ void ClientGameCommandManager::AddTempModels(void)
         // Run physics if the lastEnt is not valid to get a valid lerp
         if (!p->lastEntValid) {
             float t;
-            t  = physics_rate / 1000.0f;
+            t = physics_rate / 1000.0f;
 
             ret = TempModelPhysics(p, t, scale);
             if (!ret) {
@@ -1113,7 +1185,7 @@ void ClientGameCommandManager::SpawnTempModel(int mcount)
         if (m_spawnthing->cgd.flags & T_WAVE) {
             p->m_spawnthing = m_spawnthing;
             m_spawnthing->numtempmodels++;
-            start           = Vector(0, 0, 0);
+            start = Vector(0, 0, 0);
         } else {
             p->m_spawnthing = NULL;
             start           = m_spawnthing->cgd.origin;
@@ -1137,7 +1209,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);
@@ -1390,7 +1468,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
@@ -1424,18 +1502,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;
             }
@@ -1446,20 +1521,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;
     }
@@ -119,7 +120,7 @@ void CG_MessageSingleClient_f(void)
 
         // copy the rest
         for (i = 2; i < cgi.Argc(); i++) {
-            sString += va("%s", cgi.Argv(i));
+            sString += va(" %s", cgi.Argv(i));
         }
 
         sString += "\n";
@@ -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);
@@ -289,7 +290,13 @@ void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition)
                 VectorMA(origin, oHead.origin[i], mat[i], origin);
             }
 
-            cg.refdefViewAngles[2] += cg.predicted_player_state.fLeanAngle * 0.3;
+            if (cg_target_game >= TG_MOHTA) {
+                // Changed in 2.0
+                //  Slight less angle
+                cg.refdefViewAngles[2] += cg.predicted_player_state.fLeanAngle * 0.2;
+            } else {
+                cg.refdefViewAngles[2] += cg.predicted_player_state.fLeanAngle * 0.3;
+            }
         }
     } else {
         cgi.DPrintf("CG_OffsetFirstPersonView warning: Couldn't find 'eyes bone' for player\n");
@@ -297,6 +304,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) && !(cg.predicted_player_state.pm_flags & PMF_NO_MOVE))) {
+        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 +383,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 +462,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);
@@ -475,9 +491,16 @@ static int CG_CalcFov(void)
     int   contents;
     float fov_x, fov_y;
     int   inwater;
+    float fov_ratio;
 
-    fov_x = cg.camera_fov;
-    x     = cg.refdef.width / tan(fov_x / 360 * M_PI);
+    fov_ratio = (float)cg.refdef.width / (float)cg.refdef.height * (3.0 / 4.0);
+    if (fov_ratio == 1) {
+        fov_x = cg.camera_fov;
+    } else {
+        fov_x = RAD2DEG(atan(tan(DEG2RAD(cg.camera_fov / 2.0)) * fov_ratio)) * 2.0;
+    }
+
+    x = cg.refdef.width / tan(fov_x / 360 * M_PI);
     fov_y = atan2(cg.refdef.height, x);
     fov_y = fov_y * 360 / M_PI;
 
@@ -565,6 +588,8 @@ static int CG_CalcViewValues(void)
     VectorCopy(ps->origin, cg.refdef.vieworg);
     VectorCopy(ps->viewangles, cg.refdefViewAngles);
 
+    cg.refdefViewAngles[2] += ps->fLeanAngle * 0.1;
+
     if (cg.snap->ps.stats[STAT_HEALTH] > 0) {
         VectorSubtract(cg.refdefViewAngles, cg.predicted_player_state.damage_angles, cg.refdefViewAngles);
         cg.refdefViewAngles[0] += cg.viewkick[0];
@@ -712,7 +737,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) {
@@ -800,6 +855,15 @@ void CG_DrawActiveFrame(int serverTime, int frameTime, stereoFrame_t stereoView,
         // no entities should be marked as interpolating
     }
 
+    //
+    // Added in OPM
+    //  Clamp the fov to avoid artifacts
+    if (cg_fov->value < 65) {
+        cgi.Cvar_Set("cg_fov", "65");
+    } else if (cg_fov->value > 120) {
+        cgi.Cvar_Set("cg_fov", "120");
+    }
+
     // update cg.predicted_player_state
     CG_PredictPlayerState();
 
@@ -871,13 +935,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 {
@@ -885,28 +949,39 @@ 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);
                 }
             }
         }
 
         cg.bIntermissionDisplay = qfalse;
+    } else {
+        // Added in OPM
+        //  In vanilla, scores are updated because when pressing a key,
+        //  it is sent every frame.
+        //  In OPM, an event for a key is sent only once, even when it's being held.
+        if (cgs.gametype != GT_SINGLE_PLAYER && cg.showScores) {
+            CG_ScoresDown_f();
+        }
     }
 
+    // Added in OPM
+    CG_ProcessPlayerModel();
+
     // build the render lists
     if (!cg.hyperspace) {
         CG_AddPacketEntities(); // after calcViewValues, so predicted player state is correct

code/cgame/cg_viewmodelanim.c

@@ -351,7 +351,7 @@ 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;
@@ -359,7 +359,7 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
     }
 
     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) {
@@ -428,7 +428,7 @@ void CG_ViewModelAnimation(refEntity_t *pModel)
             break;
         }
 
-        sprintf(szAnimName, "%s_%s", AnimPrefixList[iAnimPrefixIndex], pszAnimSuffix);
+        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);

code/cgame/cg_volumetricsmoke.cpp

@@ -209,7 +209,7 @@ void ClientGameCommandManager::ResetVSSSources()
 
 void ClientGameCommandManager::ResetVSSSources(Event *ev)
 {
-    // FIXME: stub??
+    ResetVSSSources();
 }
 
 void CG_ResetVSSSources()
@@ -289,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
@@ -315,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,
@@ -363,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++) {
@@ -624,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++) {
@@ -643,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];
@@ -746,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;
             }
@@ -777,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;
 
@@ -799,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());
@@ -808,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;
@@ -830,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());
@@ -841,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++) {
@@ -874,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);
         }
@@ -1225,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) {
@@ -1240,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;
                 }
@@ -1265,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;
             }
@@ -1338,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/client/CMakeLists.txt

@@ -1,26 +1,29 @@
-cmake_minimum_required(VERSION 3.5)
-project(omohclient)
+cmake_minimum_required(VERSION 3.12)
 
-option(NO_OPENAL "Use older sound-system" FALSE)
+project(omohclient)
 
 add_subdirectory("../cgame" "./cgame")
 
 file(GLOB SOURCES_CLIENT "./*.c*")
 file(GLOB_RECURSE SOURCES_UILIB "../uilib/*.c*")
 
+set(SOURCES_CLIENT ${SOURCES_CLIENT}
+	# Gamespy
+	"${CMAKE_SOURCE_DIR}/code/gamespy/cl_gamespy.c"
+)
+
 # Made as an interface and not static, as static only links used methods
 add_library(omohclient INTERFACE)
 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)
+target_link_libraries(omohclient INTERFACE omohsdl_client)
 target_link_libraries(omohclient INTERFACE gcd)
 
 # Sound stuff
 target_compile_definitions(omohclient INTERFACE USE_CODEC_MP3)
 
-if (NOT NO_OPENAL)
+if (NOT NO_MODERN_DMA)
 	# Use OpenAL
 	find_package(OpenAL REQUIRED)
 
@@ -31,7 +34,13 @@ if (NOT NO_OPENAL)
 		else()
 			target_include_directories(omohclient INTERFACE ${OPENAL_INCLUDE_DIR})
 		endif()
-		target_link_libraries(omohclient INTERFACE ${OPENAL_LIBRARY})
+
+		if(NOT USE_SYSTEM_LIBS)
+			target_compile_definitions(omohclient INTERFACE USE_OPENAL_DLOPEN=1)
+		else()
+			# Link against system OpenAL
+			target_link_libraries(omohclient INTERFACE OpenAL::OpenAL)
+		endif()
 	endif()
 
 	list(FILTER SOURCES_CLIENT EXCLUDE REGEX "./snd_([a-zA-Z0-9_]+)\.c$")
@@ -52,18 +61,24 @@ endif()
 
 set(OLD_VALUE ${BUILD_SHARED_LIBS})
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-add_subdirectory("../libmad" "./libmad" EXCLUDE_FROM_ALL)
-target_link_libraries(omohclient INTERFACE mad)
-set(BUILD_SHARED_LIBS ${OLD_VALUE} CACHE BOOL "" FORCE)
 
-if (USE_OPENAL)
-	# Try to use OpenAL
-	find_package(OpenAL)
-	if (OPENAL_FOUND)
-		target_compile_definitions(omohclient INTERFACE USE_OPENAL=1)
-		target_include_directories(omohclient INTERFACE ${OPENAL_INCLUDE_DIR}/AL)
-		target_link_libraries(omohclient INTERFACE ${OPENAL_LIBRARY})
-	endif()
+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_cgame.cpp

@@ -248,21 +248,23 @@ qboolean	CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
 	if (snapshot->numEntities != count) {
 		Com_DPrintf("CL_GetSnapshot: Not all children could find their parents.\n");
 
-		for (i = count; i < snapshot->numEntities; i++)
+		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;
+					parents[s1->number] = -2;
+				}
 			}
 		}
 	}
@@ -625,7 +627,9 @@ 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->Cvar_CheckRange				= Cvar_CheckRange;
 
 	cgi->Argc							= Cmd_Argc;
 	cgi->Args							= Cmd_Args;
@@ -769,7 +773,9 @@ 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->UI_GetHighResolutionScale  = UI_GetHighResolutionScale;
 	cgi->Key_StringToKeynum			= Key_StringToKeynum;
 	cgi->Key_KeynumToBindString		= Key_KeynumToBindString;
 	cgi->Key_GetKeysForCommand		= Key_GetKeysForCommand;
@@ -918,7 +924,13 @@ void CL_InitCGame( void ) {
 	// find the current mapname
 	info = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ];
 	mapname = Info_ValueForKey( info, "mapname" );
-	Com_sprintf( cl.mapname, sizeof( cl.mapname ), "maps/%s.bsp", mapname );
+
+	if (CL_UseLargeLightmap(mapname)) {
+		Com_sprintf(cl.mapname, sizeof(cl.mapname), "maps/%s.bsp", mapname);
+	} else {
+		// Added in 2.0
+		Com_sprintf(cl.mapname, sizeof(cl.mapname), "maps/%s_sml.bsp", mapname);
+	}
 
 	S_BeginRegistration();
 	CL_ShutdownCGame();
@@ -933,10 +945,17 @@ void CL_InitCGame( void ) {
 		CL_InitClientSavedData();
 	}
 
-	// init for this gamestate
-	// use the lastExecutedServerCommand instead of the serverCommandSequence
-	// otherwise server commands sent just before a gamestate are dropped
-	cge->CG_Init( &cgi, clc.serverMessageSequence, clc.lastExecutedServerCommand, clc.clientNum );
+	if (cl.snap.valid) {
+		// init for this gamestate
+		// use the lastExecutedServerCommand instead of the serverCommandSequence
+		// otherwise server commands sent just before a gamestate are dropped
+		cge->CG_Init(&cgi, clc.serverMessageSequence, clc.lastExecutedServerCommand, clc.clientNum);
+	} else {
+		// executing client commands from previous map/server might be an issue, some commands might be cs commands,
+		// like old CS_SYSTEMINFO configstrings which still contain the sv_serverId from previous map.
+		// It would cause the client to lose the game state number
+		cge->CG_Init(&cgi, clc.serverMessageSequence, clc.serverCommandSequence, clc.clientNum);
+	}
 
 	ClearNewConfigFlag();
 	TIKI_FinishLoad();
@@ -1111,6 +1130,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;
@@ -1161,7 +1216,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
@@ -1091,8 +1102,6 @@ static void RoQReset( void ) {
 
 static void RoQInterrupt(void)
 {
-	// Removed in OPM
-#if 0
 	byte				*framedata;
         short		sbuf[32768];
         int		ssize;
@@ -1144,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;
@@ -1216,7 +1221,6 @@ redump:
 //	assert(cinTable[currentHandle].RoQFrameSize <= 65536);
 //	r = FS_Read( cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile );
 	cinTable[currentHandle].RoQPlayed	+= cinTable[currentHandle].RoQFrameSize+8;
-#endif
 }
 
 /******************************************************************************
@@ -1229,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;
 
@@ -1276,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
@@ -1289,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", "");
+    }
 }
 
 /*
@@ -1331,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;
 
@@ -1360,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;
@@ -1400,9 +1455,6 @@ CIN_PlayCinematic
 ==================
 */
 int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBits ) {
-	return 0;
-	// Removed in OPM
-#if 0
 	unsigned short RoQID;
 	char	name[MAX_OSPATH];
 	int		i;
@@ -1428,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);
@@ -1474,17 +1526,12 @@ 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");
 
 	RoQShutdown();
 	return -1;
-#endif
 }
 
 void CIN_SetExtents (int handle, int x, int y, int w, int h) {
@@ -1600,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);
 }
 
 
@@ -1646,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]);}
@@ -453,6 +471,33 @@ void CL_JoystickEvent( int axis, int value, int time ) {
 	cl.joystickAxis[axis] = value;
 }
 
+/*
+=================
+CL_UpdateMouse
+
+Added in OPM
+Update mouse position with absolute position (relative to the window)
+when the UI catcher is active.
+=================
+*/
+void CL_UpdateMouse() {
+    if (!(Key_GetCatcher() & KEYCATCH_UI)) {
+        return;
+    }
+
+    if (IN_IsCursorActive()) {
+        // If it's grabbed, don't use absolute position
+        return;
+    }
+
+    if (com_unfocused->integer) {
+        // Ignore updates when unfocused
+        return;
+    }
+
+    IN_GetMousePosition(&cl.mousex, &cl.mousey);
+}
+
 /*
 =================
 CL_JoystickMove
@@ -461,6 +506,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 +523,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 +624,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);
@@ -617,8 +678,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;
 	}
 
@@ -726,6 +787,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 ) {
@@ -826,8 +893,8 @@ qboolean CL_ReadyToSendPacket( void ) {
 	}
 
 	// check for exceeding cl_maxpackets
-	if ( cl_maxpackets->integer < 15 ) {
-		Cvar_Set( "cl_maxpackets", "15" );
+	if ( cl_maxpackets->integer < 30 ) {
+		Cvar_Set( "cl_maxpackets", "30" );
 	} else if ( cl_maxpackets->integer > 125 ) {
 		Cvar_Set( "cl_maxpackets", "125" );
 	}
@@ -917,6 +984,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 );
@@ -973,16 +1092,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 );
-	}
 }
 
 /*
@@ -1094,6 +1203,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_instantAction.cpp

@@ -0,0 +1,640 @@
+/*
+===========================================================================
+Copyright (C) 2025 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_instantAction.h"
+#include "cl_uiserverlist.h"
+#include "../gamespy/sv_gamespy.h"
+
+Event EV_UIInstantAction_AcceptServer
+(
+    "acceptserver",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Connect to the current server"
+);
+
+Event EV_UIInstantAction_RejectServer
+(
+    "rejectserver",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Reject the current server"
+);
+
+Event EV_UIInstantAction_Cancel
+(
+    "ia_cancel",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "cancel the server update"
+);
+
+Event EV_UIInstantAction_Refresh
+(
+    "ia_refresh",
+    EV_DEFAULT,
+    NULL,
+    NULL,
+    "Refresh the server list"
+);
+
+CLASS_DECLARATION(UIWidget, UIInstantAction, NULL) {
+    {&EV_UIInstantAction_AcceptServer, &UIInstantAction::Connect      },
+    {&EV_UIInstantAction_RejectServer, &UIInstantAction::Reject       },
+    {&EV_UIInstantAction_Cancel,       &UIInstantAction::CancelRefresh},
+    {&EV_UIInstantAction_Refresh,      &UIInstantAction::Refresh      },
+    {NULL,                             NULL                           }
+};
+
+struct ServerListInstance {
+    int              iServerType;
+    UIInstantAction *pServerList;
+};
+
+ServerListInstance g_IAServerListInst[2];
+
+UIInstantAction::UIInstantAction()
+{
+    state           = IA_INITIALIZE;
+    numFoundServers = 0;
+    numServers      = 0;
+    minPlayers      = 3;
+    startingMaxPing = 100;
+    endingMaxPing   = 1500;
+    maxServers      = -1;
+    servers         = NULL;
+    doneList[0]     = false;
+    doneList[1]     = false;
+    serverList[0]   = NULL;
+    serverList[1]   = NULL;
+
+    ReadIniFile();
+    EnableServerInfo(false);
+
+    menuManager.PassEventToWidget("ia_cancel_button", new Event(EV_Widget_Disable));
+    menuManager.PassEventToWidget("ia_refresh_button", new Event(EV_Widget_Disable));
+}
+
+UIInstantAction::~UIInstantAction()
+{
+    CleanUp();
+}
+
+void UIInstantAction::CleanUp()
+{
+    if (serverList[0]) {
+        ServerListFree(serverList[0]);
+        serverList[0] = NULL;
+    }
+
+    if (serverList[1]) {
+        ServerListFree(serverList[1]);
+        serverList[1] = NULL;
+    }
+
+    if (servers) {
+        delete[] servers;
+        servers = NULL;
+    }
+}
+
+void UIInstantAction::Init()
+{
+    const char *secret_key;
+    const char *game_name;
+
+    static const unsigned int iNumConcurrent = 10;
+
+    numFoundServers = 0;
+    numServers      = 0;
+    doneList[0]     = false;
+    doneList[1]     = false;
+
+    EnableServerInfo(false);
+
+    menuManager.PassEventToWidget("ia_cancel_button", new Event(EV_Widget_Disable));
+    menuManager.PassEventToWidget("ia_refresh_button", new Event(EV_Widget_Disable));
+    menuManager.PassEventToWidget("ia_noserverfound", new Event(EV_Widget_Disable));
+
+    Cvar_Set("ia_search_percentage", va("%d %%", 0));
+
+    if (com_target_game->integer < target_game_e::TG_MOHTT) {
+        g_IAServerListInst[0].iServerType = com_target_game->integer;
+        g_IAServerListInst[0].pServerList = this;
+
+        game_name  = GS_GetGameName(com_target_game->integer);
+        secret_key = GS_GetGameKey(com_target_game->integer);
+
+        serverList[0] = ServerListNew(
+            game_name,
+            game_name,
+            secret_key,
+            iNumConcurrent,
+            (void *)&IAServerListCallBack,
+            1,
+            (void *)&g_IAServerListInst[0]
+        );
+
+        ServerListClear(serverList[0]);
+    } else {
+        g_IAServerListInst[0].iServerType = target_game_e::TG_MOHTT;
+        g_IAServerListInst[0].pServerList = this;
+
+        game_name  = GS_GetGameName(target_game_e::TG_MOHTT);
+        secret_key = GS_GetGameKey(target_game_e::TG_MOHTT);
+
+        serverList[0] = ServerListNew(
+            game_name,
+            game_name,
+            secret_key,
+            iNumConcurrent,
+            (void *)&IAServerListCallBack,
+            1,
+            (void *)&g_IAServerListInst[0]
+        );
+
+        ServerListClear(serverList[0]);
+
+        g_IAServerListInst[1].iServerType = target_game_e::TG_MOHTA;
+        g_IAServerListInst[1].pServerList = this;
+
+        game_name  = GS_GetGameName(target_game_e::TG_MOHTA);
+        secret_key = GS_GetGameKey(target_game_e::TG_MOHTA);
+
+        serverList[1] = ServerListNew(
+            game_name,
+            game_name,
+            secret_key,
+            iNumConcurrent,
+            (void *)&IAServerListCallBack,
+            1,
+            (void *)&g_IAServerListInst[1]
+        );
+
+        ServerListClear(serverList[1]);
+    }
+
+    state           = IA_WAITING;
+    numFoundServers = 0;
+
+    ServerListUpdate(serverList[0], true);
+
+    if (serverList[1]) {
+        ServerListUpdate(serverList[1], true);
+    }
+
+    menuManager.PassEventToWidget("ia_cancel_button", new Event(EV_Widget_Enable));
+    menuManager.PassEventToWidget("searchstatus", new Event(EV_Widget_Enable));
+    menuManager.PassEventToWidget("searchstatuslable", new Event(EV_Widget_Enable));
+}
+
+int UIInstantAction::GetServerIndex(int maxPing, int gameType)
+{
+    int bestPing   = 1500;
+    int bestServer = -1;
+    int i;
+
+    for (i = 0; i < numFoundServers; i++) {
+        const IAServer_t& IAServer = servers[i];
+
+        char *gameVer;
+        float fGameVer;
+        int   ping;
+        int   numPlayers;
+
+        if (IAServer.rejected) {
+            continue;
+        }
+
+        // Skip servers that don't match the provided game type
+        if (ServerGetIntValue(IAServer.server, "g_gametype_i", 1) != gameType) {
+            continue;
+        }
+
+        // Skip servers with high ping
+        ping = ServerGetPing(IAServer.server);
+        if (ping > maxPing) {
+            continue;
+        }
+
+        gameVer = ServerGetStringValue(IAServer.server, "gamever", "1.00");
+        if (com_target_demo->integer && *gameVer != 'd') {
+            // Skip retail servers on demo game
+            continue;
+        } else if (!com_target_demo->integer && *gameVer == 'd') {
+            // Skip demo servers on retail game
+            continue;
+        }
+
+        // Skip incompatible servers
+        fGameVer = atof(gameVer);
+        if (com_target_game->integer >= target_game_e::TG_MOHTT) {
+            if (IAServer.serverGame.serverType == target_game_e::TG_MOHTT) {
+                if (fabs(fGameVer) < 2.3f) {
+                    continue;
+                }
+            } else {
+                if (fabs(fGameVer) < 2.1f) {
+                    continue;
+                }
+            }
+        } else {
+            if (fabs(fGameVer - com_target_shortversion->value) > 0.1f) {
+                continue;
+            }
+        }
+
+        // Skip servers with a password
+        if (ServerGetIntValue(IAServer.server, "password", 0)) {
+            continue;
+        }
+
+        // Skip servers that don't match the minimum number of players
+        numPlayers = ServerGetIntValue(IAServer.server, "numplayers", 0);
+        if (numPlayers < minPlayers) {
+            continue;
+        }
+
+        // Skip full servers
+        if (numPlayers == ServerGetIntValue(IAServer.server, "maxplayers", 0)) {
+            continue;
+        }
+
+        // Skip servers with an higher ping than the best one
+        if (ping >= bestPing) {
+            continue;
+        }
+
+        //
+        // Found a potential server
+        //
+
+        bestPing   = ping;
+        bestServer = i;
+    }
+
+    return bestServer;
+}
+
+void UIInstantAction::ReadIniFile()
+{
+    char       *buffer;
+    const char *p;
+    const char *pVal;
+    int         intValue;
+    char        value[32];
+
+    if (!FS_ReadFileEx("iaction.ini", (void **)&buffer, qtrue)) {
+        return;
+    }
+
+    for (p = buffer; p; p = strstr(pVal, "\n")) {
+        if (sscanf(p, "%31s", value) != 1) {
+            break;
+        }
+
+        pVal = strstr(p, "=");
+        if (!pVal) {
+            break;
+        }
+
+        pVal++;
+
+        if (sscanf(pVal, "%d", &intValue) != 1) {
+            break;
+        }
+
+        if (!Q_stricmpn(value, "MinPlayers", 10)) {
+            minPlayers = intValue;
+        }
+
+        if (!Q_stricmpn(value, "StartingMaxPing", 15)) {
+            startingMaxPing = intValue;
+        }
+
+        if (!Q_stricmpn(value, "EndingMaxPing", 13)) {
+            endingMaxPing = intValue;
+        }
+
+        if (!Q_stricmpn(value, "MaxServers", 10)) {
+            maxServers = intValue;
+        }
+    }
+}
+
+void UIInstantAction::FindServer()
+{
+    int ping;
+    int i;
+
+    currentServer = -1;
+    state         = IA_NONE;
+
+    for (ping = startingMaxPing; ping < endingMaxPing; ping += 100) {
+        //
+        // Find the best server starting from FFA gametype first
+        //
+        for (i = 1; i < 7; i++) {
+            currentServer = GetServerIndex(ping, i);
+            if (currentServer >= 0) {
+                break;
+            }
+        }
+
+        if (currentServer >= 0) {
+            break;
+        }
+    }
+
+    menuManager.PassEventToWidget("ia_refresh_button", new Event(EV_Widget_Enable));
+    menuManager.PassEventToWidget("ia_cancel_button", new Event(EV_Widget_Disable));
+    menuManager.PassEventToWidget("searchstatus", new Event(EV_Widget_Disable));
+    menuManager.PassEventToWidget("searchstatuslable", new Event(EV_Widget_Disable));
+
+    if (currentServer < 0) {
+        EnableServerInfo(false);
+
+        menuManager.PassEventToWidget("ia_noserverfound", new Event(EV_Widget_Enable));
+        return;
+    }
+
+    const IAServer_t& IAServer   = servers[currentServer];
+    const char       *hostname   = ServerGetStringValue(IAServer.server, "hostname", "(NONE)");
+    const char       *gametype   = ServerGetStringValue(IAServer.server, "gametype", "(NONE)");
+    int               numplayers = ServerGetIntValue(IAServer.server, "numplayers", 0);
+    int               maxplayers = ServerGetIntValue(IAServer.server, "maxplayers", 0);
+    ping                         = ServerGetPing(IAServer.server);
+
+    Cvar_Set("ia_servername", va("  %s", hostname));
+    Cvar_Set("ia_ping", va("%d", ping));
+    Cvar_Set("ia_gametype", va("%s", gametype));
+    Cvar_Set("ia_players", va("%d", numplayers));
+    Cvar_Set("ia_maxplayers", va("%d", maxplayers));
+
+    EnableServerInfo(true);
+}
+
+void UIInstantAction::Connect(Event *ev)
+{
+    char *gameVer;
+    float fGameVer;
+    bool  bDiffVersion;
+    char  command[256];
+
+    if (currentServer < 0 || currentServer < numServers) {
+        return;
+    }
+
+    const IAServer_t& IAServer = servers[currentServer];
+
+    gameVer = ServerGetStringValue(IAServer.server, "gamever", "1.00");
+    if (gameVer[0] == 'd') {
+        gameVer++;
+    }
+
+    // Skip incompatible servers
+    fGameVer     = atof(gameVer);
+    bDiffVersion = false;
+    if (com_target_game->integer >= target_game_e::TG_MOHTT) {
+        if (IAServer.serverGame.serverType == target_game_e::TG_MOHTT) {
+            if (fabs(fGameVer) < 2.3f) {
+                bDiffVersion = true;
+            }
+        } else {
+            if (fabs(fGameVer) < 2.1f) {
+                bDiffVersion = true;
+            }
+        }
+    } else {
+        if (fabs(fGameVer - com_target_shortversion->value) > 0.1f) {
+            bDiffVersion = true;
+        }
+    }
+
+    if (bDiffVersion) {
+        if (fGameVer - com_target_shortversion->value > 0) {
+            // Older version
+            UI_SetReturnMenuToCurrent();
+            Cvar_Set("com_errormessage", va("Server is version %s, you are using %s", gameVer, "2.40"));
+            UI_PushMenu("wrongversion");
+        } else {
+            // Server version is newer
+            Cvar_Set("dm_serverstatus", va("Can not connect to v%s server, you are using v%s", gameVer, "2.40"));
+        }
+    }
+
+    UI_SetReturnMenuToCurrent();
+    Cvar_Set("g_servertype", va("%d", servers[currentServer].serverGame.serverType));
+
+    Com_sprintf(
+        command,
+        sizeof(command),
+        "connect %s:%i\n",
+        ServerGetAddress(IAServer.server),
+        ServerGetIntValue(IAServer.server, "hostport", PORT_SERVER)
+    );
+    Cbuf_AddText(command);
+}
+
+void UIInstantAction::Reject(Event *ev)
+{
+    servers[currentServer].rejected = 1;
+    FindServer();
+}
+
+void UIInstantAction::Draw()
+{
+    switch (state) {
+    case IA_INITIALIZE:
+        Init();
+        break;
+    case IA_UPDATE:
+        Update();
+        break;
+    case IA_FINISHED:
+        FindServer();
+        break;
+    default:
+        break;
+    }
+
+    if (serverList[0]) {
+        ServerListThink(serverList[0]);
+    }
+
+    if (serverList[1]) {
+        ServerListThink(serverList[1]);
+    }
+}
+
+void UIInstantAction::Update()
+{
+    numFoundServers = 0;
+
+    // count the total number of servers from both server list
+    numServers = ServerListCount(serverList[0]);
+    if (serverList[1]) {
+        numServers += ServerListCount(serverList[1]);
+    }
+
+    state   = IA_FINISHED;
+    servers = new IAServer_t[numServers];
+
+    ServerListHalt(serverList[0]);
+    if (serverList[1]) {
+        ServerListHalt(serverList[1]);
+    }
+
+    ServerListThink(serverList[0]);
+    if (serverList[1]) {
+        ServerListThink(serverList[1]);
+    }
+
+    state = IA_SEARCHING;
+
+    // Start updating the first list
+    doneList[0] = false;
+    ServerListClear(serverList[0]);
+    ServerListUpdate(serverList[0], true);
+
+    // Update the second optional list
+    if (serverList[1]) {
+        doneList[1] = false;
+        ServerListClear(serverList[1]);
+        ServerListUpdate(serverList[1], true);
+    }
+}
+
+int UIInstantAction::AddServer(GServer server, const ServerGame_t& serverGame)
+{
+    servers[numFoundServers].server     = server;
+    servers[numFoundServers].serverGame = serverGame;
+    servers[numFoundServers].rejected   = false;
+    numFoundServers++;
+
+    return numFoundServers;
+}
+
+void UIInstantAction::CancelRefresh(Event *ev)
+{
+    state = IA_FINISHED;
+    ServerListHalt(serverList[0]);
+    ServerListHalt(serverList[1]);
+}
+
+void UIInstantAction::Refresh(Event *ev)
+{
+    state = IA_INITIALIZE;
+}
+
+void UIInstantAction::EnableServerInfo(bool enable)
+{
+    if (enable) {
+        menuManager.PassEventToWidget("iaservername_label", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_servername_field", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_ping_label", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_ping_field", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_gametype_label", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_gametype_field", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_players_label", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_players_field", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_maxplayers_label", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("ia_maxplayers_field", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("acceptserver", new Event(EV_Widget_Enable));
+        menuManager.PassEventToWidget("rejectserver", new Event(EV_Widget_Enable));
+    } else {
+        menuManager.PassEventToWidget("iaservername_label", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_servername_field", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_ping_label", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_ping_field", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_gametype_label", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_gametype_field", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_players_label", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_players_field", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_maxplayers_label", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("ia_maxplayers_field", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("acceptserver", new Event(EV_Widget_Disable));
+        menuManager.PassEventToWidget("rejectserver", new Event(EV_Widget_Disable));
+    }
+}
+
+void UIInstantAction::IAServerListCallBack(GServerList serverlist, int msg, void *instance, void *param1, void *param2)
+{
+    const ServerListInstance *pInstance   = (const ServerListInstance *)instance;
+    UIInstantAction          *pServerList = pInstance->pServerList;
+
+    if (msg == LIST_PROGRESS) {
+        if (pServerList->state == IA_WAITING) {
+            if (pInstance->iServerType == com_target_game->integer) {
+                pServerList->doneList[0] = true;
+            }
+
+            if (com_target_game->integer >= target_game_e::TG_MOHTT && pInstance->iServerType == target_game_e::TG_MOHTA) {
+                pServerList->doneList[1] = true;
+            }
+
+            if (pServerList->doneList[0] && (!pServerList->serverList[1] || pServerList->doneList[1])) {
+                pServerList->state = IA_UPDATE;
+            }
+        } else if (pServerList->state == IA_SEARCHING) {
+            ServerGame_t serverGame;
+            serverGame.serverType = pInstance->iServerType;
+            const int serverIndex = pServerList->AddServer((GServer)param1, serverGame);
+
+            Cvar_Set("ia_search_percentage", va("%d %%", 100 * serverIndex / pServerList->numServers));
+
+            if (pServerList->maxServers >= 0 && serverIndex >= pServerList->maxServers) {
+                // Reached the maximum number of servers, stop there
+                pServerList->doneList[0] = true;
+                ServerListHalt(pServerList->serverList[0]);
+
+                if (pServerList->serverList[1]) {
+                    pServerList->doneList[1] = true;
+                    ServerListHalt(pServerList->serverList[1]);
+                }
+
+                pServerList->state = IA_FINISHED;
+            }
+        }
+    } else if (msg == LIST_STATECHANGED && ServerListState(serverlist) == GServerListState::sl_idle) {
+        if (pInstance->iServerType == com_target_game->integer) {
+            pServerList->doneList[0] = true;
+        }
+
+        if (com_target_game->integer >= target_game_e::TG_MOHTT && pInstance->iServerType == target_game_e::TG_MOHTA) {
+            pServerList->doneList[1] = true;
+        }
+
+        if (pServerList->doneList[0] && (!pServerList->serverList[1] || pServerList->doneList[1])) {
+            if (pServerList->state == IA_WAITING) {
+                pServerList->state = IA_UPDATE;
+            }
+            if (pServerList->state == IA_SEARCHING) {
+                pServerList->state = IA_FINISHED;
+            }
+        }
+    }
+}

code/client/cl_instantAction.h

@@ -0,0 +1,103 @@
+/*
+===========================================================================
+Copyright (C) 2025 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
+===========================================================================
+*/
+
+// Added in 2.30
+//  Instantly find a server matching common criterias
+
+#pragma once
+
+#include "../gamespy/goaceng.h"
+
+typedef struct {
+    int serverType;
+} ServerGame_t;
+
+typedef struct {
+    GServer      server;
+    ServerGame_t serverGame;
+    bool         rejected;
+} IAServer_t;
+
+enum IAState_e {
+    IA_NONE,
+    IA_INITIALIZE,
+    IA_WAITING,
+    IA_UPDATE,
+    IA_SEARCHING,
+    IA_FINISHED
+};
+
+class UIInstantAction : public UIWidget
+{
+public:
+    CLASS_PROTOTYPE(UIInstantAction);
+
+public:
+    UIInstantAction();
+    ~UIInstantAction() override;
+
+    void CleanUp();
+    void Init();
+
+    int  GetServerIndex(int maxPing, int gameType);
+    void ReadIniFile();
+    void FindServer();
+    void Connect(Event *ev);
+    void Reject(Event *ev);
+    void Draw();
+    void Update();
+    int  AddServer(GServer server, const ServerGame_t& serverGame);
+    void CancelRefresh(Event *ev);
+    void Refresh(Event *ev);
+    void EnableServerInfo(bool enable);
+
+private:
+    static void IAServerListCallBack(GServerList serverlist, int msg, void *instance, void *param1, void *param2);
+
+private:
+    //
+    // List
+    //
+    bool        doneList[2];
+    GServerList serverList[2];
+    int         maxServers;
+
+    //
+    // Current states
+    //
+    IAState_e state;
+    int       numServers;
+    int       numFoundServers;
+
+    //
+    // Filters
+    //
+    int minPlayers;
+    int startingMaxPing;
+    int endingMaxPing;
+
+    //
+    // Servers
+    //
+    IAServer_t *servers;
+    int         currentServer;
+};

code/client/cl_invrender.cpp

@@ -148,7 +148,7 @@ void CL_Draw3DModel(
 
             hModel[iCurrNum] = model;
             iIndex[iCurrNum] = -1;
-            strcpy(szAnimName[iCurrNum], anim);
+            Q_strncpyz(szAnimName[iCurrNum], anim, sizeof(szAnimName[iCurrNum]));
         } else {
             iCurrNum = i;
 
@@ -164,7 +164,7 @@ void CL_Draw3DModel(
                 }
             } else {
                 iIndex[iCurrNum] = -1;
-                strcpy(szAnimName[iCurrNum], anim);
+                Q_strncpyz(szAnimName[iCurrNum], anim, sizeof(szAnimName[iCurrNum]));
             }
         }
 
@@ -295,7 +295,7 @@ void UI_DoInventory(qboolean activate_mouse)
     if (client_inv.align == INV_ALIGN_RIGHT) {
         s_main_inv->InitFrame(
             NULL,
-            client_inv.horizoffset + cls.glconfig.vidWidth - client_inv.typewidth,
+            client_inv.horizoffset + uid.vidWidth - client_inv.typewidth,
             client_inv.vertoffset,
             client_inv.typewidth,
             client_inv.typeheight * client_inv.types.NumObjects(),

code/client/cl_keys.cpp

@@ -984,6 +984,8 @@ CL_InitKeyCommands
 */
 void CL_InitKeyCommands(void)
 {
+    int i;
+
     // register our functions
     Cmd_AddCommand("bind", Key_Bind_f);
     Cmd_AddCommand("unbind", Key_Unbind_f);
@@ -997,6 +999,10 @@ void CL_InitKeyCommands(void)
     Cmd_AddCommand("ctrlbindlist", Key_AltBindlist_f);
 
     memset(menubound, 0, sizeof(menubound));
+
+    for (i = K_F1; i <= K_F15; i++) {
+        menubound[i] = qtrue;
+    }
 }
 
 /*
@@ -1089,7 +1095,7 @@ void CL_KeyEvent(int key, qboolean down, unsigned time)
 
     if (clc.state > CA_DISCONNECTED && cge && !Key_GetCatcher() && cge->CG_CheckCaptureKey(key, down, time)
         && key != K_ESCAPE) {
-        if (key == K_CONSOLE || (keys[K_SHIFT].down && key == K_ESCAPE)) {
+        if (key != K_CONSOLE && (!keys[K_SHIFT].down || key != K_ESCAPE)) {
             return;
         }
     }
@@ -1134,9 +1140,9 @@ void CL_KeyEvent(int key, qboolean down, unsigned time)
 
     if (key >= K_MOUSE1 && key <= K_MOUSE5) {
         if (down) {
-            cl.mouseButtons |= (1 << (key + (256 - K_MOUSE1)));
+            cl.mouseButtons |= (1 << (key - K_MOUSE1));
         } else {
-            cl.mouseButtons &= ~(1 << (key + (256 - K_MOUSE1)));
+            cl.mouseButtons &= ~(1 << (key - K_MOUSE1));
         }
 
         if (in_guimouse) {
@@ -1346,5 +1352,5 @@ Key_SetCatcher
 */
 void Key_SetCatcher(int catcher)
 {
-    keyCatchers = catcher;
+    cls.keyCatchers = catcher;
 }

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();
@@ -556,6 +568,7 @@ void CL_ParseGamestate( msg_t *msg ) {
             csNum = CPT_NormalizeConfigstring(i);
             if (csNum < 0 || csNum >= MAX_CONFIGSTRINGS) {
                 Com_Error(ERR_DROP, "configstring > MAX_CONFIGSTRINGS");
+				return;
             }
             s = MSG_ReadScrambledBigString(msg);
             len = strlen(s);
@@ -576,8 +589,7 @@ void CL_ParseGamestate( msg_t *msg ) {
 			//Com_Memset (&nullstate, 0, sizeof(nullstate));
 			MSG_GetNullEntityState(&nullstate);
 			es = &cl.entityBaselines[ newnum ];
-			// FIXME: frametime
-			MSG_ReadDeltaEntity( msg, &nullstate, es, newnum, 0.0);
+			MSG_ReadDeltaEntity( msg, &nullstate, es, newnum, cls.serverFrameTime);
 		} else {
 			Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte %i", cmd );
 		}
@@ -594,16 +606,25 @@ void CL_ParseGamestate( msg_t *msg ) {
 	// stop recording now so the demo won't have an unnecessary level load at the end.
 	if(cl_autoRecordDemo->integer && clc.demorecording)
 		CL_StopRecord_f();
-	
-	// reinitialize the filesystem if the game directory has changed
-	FS_ConditionalRestart( clc.checksumFeed, qfalse );
+
+	if (clc.state == CA_CONNECTED && !Cvar_Get("sv_paks", "", 0)->string[0]) {
+		// Added in 2.30
+		FS_Restart(clc.checksumFeed);
+	} else {
+		// reinitialize the filesystem if the game directory has changed
+		FS_ConditionalRestart(clc.checksumFeed, qfalse);
+	}
 
 	clc.state = CA_LOADING;
     if (!com_sv_running->integer)
     {
         const char *info = cl.gameState.stringData + cl.gameState.stringOffsets[CS_SERVERINFO];
-        UI_ClearState();
-        UI_BeginLoad(Info_ValueForKey(info, "mapname"));
+		const char *mapname = Info_ValueForKey(info, "mapname");
+		// Added in 2.0
+		Cvar_Set("mapname", mapname);
+
+		UI_ClearState();
+        UI_BeginLoad(mapname);
     }
 
 	// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
@@ -784,6 +805,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 +1125,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
@@ -46,15 +47,20 @@ void CL_ShutdownUI(void);
 //
 // general ui stuff
 //
-extern inventory_t client_inv;
-extern bind_t      client_bind;
-extern cvar_t     *cl_greenfps;
-extern qboolean    server_loading;
+extern inventory_t  client_inv;
+extern bind_t       client_bind;
+extern cvar_t      *cl_greenfps;
+extern qboolean     server_loading;
+extern const UColor UWhiteChatMessageColor;
+extern const UColor URedChatMessageColor;
+extern const UColor UGreenChatMessageColor;
 
 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);
+void        UI_GetHighResolutionScale(vec2_t scale);
 
 //
 // menu
@@ -111,6 +117,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_uidmbox.cpp

@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2015 the OpenMoHAA team
+Copyright (C) 2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -21,6 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "cl_ui.h"
+#include "../qcommon/localization.h"
 
 Event EV_DMBox_Goin
 (
@@ -40,126 +41,116 @@ Event EV_DMBox_Decay
 	"Event to make the dmbox console line decay"
 );
 
-static float s_dmboxWidth = 384.0;
+static float s_dmboxWidth   = 384.0;
 static float s_dmboxOffsetX = 3.0f;
 static float s_dmboxOffsetY = 8.0f;
 
-CLASS_DECLARATION( UIWidget, UIDMBox, NULL )
-{
-	{ &W_SizeChanged,		&UIDMBox::OnSizeChanged },
-	{ &EV_DMBox_Goin,		&UIDMBox::MoveInEvent },
-	{ &EV_DMBox_Decay,		&UIDMBox::DecayEvent },
-	{ NULL, NULL }
+CLASS_DECLARATION(UIWidget, UIDMBox, NULL) {
+    {&W_SizeChanged,  &UIDMBox::OnSizeChanged},
+    {&EV_DMBox_Goin,  &UIDMBox::MoveInEvent  },
+    {&EV_DMBox_Decay, &UIDMBox::DecayEvent   },
+    {NULL,            NULL                   }
 };
 
 UIDMBox::UIDMBox()
 {
-	m_numitems = 0;
-	m_reallyshown = true;
-	m_fontbold = NULL;
-	m_boxstate = boxstate_t::box_out;
-	m_iBeginDecay = 0;
-	m_boxtime = uid.time;
-	m_movespeed = 500;
+    m_numitems    = 0;
+    m_reallyshown = true;
+    m_fontbold    = NULL;
+    m_boxstate    = boxstate_t::box_out;
+    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 )
+void UIDMBox::VerifyBoxOut(void)
 {
-	PostMoveinEvent();
-	if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_out)
-	{
-		ChangeBoxState(boxstate_t::box_moving_out);
-	}
+    PostMoveinEvent();
+    if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_out) {
+        ChangeBoxState(boxstate_t::box_moving_out);
+    }
 }
 
-void UIDMBox::ChangeBoxState( boxstate_t state )
+void UIDMBox::ChangeBoxState(boxstate_t state)
 {
-	m_boxstate = state;
-	m_boxtime = uid.time;
-	setShowState();
+    m_boxstate = state;
+    m_boxtime  = uid.time;
+    setShowState();
 
-	if (state == box_out) {
-		PostMoveinEvent();
-	}
+    if (state == box_out) {
+        PostMoveinEvent();
+    }
 }
 
-void UIDMBox::HandleBoxMoving( void )
+void UIDMBox::HandleBoxMoving(void)
 {
-	int delta;
-	UIRect2D newRect;
+    int      delta;
+    UIRect2D newRect;
 
-	if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_moving_in) {
-		return;
-	}
+    if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_moving_in) {
+        return;
+    }
 
-	delta = m_movespeed * (uid.time - m_boxtime) / 1000;
-	m_boxtime = 1000 * delta / m_movespeed + m_boxtime;
-	if (m_boxstate == boxstate_t::box_moving_out)
-	{
-		newRect.size.width = m_frame.size.width;
-		newRect.size.height = m_frame.size.height;
-		newRect.pos.x = m_frame.pos.x;
-		newRect.pos.y = delta + m_frame.pos.y;
+    delta     = m_movespeed * (uid.time - m_boxtime) / 1000;
+    m_boxtime = 1000 * delta / m_movespeed + m_boxtime;
+    if (m_boxstate == boxstate_t::box_moving_out) {
+        newRect.size.width  = m_frame.size.width;
+        newRect.size.height = m_frame.size.height;
+        newRect.pos.x       = m_frame.pos.x;
+        newRect.pos.y       = delta + m_frame.pos.y;
 
-		if (newRect.pos.y <= 0.0)
-		{
-			newRect.pos.y = 0.0;
-			ChangeBoxState(boxstate_t::box_out);
-		}
-	}
-	else if (m_boxstate == boxstate_t::box_moving_in)
-	{
-		newRect.size.width = m_frame.size.width;
-		newRect.size.height = m_frame.size.height;
-		newRect.pos.x = m_frame.pos.x;
-		newRect.pos.y = delta - m_frame.pos.y;
+        if (newRect.pos.y <= 0.0) {
+            newRect.pos.y = 0.0;
+            ChangeBoxState(boxstate_t::box_out);
+        }
+    } else if (m_boxstate == boxstate_t::box_moving_in) {
+        newRect.size.width  = m_frame.size.width;
+        newRect.size.height = m_frame.size.height;
+        newRect.pos.x       = m_frame.pos.x;
+        newRect.pos.y       = delta - m_frame.pos.y;
 
-		if (newRect.pos.y <= -newRect.size.height)
-		{
-			newRect.pos.y = -newRect.size.height;
-			ChangeBoxState(boxstate_t::box_in);
-		}
-	}
-	else {
-		newRect = m_frame;
-	}
+        if (newRect.pos.y <= -newRect.size.height) {
+            newRect.pos.y = -newRect.size.height;
+            ChangeBoxState(boxstate_t::box_in);
+        }
+    } else {
+        newRect = m_frame;
+    }
 
-	setFrame(newRect);
+    setFrame(newRect);
 }
 
-void UIDMBox::PostMoveinEvent( void )
+void UIDMBox::PostMoveinEvent(void)
 {
-	if (m_boxstate != boxstate_t::box_out) {
-		return;
-	}
+    if (m_boxstate != boxstate_t::box_out) {
+        return;
+    }
 
-	if (!EventPending(EV_DMBox_Goin)) {
-		PostEvent(EV_DMBox_Goin, 10.0);
-	}
-	else {
-		PostponeEvent(EV_DMBox_Goin, 10.0);
-	}
+    if (!EventPending(EV_DMBox_Goin)) {
+        PostEvent(EV_DMBox_Goin, 10.0);
+    } else {
+        PostponeEvent(EV_DMBox_Goin, 10.0);
+    }
 }
 
-void UIDMBox::PostDecayEvent( void )
+void UIDMBox::PostDecayEvent(void)
 {
-	if (!EventPending(EV_DMBox_Decay))
-	{
-		float fDelayTime;
-		int iNumLines;
-		int i;
-		const char* pszString = m_items[0].string.c_str();
+    if (!EventPending(EV_DMBox_Decay)) {
+        float       fDelayTime;
+        int         iNumLines;
+        int         i;
+        const char *pszString = m_items[0].string.c_str();
 
-		//
-		// Calculate the number of lines
-		//
-		iNumLines = 1;
-		for (i = 0; pszString[i]; i++)
-		{
-			if (pszString[i] == '\n') {
-				iNumLines++;
-			}
-		}
+        //
+        // Calculate the number of lines
+        //
+        iNumLines = 1;
+        for (i = 0; pszString[i]; i++) {
+            if (pszString[i] == '\n') {
+                iNumLines++;
+            }
+        }
 
         if (m_items[0].flags & DMBOX_ITEM_FLAG_BOLD) {
             fDelayTime = iNumLines * 8.0;
@@ -167,265 +158,268 @@ void UIDMBox::PostDecayEvent( void )
         //
         // Bold as twice more decay
         //
-		else if (m_items[0].flags & DMBOX_ITEM_FLAG_DEATH) {
-			fDelayTime = iNumLines * 6.0;
-		}
-		else {
-			fDelayTime = iNumLines * 5.0;
-		}
+        else if (m_items[0].flags & DMBOX_ITEM_FLAG_DEATH) {
+            fDelayTime = iNumLines * 6.0;
+        } else {
+            fDelayTime = iNumLines * 5.0;
+        }
 
-		m_iBeginDecay = cls.realtime;
-		m_iEndDecay = (int)(fDelayTime * 1000.0);
+        m_iBeginDecay = cls.realtime;
+        m_iEndDecay   = (int)(fDelayTime * 1000.0);
 
-		PostEvent(EV_DMBox_Decay, fDelayTime);
-	}
+        PostEvent(EV_DMBox_Decay, fDelayTime);
+    }
 }
 
-void UIDMBox::setShowState( void )
+void UIDMBox::setShowState(void)
 {
-	if (m_reallyshown) {
-		setShow(m_boxstate != box_in);
-	} else {
-		setShow(false);
-	}
+    if (m_reallyshown) {
+        setShow(m_boxstate != box_in);
+    } else {
+        setShow(false);
+    }
 }
 
-void UIDMBox::RemoveTopItem( void )
+void UIDMBox::RemoveTopItem(void)
 {
-	int i;
+    int i;
 
-	if (m_numitems > 0) {
-		for (i = 0; i < m_numitems - 1; i++) {
-			m_items[i] = m_items[i + 1];
-		}
+    if (m_numitems > 0) {
+        for (i = 0; i < m_numitems - 1; i++) {
+            m_items[i] = m_items[i + 1];
+        }
 
-		m_numitems--;
-	}
+        m_numitems--;
+    }
 }
 
-str UIDMBox::CalculateBreaks( UIFont *font, str text, float max_width )
+str UIDMBox::CalculateBreaks(UIFont *font, str text, float max_width)
 {
-	str newText, sTmp;
-	int i;
-	float fX;
-	float fwX, fsX;
+    str         newText;
+    float       fX;
+    float       fwX;
+    const char *current;
+    int         count;
 
-	Cmd_TokenizeString(text.c_str());
-	if (Cmd_Argc())
-	{
-		fX = 0.0;
-		fsX = font->getCharWidth(' ');
+    current = text;
+    fX      = 0.0;
 
-		for (i = 0; i < Cmd_Argc(); i++)
-		{
-			sTmp = Cmd_Argv(i);
+    for (count = font->DBCSGetWordBlockCount(current, -1); count;
+         current += count, count = font->DBCSGetWordBlockCount(current, -1)) {
+        fwX = font->getWidth(current, count);
 
-			fwX = font->getWidth(sTmp.c_str(), -1);
-			if (fwX + i <= max_width)
-			{
-				if (fwX + i + fX <= max_width)
-				{
-					newText += sTmp + " ";
-				} else {
-					newText += "\n" + sTmp + " ";
-				}
-			}
-			else
-			{
-				sTmp += "\n";
-				fX = 0.0;
-			}
-		}
-	} else {
-		newText = "";
-	}
+        if (fX + fwX > max_width) {
+            newText += "\n" + str(current, 0, count);
+            fX = 0;
+        } else {
+            newText += str(current, 0, count);
+        }
 
-	return newText;
+        fX += fwX;
+    }
+
+    return newText;
 }
 
-float UIDMBox::PrintWrap( UIFont *font, float x, float y, str text )
+float UIDMBox::PrintWrap(UIFont *font, float x, float y, str text)
 {
-	const char* p1, * p2;
-	size_t n, l;
-	float fY;
+    const char *p1, *p2;
+    size_t      n, l;
+    float       fY;
 
-	fY = y;
-	p1 = text.c_str();
-	l = text.length();
+    fY = y;
+    p1 = text.c_str();
+    l  = text.length();
 
-	for (;;)
-	{
-		p2 = strchr(p1, '\n');
-		if (!p2) {
-			break;
-		}
+    for (;;) {
+        p2 = strchr(p1, '\n');
+        if (!p2) {
+            break;
+        }
 
-		n = p2 - p1;
-		if (n >= l) {
-			break;
-		}
+        n = p2 - p1;
+        if (n >= l) {
+            break;
+        }
 
-		font->Print(x, fY, p1, p2 - p1, qfalse);
-		p1 = p2 + 1;
-		l -= n;
-		fY += font->getHeight(qfalse);
-	}
+        font->Print(x, fY, p1, p2 - p1, getHighResScale());
+        p1 = p2 + 1;
+        l -= n;
+        fY += font->getHeight();
+    }
 
-	font->Print(x, fY, p1, l, qfalse);
+    if (*p1) {
+        font->Print(x, fY, p1, l, getHighResScale());
+        fY += font->getHeight();
+    }
 
-	return font->getHeight(qfalse) + (fY - y);
+    return fY - y;
 }
 
-float UIDMBox::DrawItem( item_t *in, float x, float y, float alpha )
+float UIDMBox::DrawItem(item_t *in, float x, float y, float alpha)
 {
-	in->font->setColor(in->color);
-	in->font->setAlpha(alpha);
+    if (m_drawoutline) {
+        //
+        // Draw an outline
+        //
 
-	return PrintWrap(in->font, x, y, in->string);
+        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);
+
+    return PrintWrap(in->font, x, y, in->string);
 }
 
-void UIDMBox::Print( const char *text )
+void UIDMBox::Print(const char *text)
 {
-	const char* text1 = text;
+    const char *text1 = text;
 
-	if (m_numitems > 5)
-	{
-		//
-		// Overwrite an item
-		//
-		RemoveTopItem();
-	}
+    if (m_numitems > 5) {
+        //
+        // Overwrite an item
+        //
+        RemoveTopItem();
+    }
 
-	m_items[m_numitems].flags = 0;
+    m_items[m_numitems].flags = 0;
 
-	if (*text == MESSAGE_CHAT_WHITE)
-	{
-		m_items[m_numitems].color = UGrey;
-		m_items[m_numitems].font = m_fontbold;
-		m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_BOLD;
+    if (*text == MESSAGE_CHAT_WHITE) {
+        m_items[m_numitems].color = UWhiteChatMessageColor;
+        m_items[m_numitems].font  = m_fontbold;
+        m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_BOLD;
 
-		text1 = text + 1;
-	}
-	else if (*text == MESSAGE_CHAT_RED)
-	{
-		m_items[m_numitems].color = ULightRed;
-		m_items[m_numitems].font = m_fontbold;
-		m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_DEATH;
+        text1 = text + 1;
+    } else if (*text == MESSAGE_CHAT_RED) {
+        m_items[m_numitems].color = URedChatMessageColor;
+        m_items[m_numitems].font  = m_fontbold;
+        m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_DEATH;
 
-		text1 = text + 1;
-	}
-	else if (*text == MESSAGE_CHAT_GREEN)
-	{
-		m_items[m_numitems].color = UGreen;
+        text1 = text + 1;
+    } else if (*text == MESSAGE_CHAT_GREEN) {
+        m_items[m_numitems].color = UGreenChatMessageColor;
         m_items[m_numitems].font = m_fontbold;
         m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_DEATH;
 
-		text1 = text + 1;
-	}
-	else
-	{
-		m_items[m_numitems].color = m_foreground_color;
-		m_items[m_numitems].font = m_font;
-	}
+        text1 = text + 1;
+    } else {
+        m_items[m_numitems].color = m_foreground_color;
+        m_items[m_numitems].font  = m_font;
+    }
 
-	m_items[m_numitems].string = CalculateBreaks(m_items[m_numitems].font, text1, s_dmboxWidth);
+    m_items[m_numitems].string = CalculateBreaks(m_items[m_numitems].font, Sys_LV_CL_ConvertString(text1), s_dmboxWidth);
 
-	m_numitems++;
-	VerifyBoxOut();
-	PostDecayEvent();
+    m_numitems++;
+    VerifyBoxOut();
+    PostDecayEvent();
 }
 
-void UIDMBox::OnSizeChanged( Event *ev )
+void UIDMBox::OnSizeChanged(Event *ev)
 {
-	s_dmboxWidth = m_frame.size.width;
+    s_dmboxWidth = m_frame.size.width;
 }
 
-void UIDMBox::Create( const UIRect2D& rect, const UColor& fore, const UColor& back, float alpha )
+void UIDMBox::Create(const UIRect2D& rect, const UColor& fore, const UColor& back, float alpha)
 {
-	InitFrame(NULL, rect, 0, "facfont-20");
+    InitFrame(NULL, rect, 0, "facfont-20");
 
-	if (!m_fontbold) {
-		m_fontbold = new UIFont("facfont-20");
-	}
+    if (!m_fontbold) {
+        m_fontbold = new UIFont("facfont-20");
+    }
 
-	m_fontbold->setColor(URed);
-	setBackgroundColor(back, true);
-	setForegroundColor(fore);
-	setBackgroundAlpha(alpha);
+    m_fontbold->setColor(URed);
+    setBackgroundColor(back, true);
+    setForegroundColor(fore);
+    setBackgroundAlpha(alpha);
 
-	Connect(this, W_SizeChanged, W_SizeChanged);
-	OnSizeChanged(NULL);
+    Connect(this, W_SizeChanged, W_SizeChanged);
+    OnSizeChanged(NULL);
 
-	m_movespeed = rect.size.height * 3.0;
+    m_movespeed = rect.size.height * 3.0;
 
-	setShowState();
+    setShowState();
 }
 
-void UIDMBox::MoveInEvent( Event *ev )
+void UIDMBox::MoveInEvent(Event *ev) {}
+
+void UIDMBox::DecayEvent(Event *ev)
 {
+    RemoveTopItem();
+    if (m_numitems) {
+        PostDecayEvent();
+    }
 }
 
-void UIDMBox::DecayEvent( Event *ev )
+void UIDMBox::Draw(void)
 {
-	RemoveTopItem();
-	if (m_numitems) {
-		PostDecayEvent();
-	}
+    float fsY;
+    int   i;
+    float alpha;
+    float alphaScale;
+
+    alphaScale = 0.8f;
+    HandleBoxMoving();
+
+    if (!m_numitems) {
+        //
+        // Nothing to show
+        //
+        return;
+    }
+
+    m_font->setColor(m_foreground_color);
+    alpha = (float)(cls.realtime - m_iBeginDecay) / (float)m_iEndDecay;
+    if (alpha > 1.0) {
+        alpha = 1.0;
+    }
+
+    alpha = (1.0 - alpha) * 4.0;
+    if (alpha > 1.0) {
+        alpha = 1.0;
+    }
+
+    if (cge) {
+        alphaScale = 1.0 - cge->CG_GetObjectiveAlpha();
+    }
+
+    fsY = DrawItem(m_items, s_dmboxOffsetX, s_dmboxOffsetY, alpha * alphaScale);
+    fsY = alpha <= 0.2 ? s_dmboxOffsetY : fsY + s_dmboxOffsetY;
+
+    for (i = 1; i < m_numitems; i++) {
+        fsY += DrawItem(&m_items[i], s_dmboxOffsetX, fsY, alphaScale);
+        if (fsY > m_frame.size.height) {
+            if (EventPending(EV_DMBox_Decay)) {
+                CancelEventsOfType(EV_DMBox_Decay);
+            }
+
+            PostEvent(EV_DMBox_Decay, 0.0);
+            break;
+        }
+    }
 }
 
-void UIDMBox::Draw( void )
+void UIDMBox::setRealShow(bool b)
 {
-	float fsY;
-	int i;
-	float alpha;
-	float alphaScale;
-
-	alphaScale = 0.8f;
-	HandleBoxMoving();
-
-	if (!m_numitems) {
-		//
-		// Nothing to show
-		//
-		return;
-	}
-
-	m_font->setColor(m_foreground_color);
-	alpha = (float)(cls.realtime - m_iBeginDecay) / (float)m_iEndDecay;
-	if (alpha > 1.0) alpha = 1.0;
-
-	alpha = (1.0 - alpha) * 4.0;
-	if (alpha > 1.0) alpha = 1.0;
-
-	if (cge) {
-		alphaScale = 1.0 - cge->CG_GetObjectiveAlpha();
-	}
-
-	fsY = DrawItem(m_items, s_dmboxOffsetX, s_dmboxOffsetY, alpha * alphaScale);
-	fsY = alpha <= 0.2 ? s_dmboxOffsetY : fsY + s_dmboxOffsetY;
-
-	for (i = 1; i < m_numitems; i++)
-	{
-		fsY += DrawItem(&m_items[i], s_dmboxOffsetX, fsY, alphaScale);
-		if (fsY > m_frame.size.height)
-		{
-			if (EventPending(EV_DMBox_Decay)) {
-				CancelEventsOfType(EV_DMBox_Decay);
-			}
-
-			PostEvent(EV_DMBox_Decay, 0.0);
-			break;
-		}
-	}
+    this->m_reallyshown = b;
+    setShowState();
 }
 
-void UIDMBox::setRealShow( bool b )
+void UIDMBox::Clear(void)
 {
-	this->m_reallyshown = b;
-	setShowState();
-}
-
-void UIDMBox::Clear( void )
-{
-	m_numitems = 0;
+    m_numitems = 0;
 }

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

@@ -47,7 +47,7 @@ FilePickerClass::FilePickerClass()
     window = new UIFloatingWindow();
     window->Create(
         NULL,
-        UIRect2D((cls.glconfig.vidWidth - 400) / 2, (cls.glconfig.vidHeight - 300) / 2, 400, 300),
+        UIRect2D((uid.vidWidth - 400) / 2, (uid.vidHeight - 300) / 2, 400, 300),
         "File Picker",
         UColor(0.15f, 0.195f, 0.278f),
         UHudColor
@@ -104,8 +104,10 @@ void FilePickerClass::Initialize(
         currentDirectory += "/";
     }
 
-    extension    = ext;
-    ignoredFiles = ignore_files;
+    extension = ext;
+    if (ignore_files) {
+        ignoredFiles = ignore_files;
+    }
 
     SetupFiles();
 }

code/client/cl_uigamespy.cpp

@@ -0,0 +1,118 @@
+/*
+===========================================================================
+Copyright (C) 2025 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
+===========================================================================
+*/
+
+// cl_uigamespy.cpp
+#include "cl_uigamespy.h"
+
+CLASS_DECLARATION(UIFloatingWindow, GameSpyDialog, NULL) {
+    {&W_Deactivated, &UIFloatingWindow::ClosePressed},
+    {NULL,           NULL                           }
+};
+
+GameSpyDialog::GameSpyDialog()
+    : overlay(NULL)
+    , label(NULL)
+    , closeButton(NULL)
+{
+    AddFlag(WF_ALWAYS_TOP);
+}
+
+GameSpyDialog::~GameSpyDialog()
+{
+    if (overlay) {
+        delete overlay;
+        overlay = NULL;
+    }
+
+    if (label) {
+        delete label;
+        label = NULL;
+    }
+
+    if (closeButton) {
+        delete closeButton;
+        closeButton = NULL;
+    }
+}
+
+void GameSpyDialog::FrameInitialized(void)
+{
+    UIFloatingWindow::FrameInitialized();
+
+    label = new UILabel();
+
+    label->InitFrame(getChildSpace(), getChildSpace()->getClientFrame(), 0);
+    label->setTitle(
+        "GameSpy's multiplayer matchmaking\n"
+        "and server browsing services, which were\n"
+        "essential for online gaming in many classic\n"
+        "titles including Medal of Honor: Allied Assault,\n"
+        "were permanently shut down in 2014."
+    );
+    label->setForegroundColor(UHudColor);
+
+    closeButton = new UIButton();
+    closeButton->InitFrame(getChildSpace(), UIRect2D(100, 150, 100, 30), 0);
+    closeButton->setTitle("Close");
+    closeButton->AllowActivate(true);
+    closeButton->Connect(this, W_Button_Pressed, W_Deactivated);
+
+    overlay = new UIButton();
+    overlay->InitFrame(NULL, UIRect2D(0, 0, uid.vidWidth, uid.vidHeight), 0);
+    overlay->setBackgroundColor(UColor(0, 0, 0, 0.5f), true);
+    overlay->AllowActivate(true);
+
+    overlay->Connect(this, W_Button_Pressed, W_Deactivated);
+}
+
+void GameSpyDialog::Create(
+    UIWidget *parent, const UIRect2D& rect, const char *title, const UColor& bgColor, const UColor& fgColor
+)
+{
+    // First call parent's Create
+    UIFloatingWindow::Create(parent, rect, title, bgColor, fgColor);
+
+    // After creation, find minimize button by name and hide it
+    for (UIWidget *child = getFirstChild(); child; child = getNextChild(child)) {
+        if (strcmp(child->getName(), "minimizebutton") == 0) {
+            child->setShow(false);
+            break;
+        }
+    }
+}
+
+void UI_LaunchGameSpy_f(void)
+{
+    GameSpyDialog *dialog = new GameSpyDialog();
+
+    dialog->Create(
+        NULL,
+        UIRect2D((uid.vidWidth - 300) / 2, (uid.vidHeight - 200) / 2, 300, 200),
+        "GameSpy",
+        UColor(0.15f, 0.195f, 0.278f),
+        UHudColor
+    );
+
+    uWinMan.ActivateControl(dialog);
+
+    dialog->Connect(dialog, W_Deactivated, W_Deactivated);
+}

code/client/cl_uigamespy.h

@@ -0,0 +1,50 @@
+/*
+===========================================================================
+Copyright (C) 2025 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
+===========================================================================
+*/
+
+// cl_gamespy.h
+#ifndef __CL_GAMESPY_H__
+#define __CL_GAMESPY_H__
+
+#include "cl_ui.h"
+#include "keycodes.h"
+
+class GameSpyDialog : public UIFloatingWindow
+{
+private:
+    UIButton *overlay;
+    UILabel  *label;
+    UIButton *closeButton;
+
+protected:
+    void FrameInitialized(void) override;
+
+public:
+    GameSpyDialog();
+    ~GameSpyDialog();
+    void
+    Create(UIWidget *parent, const UIRect2D& rect, const char *title, const UColor& bgColor, const UColor& fgColor);
+
+    CLASS_PROTOTYPE(GameSpyDialog);
+};
+
+void UI_LaunchGameSpy_f(void);
+#endif

code/client/cl_uigmbox.cpp

@@ -21,6 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "cl_ui.h"
+#include "../qcommon/localization.h"
 
 Event EV_GMBox_Goin
 (
@@ -40,371 +41,370 @@ Event EV_GMBox_Decay
 	"Event to make the gmbox console line decay"
 );
 
-static float s_gmboxWidth = 640.0;
+static float s_gmboxWidth   = 640.0;
 static float s_gmboxOffsetX = 3.0f;
 static float s_gmboxOffsetY = 0.0f;
 
-CLASS_DECLARATION( UIWidget, UIGMBox, NULL )
-{
-	{ &W_SizeChanged,		&UIGMBox::OnSizeChanged },
-	{ &EV_GMBox_Goin,		&UIGMBox::MoveInEvent },
-	{ &EV_GMBox_Decay,		&UIGMBox::DecayEvent },
-	{ NULL, NULL }
+CLASS_DECLARATION(UIWidget, UIGMBox, NULL) {
+    {&W_SizeChanged,  &UIGMBox::OnSizeChanged},
+    {&EV_GMBox_Goin,  &UIGMBox::MoveInEvent  },
+    {&EV_GMBox_Decay, &UIGMBox::DecayEvent   },
+    {NULL,            NULL                   }
 };
 
 UIGMBox::UIGMBox()
 {
-	m_numitems = 0;
-	m_reallyshown = true;
-	m_fontbold = NULL;
-	m_boxstate = boxstate_t::box_out;
-	m_iBeginDecay = 0;
-	m_boxtime = uid.time;
-	m_movespeed = 500;
+    m_numitems    = 0;
+    m_reallyshown = true;
+    m_fontbold    = NULL;
+    m_boxstate    = boxstate_t::box_out;
+    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 )
+void UIGMBox::VerifyBoxOut(void)
 {
-	PostMoveinEvent();
-	if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_out)
-	{
-		ChangeBoxState(boxstate_t::box_moving_out);
-	}
+    PostMoveinEvent();
+    if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_out) {
+        ChangeBoxState(boxstate_t::box_moving_out);
+    }
 }
 
-void UIGMBox::ChangeBoxState( boxstate_t state )
+void UIGMBox::ChangeBoxState(boxstate_t state)
 {
-	m_boxstate = state;
-	m_boxtime = uid.time;
-	setShowState();
+    m_boxstate = state;
+    m_boxtime  = uid.time;
+    setShowState();
 
-	if (state == box_out) {
-		PostMoveinEvent();
-	}
+    if (state == box_out) {
+        PostMoveinEvent();
+    }
 }
 
-void UIGMBox::HandleBoxMoving( void )
+void UIGMBox::HandleBoxMoving(void)
 {
-	int delta;
-	UIRect2D newRect;
+    int      delta;
+    UIRect2D newRect;
 
-	if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_moving_in) {
-		return;
-	}
+    if (m_boxstate != boxstate_t::box_moving_out && m_boxstate != boxstate_t::box_moving_in) {
+        return;
+    }
 
-	delta = m_movespeed * (uid.time - m_boxtime) / 1000;
-	m_boxtime = 1000 * delta / m_movespeed + m_boxtime;
-	if (m_boxstate == boxstate_t::box_moving_out)
-	{
-		newRect.size.width = m_frame.size.width;
-		newRect.size.height = m_frame.size.height;
-		newRect.pos.x = m_frame.pos.x;
-		newRect.pos.y = delta + m_frame.pos.y;
+    delta     = m_movespeed * (uid.time - m_boxtime) / 1000;
+    m_boxtime = 1000 * delta / m_movespeed + m_boxtime;
+    if (m_boxstate == boxstate_t::box_moving_out) {
+        newRect.size.width  = m_frame.size.width;
+        newRect.size.height = m_frame.size.height;
+        newRect.pos.x       = m_frame.pos.x;
+        newRect.pos.y       = delta + m_frame.pos.y;
 
-		if (newRect.pos.y <= 0.0)
-		{
-			newRect.pos.y = 0.0;
-			ChangeBoxState(boxstate_t::box_out);
-		}
-	}
-	else if (m_boxstate == boxstate_t::box_moving_in)
-	{
-		newRect.size.width = m_frame.size.width;
-		newRect.size.height = m_frame.size.height;
-		newRect.pos.x = m_frame.pos.x;
-		newRect.pos.y = delta - m_frame.pos.y;
+        if (newRect.pos.y <= 0.0) {
+            newRect.pos.y = 0.0;
+            ChangeBoxState(boxstate_t::box_out);
+        }
+    } else if (m_boxstate == boxstate_t::box_moving_in) {
+        newRect.size.width  = m_frame.size.width;
+        newRect.size.height = m_frame.size.height;
+        newRect.pos.x       = m_frame.pos.x;
+        newRect.pos.y       = delta - m_frame.pos.y;
 
-		if (newRect.pos.y <= -newRect.size.height)
-		{
-			newRect.pos.y = -newRect.size.height;
-			ChangeBoxState(boxstate_t::box_in);
-		}
-	} else {
-		newRect = m_frame;
-	}
+        if (newRect.pos.y <= -newRect.size.height) {
+            newRect.pos.y = -newRect.size.height;
+            ChangeBoxState(boxstate_t::box_in);
+        }
+    } else {
+        newRect = m_frame;
+    }
 
-	setFrame(newRect);
+    setFrame(newRect);
 }
 
-void UIGMBox::PostMoveinEvent( void )
+void UIGMBox::PostMoveinEvent(void)
 {
-	if (m_boxstate != boxstate_t::box_out) {
-		return;
-	}
+    if (m_boxstate != boxstate_t::box_out) {
+        return;
+    }
 
-	if (!EventPending(EV_GMBox_Goin)) {
-		PostEvent(EV_GMBox_Goin, 10.0);
-	} else {
-		PostponeEvent(EV_GMBox_Goin, 10.0);
-	}
+    if (!EventPending(EV_GMBox_Goin)) {
+        PostEvent(EV_GMBox_Goin, 10.0);
+    } else {
+        PostponeEvent(EV_GMBox_Goin, 10.0);
+    }
 }
 
-void UIGMBox::PostDecayEvent( void )
+void UIGMBox::PostDecayEvent(void)
 {
-	if (!EventPending(EV_GMBox_Decay))
-	{
-		float fDelayTime;
-		int iNumLines;
-		int i;
-		const char* pszString = m_items[0].string.c_str();
+    if (!EventPending(EV_GMBox_Decay)) {
+        float       fDelayTime;
+        int         iNumLines;
+        int         i;
+        const char *pszString = m_items[0].string.c_str();
 
-		//
-		// Calculate the number of lines
-		//
-		iNumLines = 1;
-		for (i = 0; pszString[i]; i++)
-		{
-			if (pszString[i] == '\n') {
-				iNumLines++;
-			}
-		}
+        //
+        // Calculate the number of lines
+        //
+        iNumLines = 1;
+        for (i = 0; pszString[i]; i++) {
+            if (pszString[i] == '\n') {
+                iNumLines++;
+            }
+        }
 
-		//
-		// Bold as twice more decay
-		//
-		if (m_items[0].flags & GMBOX_ITEM_FLAG_BOLD) {
-			fDelayTime = iNumLines * 10.0;
-		} else {
-			fDelayTime = iNumLines * 5.0;
-		}
+        //
+        // Bold as twice more decay
+        //
+        if (m_items[0].flags & GMBOX_ITEM_FLAG_BOLD) {
+            fDelayTime = iNumLines * 10.0;
+        } else {
+            fDelayTime = iNumLines * 5.0;
+        }
 
-		m_iBeginDecay = cls.realtime;
-		m_iEndDecay = (int)(fDelayTime * 1000.0);
+        m_iBeginDecay = cls.realtime;
+        m_iEndDecay   = (int)(fDelayTime * 1000.0);
 
-		PostEvent(EV_GMBox_Decay, fDelayTime);
-	}
+        PostEvent(EV_GMBox_Decay, fDelayTime);
+    }
 }
 
-void UIGMBox::setShowState( void )
+void UIGMBox::setShowState(void)
 {
-	if (m_reallyshown) {
-		setShow(m_boxstate != box_in);
-	} else {
-		setShow(false);
-	}
+    if (m_reallyshown) {
+        setShow(m_boxstate != box_in);
+    } else {
+        setShow(false);
+    }
 }
 
-void UIGMBox::RemoveTopItem( void )
+void UIGMBox::RemoveTopItem(void)
 {
-	int i;
+    int i;
 
-	if (m_numitems > 0) {
-		for (i = 0; i < m_numitems - 1; i++) {
-			m_items[i] = m_items[i + 1];
-		}
+    if (m_numitems > 0) {
+        for (i = 0; i < m_numitems - 1; i++) {
+            m_items[i] = m_items[i + 1];
+        }
 
-		m_numitems--;
-	}
+        m_numitems--;
+    }
 }
 
-str UIGMBox::CalculateBreaks( UIFont *font, str text, float max_width )
+str UIGMBox::CalculateBreaks(UIFont *font, str text, float max_width)
 {
-	str newText, sTmp;
-	int i;
-	float fX;
-	float fwX, fsX;
+    str         newText;
+    float       fX;
+    float       fwX;
+    const char *current;
+    int         count;
 
-	Cmd_TokenizeString(text.c_str());
-	if (Cmd_Argc())
-	{
-		fX = 0.0;
-		fsX = font->getCharWidth(' ');
+    current = text;
+    fX      = 0.0;
 
-		for (i = 0; i < Cmd_Argc(); i++)
-		{
-			sTmp = Cmd_Argv(i);
+    for (count = font->DBCSGetWordBlockCount(current, -1); count;
+         current += count, count = font->DBCSGetWordBlockCount(current, -1)) {
+        fwX = font->getWidth(current, count);
 
-			fwX = font->getWidth(sTmp.c_str(), -1);
-			if (fwX + i <= max_width)
-			{
-				if (fwX + i + fX <= max_width)
-				{
-					newText += sTmp + " ";
-				} else {
-					newText += "\n" + sTmp + " ";
-				}
-			}
-			else
-			{
-				sTmp += "\n";
-				fX = 0.0;
-			}
-		}
-	} else {
-		newText = "";
-	}
+        if (fX + fwX > max_width) {
+            newText += "\n" + str(current, 0, count);
+            fX = 0;
+        } else {
+            newText += str(current, 0, count);
+        }
 
-	return newText;
+        fX += fwX;
+    }
+
+    return newText;
 }
 
-float UIGMBox::PrintWrap( UIFont *font, float x, float y, str text )
+float UIGMBox::PrintWrap(UIFont *font, float x, float y, str text)
 {
-	const char* p1, * p2;
-	size_t n, l;
-	float fY;
+    const char *p1, *p2;
+    size_t      n, l;
+    float       fY;
 
-	fY = y;
-	p1 = text.c_str();
-	l = text.length();
+    fY = y;
+    p1 = text.c_str();
+    l  = text.length();
 
-	for (;;)
-	{
-		p2 = strchr(p1, '\n');
-		if (!p2) {
-			break;
-		}
+    for (;;) {
+        p2 = strchr(p1, '\n');
+        if (!p2) {
+            break;
+        }
 
-		n = p2 - p1;
-		if (n >= l) {
-			break;
-		}
+        n = p2 - p1;
+        if (n >= l) {
+            break;
+        }
 
-		font->Print(x, fY, p1, p2 - p1, qfalse);
-		p1 = p2 + 1;
-		l -= n;
-		fY += font->getHeight(qfalse);
-	}
+        font->Print(x, fY, p1, p2 - p1, getHighResScale());
+        p1 = p2 + 1;
+        l -= n;
+        fY += font->getHeight();
+    }
 
-	font->Print(x, fY, p1, l, qfalse);
+    if (*p1) {
+        font->Print(x, fY, p1, l, getHighResScale());
+        fY += font->getHeight();
+    }
 
-	return font->getHeight(qfalse) + (fY - y);
+    return fY - y;
 }
 
-float UIGMBox::DrawItem( item_t *in, float x, float y, float alpha )
+float UIGMBox::DrawItem(item_t *in, float x, float y, float alpha)
 {
-	in->font->setColor(in->color);
-	in->font->setAlpha(alpha);
+    if (m_drawoutline) {
+        //
+        // Draw an outline
+        //
 
-	return PrintWrap(in->font, x, y, in->string);
+        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);
+
+    return PrintWrap(in->font, x, y, in->string);
 }
 
-void UIGMBox::Print( const char *text )
+void UIGMBox::Print(const char *text)
 {
-	const char* text1 = text;
+    const char *text1 = text;
 
-	if (m_numitems > 4)
-	{
-		//
-		// Overwrite an item
-		//
-		RemoveTopItem();
-	}
+    if (m_numitems > 4) {
+        //
+        // Overwrite an item
+        //
+        RemoveTopItem();
+    }
 
-	m_items[m_numitems].flags = 0;
+    m_items[m_numitems].flags = 0;
 
-	if (*text == 3)
-	{
-		m_items[m_numitems].color = UWhite;
-		m_items[m_numitems].font = m_fontbold;
-		m_items[m_numitems].flags |= GMBOX_ITEM_FLAG_BOLD;
+    if (*text == MESSAGE_WHITE) {
+        m_items[m_numitems].color = UWhite;
+        m_items[m_numitems].font  = m_fontbold;
+        m_items[m_numitems].flags |= GMBOX_ITEM_FLAG_BOLD;
 
-		text1 = text + 1;
-	}
-	else
-	{
-		m_items[m_numitems].color = m_foreground_color;
-		m_items[m_numitems].font = m_font;
-	}
+        text1 = text + 1;
+    } else {
+        m_items[m_numitems].color = m_foreground_color;
+        m_items[m_numitems].font  = m_font;
+    }
 
-	m_items[m_numitems].string = CalculateBreaks(m_items[m_numitems].font, text1, s_gmboxWidth);
+    m_items[m_numitems].string = CalculateBreaks(m_items[m_numitems].font, Sys_LV_CL_ConvertString(text1), s_gmboxWidth);
 
-	m_numitems++;
-	VerifyBoxOut();
-	PostDecayEvent();
+    m_numitems++;
+    VerifyBoxOut();
+    PostDecayEvent();
 }
 
-void UIGMBox::OnSizeChanged( Event *ev )
+void UIGMBox::OnSizeChanged(Event *ev)
 {
-	s_gmboxWidth = m_frame.size.width;
+    s_gmboxWidth = m_frame.size.width;
 }
 
-void UIGMBox::Create( const UIRect2D& rect, const UColor& fore, const UColor& back, float alpha )
+void UIGMBox::Create(const UIRect2D& rect, const UColor& fore, const UColor& back, float alpha)
 {
-	InitFrame(NULL, rect, 0, "facfont-20");
+    InitFrame(NULL, rect, 0, "facfont-20");
 
-	if (!m_fontbold) {
-		m_fontbold = new UIFont("facfont-20");
-	}
+    if (!m_fontbold) {
+        m_fontbold = new UIFont("facfont-20");
+    }
 
-	m_fontbold->setColor(URed);
-	setBackgroundColor(back, true);
-	setForegroundColor(fore);
-	setBackgroundAlpha(alpha);
+    m_fontbold->setColor(URed);
+    setBackgroundColor(back, true);
+    setForegroundColor(fore);
+    setBackgroundAlpha(alpha);
 
-	Connect(this, W_SizeChanged, W_SizeChanged);
-	OnSizeChanged(NULL);
+    Connect(this, W_SizeChanged, W_SizeChanged);
+    OnSizeChanged(NULL);
 
-	m_movespeed = rect.size.height * 3.0;
+    m_movespeed = rect.size.height * 3.0;
 
-	setShowState();
+    setShowState();
 }
 
-void UIGMBox::MoveInEvent( Event *ev )
+void UIGMBox::MoveInEvent(Event *ev) {}
+
+void UIGMBox::DecayEvent(Event *ev)
 {
+    RemoveTopItem();
+    if (m_numitems) {
+        PostDecayEvent();
+    }
 }
 
-void UIGMBox::DecayEvent( Event *ev )
+void UIGMBox::Draw(void)
 {
-	RemoveTopItem();
-	if (m_numitems) {
-		PostDecayEvent();
-	}
+    float fsY;
+    int   i;
+    float alpha;
+    float alphaScale;
+
+    alphaScale = 1.0;
+    HandleBoxMoving();
+
+    if (!m_numitems) {
+        //
+        // Nothing to show
+        //
+        return;
+    }
+
+    m_font->setColor(m_foreground_color);
+    alpha = (float)(cls.realtime - m_iBeginDecay) / (float)m_iEndDecay;
+    if (alpha > 1.0) {
+        alpha = 1.0;
+    }
+
+    alpha = (1.0 - alpha) * 4.0;
+    if (alpha > 1.0) {
+        alpha = 1.0;
+    }
+
+    if (cge) {
+        alphaScale = 1.0 - cge->CG_GetObjectiveAlpha();
+    }
+
+    fsY = DrawItem(m_items, s_gmboxOffsetX, s_gmboxOffsetY, alpha * alphaScale);
+    fsY = alpha <= 0.2 ? s_gmboxOffsetY : fsY + s_gmboxOffsetY;
+
+    for (i = 1; i < m_numitems; i++) {
+        fsY += DrawItem(&m_items[i], s_gmboxOffsetX, fsY, alphaScale);
+        if (fsY > m_frame.size.height) {
+            if (EventPending(EV_GMBox_Decay)) {
+                CancelEventsOfType(EV_GMBox_Decay);
+            }
+
+            PostEvent(EV_GMBox_Decay, 0.0);
+            break;
+        }
+    }
 }
 
-void UIGMBox::Draw( void )
+void UIGMBox::setRealShow(bool b)
 {
-	float fsY;
-	int i;
-	float alpha;
-	float alphaScale;
-
-	alphaScale = 1.0;
-	HandleBoxMoving();
-
-	if (!m_numitems) {
-		//
-		// Nothing to show
-		//
-		return;
-	}
-
-	m_font->setColor(m_foreground_color);
-	alpha = (float)(cls.realtime - m_iBeginDecay) / (float)m_iEndDecay;
-	if (alpha > 1.0) alpha = 1.0;
-
-	alpha = (1.0 - alpha) * 4.0;
-	if (alpha > 1.0) alpha = 1.0;
-
-	if (cge) {
-		alphaScale = 1.0 - cge->CG_GetObjectiveAlpha();
-	}
-
-	fsY = DrawItem(m_items, s_gmboxOffsetX, s_gmboxOffsetY, alpha * alphaScale);
-	fsY = alpha <= 0.2 ? s_gmboxOffsetY : fsY + s_gmboxOffsetY;
-
-	for (i = 1; i < m_numitems; i++)
-	{
-		fsY += DrawItem(&m_items[i], s_gmboxOffsetX, fsY, alphaScale);
-		if (fsY > m_frame.size.height)
-		{
-			if (EventPending(EV_GMBox_Decay)) {
-				CancelEventsOfType(EV_GMBox_Decay);
-			}
-
-			PostEvent(EV_GMBox_Decay, 0.0);
-			break;
-		}
-	}
+    this->m_reallyshown = b;
+    setShowState();
 }
 
-void UIGMBox::setRealShow( bool b )
+void UIGMBox::Clear(void)
 {
-	this->m_reallyshown = b;
-	setShowState();
+    m_numitems = 0;
 }
-
-void UIGMBox::Clear( void )
-{
-	m_numitems = 0;
-}
-

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) 2023 the OpenMoHAA team
+Copyright (C) 2023-2024 the OpenMoHAA team
 
 This file is part of OpenMoHAA source code.
 
@@ -25,12 +25,12 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 class LANGameItem : public UIListCtrlItem
 {
-    str strings[5];
+    str strings[6];
 
 public:
     LANGameItem();
     LANGameItem(
-        const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping
+        const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping, const str& ipAddress
     );
 
     int            getListItemValue(int which) const override;
@@ -65,6 +65,11 @@ UILANGameClass::UILANGameClass()
 
     m_iLastUpdateTime = 0;
     m_noservers_mat   = uWinMan.RegisterShader("textures/menu/noservers");
+
+    //
+    // Added in OPM
+    //
+    m_bVirtual = false;
 }
 
 void UILANGameClass::Draw(void)
@@ -102,11 +107,12 @@ void UILANGameClass::UpdateUIElement(void)
 
     width = getClientFrame().size.width - 16.f;
 
-    AddColumn(Sys_LV_CL_ConvertString("Server Name"), 0, width * 0.4f, false, false);
-    AddColumn(Sys_LV_CL_ConvertString("Map"), 1, width * 0.15f, false, false);
-    AddColumn(Sys_LV_CL_ConvertString("Players"), 2, width * 0.165f, true, true);
-    AddColumn(Sys_LV_CL_ConvertString("GameType"), 3, width * 0.22f, false, false);
-    AddColumn(Sys_LV_CL_ConvertString("Ping"), 4, width * 0.065f, true, false);
+    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);
 
@@ -134,7 +140,9 @@ void UILANGameClass::SetupServers(void)
             pServerInfo->mapName,
             va("%02i/%02i", pServerInfo->clients, pServerInfo->maxClients),
             pServerInfo->gameTypeString,
-            str(pServerInfo->ping)
+            str(pServerInfo->ping),
+            // Added in OPM
+            NET_AdrToStringwPort(pServerInfo->adr)
         );
     }
 
@@ -167,7 +175,7 @@ void UILANGameClass::JoinServer(Event *ev)
     const serverInfo_t& serverInfo = cls.localServers[getCurrentItem() - 1];
 
     UI_SetReturnMenuToCurrent();
-    CL_Connect(NET_AdrToString(serverInfo.adr), netadrtype_t::NA_UNSPEC);
+    CL_Connect(NET_AdrToStringwPort(serverInfo.adr), netadrtype_t::NA_UNSPEC);
 }
 
 qboolean UILANGameClass::KeyEvent(int key, unsigned int time)
@@ -197,7 +205,7 @@ qboolean UILANGameClass::KeyEvent(int key, unsigned int time)
 LANGameItem::LANGameItem() {}
 
 LANGameItem::LANGameItem(
-    const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping
+    const str& hostName, const str& mapName, const str& players, const str& gameTypeString, const str& ping, const str& ipAddress
 )
 {
     strings[0] = hostName;
@@ -205,6 +213,12 @@ LANGameItem::LANGameItem(
     strings[2] = players;
     strings[3] = gameTypeString;
     strings[4] = ping;
+
+    //
+    // Added in OPM
+    //
+
+    strings[5] = ipAddress;
 }
 
 int LANGameItem::getListItemValue(int which) const

code/client/cl_uiloadsave.cpp

@@ -95,7 +95,7 @@ UIFAKKLoadGameClass::UIFAKKLoadGameClass()
 {
     Connect(this, EV_UIListBase_ItemDoubleClicked, EV_UIListBase_ItemDoubleClicked);
     Connect(this, EV_UIListBase_ItemSelected, EV_UIListBase_ItemSelected);
-    AllowActivate(false);
+    AllowActivate(true);
     m_bRemovePending = false;
 
     setHeaderFont("facfont-20");
@@ -287,7 +287,7 @@ qboolean UIFAKKLoadGameClass::KeyEvent(int key, unsigned int time)
         }
         break;
     default:
-        return UIListBase::KeyEvent(key, time);
+        return UIListCtrl::KeyEvent(key, time);
     }
 
     return qfalse;
@@ -333,6 +333,7 @@ str FAKKLoadGameItem::getListItemString(int which) const
         {
             int numseconds;
             int numseconds_hours;
+            int seconds;
 
             // hours
             numseconds = atol(strings[1]);
@@ -341,17 +342,18 @@ str FAKKLoadGameItem::getListItemString(int which) const
 
             // minutes
             numseconds_hours = numseconds % 3600;
-            if (numseconds_hours / 60 <= 9) {
+            if (numseconds_hours / 60 < 10) {
                 itemstring += "0";
             }
             itemstring += (numseconds_hours / 60);
             itemstring += ":";
 
             // seconds
-            if (numseconds_hours / 60 <= 9) {
+            seconds = numseconds_hours % 60;
+            if (seconds < 10) {
                 itemstring += "0";
             }
-            itemstring += (numseconds_hours % 60);
+            itemstring += seconds;
         }
         break;
     case 2:
@@ -360,7 +362,7 @@ str FAKKLoadGameItem::getListItemString(int which) const
             char   buffer[2048];
 
             time = atol(strings[2]);
-            strftime(buffer, sizeof(buffer), "%a %b %d %H:%M:%S %Y", localtime(&time));
+            strftime(buffer, sizeof(buffer), "%a %b %d %Y %H:%M:%S", localtime(&time));
             itemstring = buffer;
         }
         break;

code/client/cl_uimaprotationsetup.cpp

@@ -76,7 +76,7 @@ void UIMapRotationListBox::PopulateRotationList()
         maplistVar = Cvar_Get("ui_maplist_ffa", "", 0);
     }
 
-    strcpy(mapBuffer, maplistVar->string);
+    Q_strncpyz(mapBuffer, maplistVar->string, sizeof(mapBuffer));
 
     for (token = strtok(mapBuffer, " /"); token; token = strtok(NULL, " /")) {
         if (!Q_stricmp(token, "dm")) {
@@ -143,7 +143,7 @@ void UIMapListBox::PopulateMapList()
         bool        bHasTOW = false;
         bool        bHasLib = false;
 
-        strcpy(mapName, filename);
+        Q_strncpyz(mapName, filename, sizeof(mapName));
         mapName[strlen(mapName) - 4] = 0;
 
         if (!COM_IsMapValid(mapName)) {
@@ -151,7 +151,7 @@ void UIMapListBox::PopulateMapList()
         }
 
         if (bTugOfWar || bLiberation) {
-            strcpy(tokenized, mapName);
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
 
             for (token = strtok(tokenized, "_"); token; token = strtok(NULL, "_")) {
                 if (bLiberation) {
@@ -181,7 +181,7 @@ void UIMapListBox::PopulateMapList()
                 }
             }
         } else if (bObjective) {
-            strcpy(tokenized, mapName);
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
 
             for (token = strtok(tokenized, "_"); token; token = strtok(NULL, "_")) {
                 if (!Q_stricmp(token, "obj")) {
@@ -209,9 +209,9 @@ void UIMapListBox::PopulateMapList()
             char        mapName[256];
             char        tokenized[256];
 
-            strcpy(mapName, filename);
+            Q_strncpyz(mapName, filename, sizeof(mapName));
             mapName[strlen(mapName) - 4] = 0;
-            strcpy(tokenized, mapName);
+            Q_strncpyz(tokenized, mapName, sizeof(tokenized));
 
             token = strtok(tokenized, "_");
             if (!Q_stricmp(token, "obj") || !Q_stricmp(mapName, "mp_ship_lib")) {
@@ -237,7 +237,7 @@ void UIMapListBox::PopulateMapList()
                 const char *filename = filenames[i];
                 char        mapName[256];
 
-                strcpy(mapName, filename);
+                Q_strncpyz(mapName, filename, sizeof(mapName));
                 mapName[strlen(mapName) - 4] = 0;
 
                 if (!COM_IsMapValid(mapName)) {
@@ -277,20 +277,27 @@ void UIAddToRotationButton::Released(Event *ev)
 
     if (mapList && rotationList) {
         size_t mapLength = 0;
-        int    item      = mapList->getCurrentItem();
+        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) {
-            str text = mapList->getItemText(item);
-
-            if (prefixLength + mapLength + text.length() < 256) {
-                rotationList->AddItem(text, NULL);
-            }
+        if (item && prefixLength + mapLength + currentItemText.length() < 256) {
+            rotationList->AddItem(currentItemText, NULL);
         }
     }
 
@@ -356,7 +363,7 @@ void UIRotationApplyButton::Released(Event *ev)
             char        map[256];
             bool        bHasTOW = false, bHasObj = false, bHasLib = false, bHasShip = false;
 
-            strcpy(map, text);
+            Q_strncpyz(map, text, sizeof(map));
             for (token = strtok(map, "_"); token; token = strtok(NULL, "_")) {
                 if (!Q_stricmp(token, "TOW")) {
                     bHasTOW = true;
@@ -387,11 +394,12 @@ void UIRotationApplyButton::Released(Event *ev)
             }
 
             maplistStr += text;
-            maplistStr += " ";
 
             if (i == 1) {
                 Cvar_Set("ui_dmmap", maplistStr);
             }
+
+            maplistStr += " ";
         }
     }
 
@@ -413,10 +421,10 @@ void UIRotationMoveItemUpButton::Released(Event *ev)
     list = static_cast<UIListBox *>(uWinMan.FindWidget("Rotation List"));
     item = list->getCurrentItem();
 
-    if (item < list->getNumItems() && list->getNumItems() > 1) {
-        str text = list->getItemText(item + 1);
+    if (item > 1 && list->getNumItems() > 1) {
+        str text = list->getItemText(item - 1);
 
-        list->DeleteItem(list->getCurrentItem() - 1);
+        list->DeleteItem(item - 1);
         list->InsertItem(text, item);
         list->setCurrentItem(item - 1);
     }
@@ -440,7 +448,7 @@ void UIRotationMoveItemDownButton::Released(Event *ev)
     if (item < list->getNumItems() && list->getNumItems() > 1) {
         str text = list->getItemText(item + 1);
 
-        list->DeleteItem(list->getCurrentItem() + 1);
+        list->DeleteItem(item + 1);
         list->InsertItem(text, item);
         list->setCurrentItem(item + 1);
     }

code/client/cl_uimaprunner.cpp

@@ -83,7 +83,7 @@ void PickFile(const char *name, Listener *obj, Event& event)
     if (name && *name && strchr(name, '/')) {
         currentpath = name;
 
-        for (i = currentpath.length(); i > 0; i--) {
+        for (i = currentpath.length() - 1; i > 0; i--) {
             if (currentpath[i] == '/') {
                 break;
             }

code/client/cl_uiminicon.cpp

@@ -112,7 +112,7 @@ void FakkMiniconsole::PostMoveinEvent(void)
 
 void FakkMiniconsole::OnSizeChanged(Event *ev)
 {
-    m_maxlines = m_frame.size.height / m_font->getHeight(false);
+    m_maxlines = m_frame.size.height / m_font->getHeight(getHighResScale());
 }
 
 void FakkMiniconsole::MoveInEvent(Event *ev)
@@ -163,14 +163,14 @@ void FakkMiniconsole::Draw(void)
     HandleBoxMoving();
 
     m_font->setColor(m_foreground_color);
-    aty = m_frame.size.height - m_font->getHeight(false);
+    aty = m_frame.size.height - m_font->getHeight(getHighResScale());
     for (i = m_lines.NumObjects(); i > 0; i--) {
-        if (-m_font->getHeight(false) >= aty) {
+        if (-m_font->getHeight(getHighResScale()) >= aty) {
             break;
         }
 
-        m_font->Print(0, aty, m_lines.ObjectAt(i), -1, false);
-        aty -= m_font->getHeight(false);
+        m_font->Print(0, aty / getHighResScale()[1], m_lines.ObjectAt(i), -1, getHighResScale());
+        aty -= m_font->getHeight(getHighResScale());
     }
 }
 

code/client/cl_uimpmappicker.cpp

@@ -51,7 +51,7 @@ MpMapPickerClass::MpMapPickerClass()
     window = new UIFloatingWindow();
     window->Create(
         NULL,
-        UIRect2D((cls.glconfig.vidWidth - 300) / 2, (cls.glconfig.vidHeight - 200) / 2, 300, 200),
+        UIRect2D((uid.vidWidth - 300) / 2, (uid.vidHeight - 200) / 2, 300, 200),
         "Select a Map",
         UColor(0.15f, 0.195f, 0.278f),
         UHudColor

code/client/cl_uiplayermodelpicker.cpp

@@ -82,8 +82,8 @@ static const PMPickerModel_t pickerModels[] = {
     {"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"             },
+//    {"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"             },
@@ -155,7 +155,7 @@ PlayerModelPickerClass::PlayerModelPickerClass()
     window = new UIFloatingWindow();
     window->Create(
         NULL,
-        UIRect2D((cls.glconfig.vidWidth - 400) / 2, (cls.glconfig.vidHeight - 300) / 2, 400, 300),
+        UIRect2D((uid.vidWidth - 400) / 2, (uid.vidHeight - 300) / 2, 400, 300),
         "Player Model Select...",
         UColor(0.15f, 0.195f, 0.278f),
         UHudColor

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.h

@@ -22,34 +22,61 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #pragma once
 
-class UIFAKKServerList : public UIListCtrl {
-protected:
-	// need a new struct instead of gamespy
-	struct GServerListImplementation *m_serverList[2];
-	bool m_bHasList;
-	bool m_bLANListing;
+#include "../gamespy/goaceng.h"
 
-public:
-	CLASS_PROTOTYPE( UIFAKKServerList );
+#define NUM_SERVERLISTS 2
 
-	bool m_bGettingList[2];
-	bool m_bUpdatingList;
+struct FAKKServerListInstance {
+    int                     iServerType;
+    class UIFAKKServerList *serverList;
+};
 
+class UIFAKKServerList : public UIListCtrl
+{
+    friend class FAKKServerListItem;
+
+public:
+    CLASS_PROTOTYPE(UIFAKKServerList);
+
+protected:
+    // need a new struct instead of gamespy
+    struct GServerListImplementation *m_serverList[NUM_SERVERLISTS];
+    bool                              m_bHasList;
+    bool                              m_bLANListing;
+
+public:
+    bool m_bGettingList[NUM_SERVERLISTS];
+    bool m_bUpdatingList;
+
+private:
+    // Added in OPM
+    //  Servers count
+    FAKKServerListInstance m_ServerListInst[NUM_SERVERLISTS];
+    int                    m_iServerQueryCount;
+    int                    m_iServerTotalCount;
+    int                    m_iTotalNumPlayers;
+    bool                   m_bDoneUpdating[NUM_SERVERLISTS];
+    bool                   m_NeedAdditionalLANSearch;
+
 protected:
-	void			SelectServer( Event *ev );
-	void			ConnectServer( Event *ev );
-	qboolean		KeyEvent( int key, unsigned int time ) override;
-	void			UpdateUIElement( void ) override;
-	void			RefreshServerList( Event *ev );
-	void			RefreshLANServerList( Event *ev );
-	void			CancelRefresh( Event *ev );
-	void			NewServerList( void );
-	void			MakeLANListing( Event *ev );
-	void			UpdateServer( Event *ev );
-	static int		ServerCompareFunction( const UIListCtrlItem *i1, const UIListCtrlItem *i2, int columnname );
+    void     SelectServer(Event *ev);
+    void     ConnectServer(Event *ev);
+    qboolean KeyEvent(int key, unsigned int time) override;
+    void     UpdateUIElement(void) override;
+    void     RefreshServerList(Event *ev);
+    void     RefreshLANServerList(Event *ev);
+    void     CancelRefresh(Event *ev);
+    void     NewServerList(void);
+    void     MakeLANListing(Event *ev);
+    void     UpdateServer(Event *ev);
+    void     RefreshStatus();
+
+    static int  ServerCompareFunction(const UIListCtrlItem *i1, const UIListCtrlItem *i2, int columnname);
+    static void UpdateServerListCallBack(GServerList serverlist, int msg, void *instance, void *param1, void *param2);
+
 public:
-	UIFAKKServerList();
+    UIFAKKServerList();
 
-	void		Draw( void ) override;
-	void		SortByColumn( int column ) override;
+    void Draw(void) override;
+    void SortByColumn(int column) override;
 };

code/client/cl_uistd.cpp

@@ -439,8 +439,11 @@ 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;
+    float     fvWidth, fvHeight;
 
     col[0] = col[1] = col[2] = col[3] = 1.0;
 
@@ -475,11 +478,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,11 +489,38 @@ void UIFakkLabel::DrawStatbar(float frac)
                 {
                     float width = frac * m_frame.size.width;
 
-                    re.DrawTilePic(0.0, 0.0, width, m_frame.size.height, m_statbar_material->GetMaterial());
+                    fvWidth = m_frame.size.width / m_vVirtualScale[0] / uii.Rend_GetShaderWidth(m_statbar_material->GetMaterial());
+                    fvHeight = m_frame.size.height / m_vVirtualScale[1] / uii.Rend_GetShaderHeight(m_statbar_material->GetMaterial());
+
+                    re.DrawStretchPic(0.0, 0.0, width, m_frame.size.height, 0, 0, fvWidth, fvHeight, m_statbar_material->GetMaterial());
+                    //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);
-                        re.DrawTilePic(0.0, 0.0, width, m_frame.size.height, m_statbar_material_flash->GetMaterial());
+
+                        fvWidth = m_frame.size.width / m_vVirtualScale[0] / uii.Rend_GetShaderWidth(m_statbar_material_flash->GetMaterial());
+                        fvHeight = m_frame.size.height / m_vVirtualScale[1] / uii.Rend_GetShaderHeight(m_statbar_material_flash->GetMaterial());
+
+                        re.DrawStretchPic(0.0, 0.0, width, m_frame.size.height, 0, 0, fvWidth, fvHeight, m_statbar_material_flash->GetMaterial());
+                        //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;
                 }
@@ -505,12 +531,39 @@ void UIFakkLabel::DrawStatbar(float frac)
                 {
                     float y = m_frame.size.height * (1.0 - frac);
 
-                    re.DrawTilePic(0.0, y, m_frame.size.width, m_frame.size.height, m_statbar_material->GetMaterial());
+                    fvWidth = m_frame.size.width / m_vVirtualScale[0] / uii.Rend_GetShaderWidth(m_statbar_material->GetMaterial());
+                    fvHeight = m_frame.size.height / m_vVirtualScale[1] / uii.Rend_GetShaderHeight(m_statbar_material->GetMaterial());
+
+                    re.DrawStretchPic(0.0, y, m_frame.size.width, m_frame.size.height, 0, 0, fvWidth, fvHeight, m_statbar_material->GetMaterial());
+                    //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);
-                        re.DrawTilePic(
-                            0.0, y, m_frame.size.width, m_frame.size.height, m_statbar_material_flash->GetMaterial()
+
+                        fvWidth = m_frame.size.width / m_vVirtualScale[0] / uii.Rend_GetShaderWidth(m_statbar_material_flash->GetMaterial());
+                        fvHeight = m_frame.size.height / m_vVirtualScale[1] / uii.Rend_GetShaderHeight(m_statbar_material_flash->GetMaterial());
+
+                        re.DrawStretchPic(0.0, y, m_frame.size.width, m_frame.size.height, 0, 0, fvWidth, fvHeight, m_statbar_material_flash->GetMaterial());
+                        //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;
@@ -542,6 +595,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:
@@ -569,6 +640,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_REVERSE:
@@ -891,8 +980,8 @@ void UIFakkLabel::DrawStatRotator(float frac)
     vNeedleDir[0] = fSinVal;
     vNeedleDir[1] = -fCosVal;
 
-    vSize[0] = (m_frame.size.width + m_frame.size.height) / m_frame.size.width * m_angles[2] * m_vVirtualScale[0];
-    vSize[1] = (m_frame.size.width + m_frame.size.height) / m_frame.size.height * m_scale * m_vVirtualScale[1];
+    vSize[0] = (m_frame.size.width + m_frame.size.height) / m_frame.size.width * m_angles[2] * getVirtualScale()[0];
+    vSize[1] = (m_frame.size.width + m_frame.size.height) / m_frame.size.height * m_scale * getVirtualScale()[1];
 
     vCenter[0] = (m_frame.size.width * 0.5f - vSize[0]) * vNeedleDir[0] + m_frame.size.width * 0.5f;
     vCenter[1] = (m_frame.size.height * 0.5f - vSize[1]) * vNeedleDir[1] + m_frame.size.height * 0.5f;
@@ -1287,7 +1376,7 @@ void UIFakkLabel::Draw(void)
                 m_iFontAlignmentVertical,
                 Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(cl.snap.ps.stats[m_stat_configstring]))),
                 UBlack,
-                m_bVirtual ? m_vVirtualScale : NULL
+                getVirtualScale()
             );
         } else {
             m_font->PrintJustified(
@@ -1295,7 +1384,7 @@ void UIFakkLabel::Draw(void)
                 m_iFontAlignmentHorizontal,
                 m_iFontAlignmentVertical,
                 Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(cl.snap.ps.stats[m_stat_configstring]))),
-                m_bVirtual ? m_vVirtualScale : NULL
+                getVirtualScale()
             );
         }
         return;
@@ -1314,7 +1403,7 @@ void UIFakkLabel::Draw(void)
                     m_iFontAlignmentVertical,
                     va("%d", delta),
                     UBlack,
-                    m_bVirtual ? m_vVirtualScale : NULL
+                    getVirtualScale()
                 );
             } else {
                 m_font->PrintJustified(
@@ -1322,7 +1411,7 @@ void UIFakkLabel::Draw(void)
                     m_iFontAlignmentHorizontal,
                     m_iFontAlignmentVertical,
                     va("%d", delta),
-                    m_bVirtual ? m_vVirtualScale : NULL
+                    getVirtualScale()
                 );
             }
             return;
@@ -1393,6 +1482,12 @@ void UIFakkLabel::Draw(void)
             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) {
@@ -1402,7 +1497,7 @@ void UIFakkLabel::Draw(void)
                 m_iFontAlignmentVertical,
                 Sys_LV_CL_ConvertString(va("%s", CL_ConfigString(CS_WEAPONS + cl.snap.ps.activeItems[m_itemindex]))),
                 UBlack,
-                m_bVirtual ? m_vVirtualScale : NULL
+                getVirtualScale()
             );
         } else {
             m_font->PrintJustified(
@@ -1410,7 +1505,7 @@ void UIFakkLabel::Draw(void)
                 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
+                getVirtualScale()
             );
         }
 

code/client/cl_uiview3d.h

@@ -51,6 +51,9 @@ protected:
     void OnDeactivate(Event *ev);
     void DrawSubtitleOverlay(void);
 
+    // Added in 2.0
+    void DrawNetProfile(void);
+
 public:
     View3D();
 

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;
@@ -353,12 +383,14 @@ 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;
 	fontInfo_t	consoleFont;
+
+	int refSequence;
 } clientStatic_t;
 
 extern clientStatic_t	cls;
@@ -385,6 +417,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 +479,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;
@@ -499,6 +559,10 @@ void UI_LoadResource( const char *name );
 
 qboolean CL_CheckPaused(void);
 
+int CL_GetRefSequence(void);
+qboolean CL_IsRendererLoaded(void);
+void CL_ApplyOriginalConfigTweaks();
+
 //
 // cl_input
 //
@@ -518,8 +582,10 @@ extern	qboolean	in_guimouse;
 void IN_ToggleMouse( void );
 void IN_MouseOn( void );
 void IN_MouseOff( void );
+void CL_UpdateMouse();
 
 void CL_InitInput (void);
+void CL_ShutdownInput(void);
 void CL_SendCmd (void);
 void CL_ClearState (void);
 void CL_ReadPackets (void);
@@ -545,6 +611,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 +653,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 +741,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_main_new.cpp

@@ -592,4 +592,29 @@ 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

@@ -86,6 +86,10 @@ 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
 }
 #endif

code/client/qal.c

@@ -81,6 +81,7 @@ LPALGENBUFFERS qalGenBuffers;
 LPALDELETEBUFFERS qalDeleteBuffers;
 LPALISBUFFER qalIsBuffer;
 LPALBUFFERDATA qalBufferData;
+LPALBUFFERI qalBufferi;
 LPALGETBUFFERF qalGetBufferf;
 LPALGETBUFFERFV qalGetBufferfv;
 LPALGETBUFFERI qalGetBufferi;
@@ -201,6 +202,7 @@ qboolean QAL_Init(const char *libname)
 	qalDeleteBuffers = GPA("alDeleteBuffers");
 	qalIsBuffer = GPA("alIsBuffer");
 	qalBufferData = GPA("alBufferData");
+	qalBufferi = GPA("alBufferi");
 	qalGetBufferf = GPA("alGetBufferf");
 	qalGetBufferfv = GPA("alGetBufferfv");
 	qalGetBufferi = GPA("alGetBufferi");

code/client/qal.h

@@ -36,15 +36,18 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #ifdef USE_LOCAL_HEADERS
 #include "../AL/al.h"
 #include "../AL/alc.h"
+#include "../AL/alext.h"
 #else
 #if defined(_MSC_VER) || defined(__APPLE__)
   // MSVC users must install the OpenAL SDK which doesn't use the AL/*.h scheme.
   // OSX framework also needs this
   #include <al.h>
   #include <alc.h>
+  #include <alext.h>
 #else
   #include <AL/al.h>
   #include <AL/alc.h>
+  #include <AL/alext.h>
 #endif
 #endif
 
@@ -120,7 +123,7 @@ extern LPALBUFFERDATA qalBufferData;
 extern LPALBUFFERF qalBufferf;
 extern LPALBUFFER3F qalBuffer3f;
 extern LPALBUFFERFV qalBufferfv;
-extern LPALBUFFERF qalBufferi;
+extern LPALBUFFERI qalBufferi;
 extern LPALBUFFER3F qalBuffer3i;
 extern LPALBUFFERFV qalBufferiv;
 extern LPALGETBUFFERF qalGetBufferf;

code/client/snd_codec.h

@@ -34,11 +34,12 @@ extern "C" {
 typedef struct snd_info_s
 {
 	int rate;
-	int width;
+	float width;
 	int channels;
 	int samples;
 	int size;
 	int dataofs;
+	int dataalign;
 } snd_info_t;
 
 typedef struct snd_codec_s snd_codec_t;

code/client/snd_codec_mp3.c

@@ -622,7 +622,7 @@ int S_MP3_CodecReadStream(snd_stream_t* stream, int bytes, void* buffer)
     mp3info = stream->ptr;
 
     // Make sure we get complete frames all the way through.
-    bytes -= bytes % (stream->info.channels * stream->info.width);
+    bytes -= fmod(bytes, (stream->info.channels * stream->info.width));
 
     if (mp3info->buflen)
     {

code/client/snd_codec_wav.c

@@ -133,6 +133,7 @@ static qboolean S_ReadRIFFHeader(fileHandle_t file, snd_info_t *info)
 	char dump[16];
 	int bits;
 	int fmtlen = 0;
+	int bytealign;
 
 	// skip the riff wav header
 	FS_Read(dump, 12, file);
@@ -149,17 +150,22 @@ static qboolean S_ReadRIFFHeader(fileHandle_t file, snd_info_t *info)
 	info->channels = FGetLittleShort(file);
 	info->rate = FGetLittleLong(file);
 	FGetLittleLong(file);
-	FGetLittleShort(file);
+	bytealign = FGetLittleShort(file);
 	bits = FGetLittleShort(file);
 
-	if( bits < 8 )
-	{
-	  Com_Printf( S_COLOR_RED "ERROR: Less than 8 bit sound is not supported\n");
-	  return qfalse;
-	}
+	//if( bits < 8 )
+	//{
+	//  Com_Printf( S_COLOR_RED "ERROR: Less than 8 bit sound is not supported\n");
+	//  return qfalse;
+	//}
 
-	info->width = bits / 8;
+	info->width = bits / 8.0;
 	info->dataofs = 0;
+	if (bits == 16) {
+		info->dataalign = 1;
+	} else {
+		info->dataalign = (bytealign / info->channels - 4) / 4 * 8 + 1;
+	}
 
 	// Skip the rest of the format chunk if required
 	if(fmtlen > 16)

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;

code/client/snd_dma_new.cpp

@@ -104,7 +104,7 @@ void S_Init(qboolean full_startup)
     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_khz            = Cvar_Get("s_khz", "44", 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);
@@ -280,15 +280,25 @@ S_BeginRegistration
 */
 void S_BeginRegistration()
 {
+    int i;
+
     Com_Printf("------- Sound Begin Registration -------\n");
 
     S_StopAllSounds(true);
 
-    ++s_registrationSequence;
+    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{};
+    }
 }
 
 /*
@@ -542,7 +552,7 @@ void S_StartLocalSound(const char *sound_name, qboolean force_load)
     }
 
     S_StartSound(
-        0,
+        NULL,
         s_iListenerNumber,
         CHAN_MENU,
         sfxHandle,
@@ -739,6 +749,10 @@ void S_Play()
     int  i;
     char name[MAX_QPATH];
 
+    if (Cmd_Argc() < 2) {
+        return;
+    }
+
     for (i = 1; i < Cmd_Argc(); i++) {
         if (strrchr(Cmd_Argv(i), '.')) {
             Q_strncpyz(name, Cmd_Argv(i), sizeof(name));

code/client/snd_info.cpp

@@ -34,7 +34,7 @@ void load_sfx_info()
     sfx_infos[0].max_factor         = -1.0;
     sfx_infos[0].loop_start         = -1;
     sfx_infos[0].loop_end           = -1;
-    sfx_infos[0].max_number_playing = 5;
+    sfx_infos[0].max_number_playing = DEFAULT_SFX_NUMBER_PLAYING;
     number_of_sfx_infos             = 1;
 
     for (current_sound_file = 0; current_sound_file < 10; current_sound_file++) {
@@ -62,7 +62,7 @@ void load_sfx_info()
                     sfx_infos[number_of_sfx_infos].max_factor         = -1.f;
                     sfx_infos[number_of_sfx_infos].loop_start         = -1;
                     sfx_infos[number_of_sfx_infos].loop_end           = -1;
-                    sfx_infos[number_of_sfx_infos].max_number_playing = 5;
+                    sfx_infos[number_of_sfx_infos].max_number_playing = DEFAULT_SFX_NUMBER_PLAYING;
                     number_of_sfx_infos++;
                 }
             } else if (!Q_stricmp(token, "loopstart")) {

code/client/snd_local_new.h

@@ -36,6 +36,22 @@ extern cvar_t *s_separation;
 extern cvar_t *s_musicVolume;
 extern cvar_t *s_ambientVolume;
 
+#define MAX_SOUNDSYSTEM_CHANNELS_3D        32
+#define MAX_SOUNDSYSTEM_CHANNELS_2D        32
+#define MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM 32
+#define MAX_SOUNDSYSTEM_POSITION_CHANNELS  (MAX_SOUNDSYSTEM_CHANNELS_3D + MAX_SOUNDSYSTEM_CHANNELS_2D + MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM)
+#define MAX_SOUNDSYSTEM_SONGS              2
+#define MAX_SOUNDSYSTEM_MISC_CHANNELS      3
+#define MAX_SOUNDSYSTEM_CHANNELS                                                                             \
+    (MAX_SOUNDSYSTEM_CHANNELS_3D + MAX_SOUNDSYSTEM_CHANNELS_2D + MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM + MAX_SOUNDSYSTEM_SONGS \
+     + MAX_SOUNDSYSTEM_MISC_CHANNELS)
+#define MAX_SOUNDSYSTEM_LOOP_SOUNDS 64
+
+#define SOUNDSYSTEM_CHANNEL_MP3_ID \
+    (MAX_SOUNDSYSTEM_CHANNELS_3D + MAX_SOUNDSYSTEM_CHANNELS_2D + MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM + MAX_SOUNDSYSTEM_SONGS)
+#define SOUNDSYSTEM_CHANNEL_TRIGGER_MUSIC_ID (SOUNDSYSTEM_CHANNEL_MP3_ID + 1)
+#define SOUNDSYSTEM_CHANNEL_MOVIE_ID         (SOUNDSYSTEM_CHANNEL_TRIGGER_MUSIC_ID + 1)
+
 typedef struct {
     int   format;
     float rate;
@@ -46,6 +62,7 @@ typedef struct {
 
     int dataofs;
     int datasize;
+    int dataalign;
 } wavinfo_t;
 
 typedef struct sfx_s {
@@ -134,7 +151,7 @@ typedef struct {
 } channelbasesavegame_t;
 
 typedef struct {
-    channelbasesavegame_t Channels[96];
+    channelbasesavegame_t Channels[MAX_SOUNDSYSTEM_CHANNELS];
 } soundsystemsavegame_t;
 
 enum channel_flags_t {
@@ -162,6 +179,7 @@ enum loopsound_flags_t {
 #define MAX_SFX         1400
 #define MAX_SFX_INFOS   1000
 #define MAX_LOOP_SOUNDS 64
+#define DEFAULT_SFX_NUMBER_PLAYING 10 //5
 
 extern qboolean   s_bLastInitSound;
 extern qboolean   s_bSoundStarted;

code/client/snd_mem_new.cpp

@@ -43,13 +43,13 @@ short int GetLittleShort()
         byte  bytes[2];
     } val;
 
-#    ifdef Q3_LITTLE_ENDIAN
+#ifdef Q3_LITTLE_ENDIAN
     val.bytes[0] = data_p[0];
     val.bytes[1] = data_p[1];
-#    else
+#else
     val.bytes[0] = data_p[1];
     val.bytes[1] = data_p[0];
-#    endif
+#endif
 
     data_p += sizeof(short);
     return val.value;
@@ -67,17 +67,17 @@ int GetLittleLong()
         byte bytes[4];
     } val;
 
-#    ifdef Q3_LITTLE_ENDIAN
+#ifdef Q3_LITTLE_ENDIAN
     val.bytes[0] = data_p[0];
     val.bytes[1] = data_p[1];
     val.bytes[2] = data_p[2];
     val.bytes[3] = data_p[3];
-#    else
+#else
     val.bytes[0] = data_p[3];
     val.bytes[1] = data_p[2];
     val.bytes[2] = data_p[1];
     val.bytes[3] = data_p[0];
-#    endif
+#endif
 
     data_p += sizeof(int);
     return val.value;
@@ -97,13 +97,13 @@ void SetLittleShort(int i)
 
     val.value = i;
 
-#    ifdef Q3_LITTLE_ENDIAN
+#ifdef Q3_LITTLE_ENDIAN
     data_p[0] = val.bytes[0];
     data_p[1] = val.bytes[1];
-#    else
+#else
     data_p[0] = val.bytes[1];
     data_p[1] = val.bytes[0];
-#    endif
+#endif
 
     data_p += sizeof(short);
 }
@@ -122,17 +122,17 @@ void SetLittleLong(int i)
 
     val.value = i;
 
-#    ifdef Q3_LITTLE_ENDIAN
+#ifdef Q3_LITTLE_ENDIAN
     data_p[0] = val.bytes[0];
     data_p[1] = val.bytes[1];
     data_p[2] = val.bytes[2];
     data_p[3] = val.bytes[3];
-#    else
+#else
     data_p[0] = val.bytes[3];
     data_p[1] = val.bytes[2];
     data_p[2] = val.bytes[1];
     data_p[3] = val.bytes[0];
-#    endif
+#endif
 
     data_p += sizeof(int);
 }
@@ -203,7 +203,7 @@ void DumpChunks()
 
         iff_chunk_len = GetLittleLong();
 
-        Com_Printf("0x%x : %s (%d)\n", data_p - 4, str, iff_chunk_len);
+        Com_Printf("0x%p : %s (%d)\n", data_p - 4, str, iff_chunk_len);
 
         data_p += (iff_chunk_len + 1) & ~1;
     } while (data_p < (byte *)iff_end);
@@ -218,6 +218,7 @@ wavinfo_t GetWavinfo(const char *name, byte *wav, int wavlength)
 {
     wavinfo_t info;
     int       samples;
+    short     bytealign;
 
     memset(&info, 0, sizeof(wavinfo_t));
 
@@ -247,7 +248,9 @@ wavinfo_t GetWavinfo(const char *name, byte *wav, int wavlength)
     if (info.format == 17) {
         info.channels = GetLittleShort();
         info.rate     = (float)GetLittleLong();
-        data_p += 6;
+        data_p += 4;
+
+        bytealign  = GetLittleShort();
         info.width = (float)GetLittleShort() / 8.f;
         data_p += 2;
 
@@ -270,12 +273,16 @@ wavinfo_t GetWavinfo(const char *name, byte *wav, int wavlength)
             Com_Error(ERR_DROP, "Sound %s has a bad loop length", name);
         }
 
-        info.dataofs = 0;
+        info.dataofs   = data_p - wav;
+        info.datasize  = iff_chunk_len - bytealign + info.dataofs;
+        info.dataalign = (bytealign / info.channels - 4) / 4 * 8 + 1;
     } else if (info.format == 1) {
         info.channels = GetLittleShort();
         info.rate     = (float)GetLittleLong();
-        data_p += 6;
-        info.width = (float)(GetLittleShort() / 8);
+        data_p += 4;
+
+        bytealign  = GetLittleShort();
+        info.width = (float)GetLittleShort() / 8.f;
 
         FindChunk("data");
         if (!data_p) {
@@ -292,14 +299,16 @@ wavinfo_t GetWavinfo(const char *name, byte *wav, int wavlength)
             Com_Error(ERR_DROP, "Sound %s has a bad loop length", name);
         }
 
-        info.dataofs = data_p - wav;
+        info.dataofs   = data_p - wav;
+        info.datasize  = iff_chunk_len;
+        info.dataalign = (bytealign / info.channels - 4) / 4 * 8 + 1;
+        // dataalign should always be 1
+        assert(info.dataalign == 1);
     } else {
         Com_Printf("Microsoft PCM format only\n");
         return info;
     }
 
-    info.datasize = iff_chunk_len;
-
     return info;
 }
 
@@ -310,26 +319,24 @@ DownSampleWav
 */
 qboolean DownSampleWav(wavinfo_t *info, byte *wav, int wavlength, int newkhz, byte **newdata)
 {
-    int newdatasize;
-    byte* datap;
-    int i;
-    int ii;
-    int error;
-    int width;
-    int oldsamples;
-    int oldrate;
+    int   newdatasize;
+    byte *datap;
+    int   i;
+    int   ii;
+    int   error;
+    int   width;
+    int   oldsamples;
+    int   oldrate;
 
     newdatasize = 0;
-    datap = &wav[info->dataofs];
+    datap       = &wav[info->dataofs];
 
-    if (info->channels > 1)
-    {
+    if (info->channels > 1) {
         Com_DPrintf("Could not downsample WAV file. Stereo WAVs not supported!\n");
         return 0;
     }
 
-    if (info->format != 1 || !info->dataofs)
-    {
+    if (info->format != 1 || !info->dataofs) {
         Com_DPrintf("Could not downsample WAV file. Not PCM format!\n");
         return 0;
     }
@@ -348,29 +355,27 @@ qboolean DownSampleWav(wavinfo_t *info, byte *wav, int wavlength, int newkhz, by
         }
     }
 
-    oldsamples = info->samples;
-    oldrate = info->rate;
+    oldsamples    = info->samples;
+    oldrate       = info->rate;
     info->samples = newdatasize / width;
-    info->rate = (float)newkhz;
+    info->rate    = (float)newkhz;
     newdatasize += info->dataofs;
 
-    *newdata = (byte*)Z_TagMalloc(newdatasize, TAG_SOUND);
+    *newdata = (byte *)Z_TagMalloc(newdatasize, TAG_SOUND);
     memcpy(*newdata, wav, info->dataofs);
 
     iff_data = *newdata;
-    iff_end = *newdata + newdatasize;
+    iff_end  = *newdata + newdatasize;
     FindChunk("RIFF");
 
-    if (!data_p || strncmp((const char*)data_p + 8, "WAVE", 4u))
-    {
+    if (!data_p || strncmp((const char *)data_p + 8, "WAVE", 4u)) {
         Com_DPrintf("Missing RIFF/WAVE chunks\n");
         return 0;
     }
 
     iff_data = data_p + 12;
     FindChunk("fmt ");
-    if (!data_p)
-    {
+    if (!data_p) {
         Com_DPrintf("Missing fmt chunk\n");
         return 0;
     }
@@ -380,8 +385,7 @@ qboolean DownSampleWav(wavinfo_t *info, byte *wav, int wavlength, int newkhz, by
     data_p += 8;
 
     FindChunk("data");
-    if (!data_p)
-    {
+    if (!data_p) {
         Com_DPrintf("Missing data chunk\n");
         return 0;
     }
@@ -404,6 +408,8 @@ qboolean DownSampleWav(wavinfo_t *info, byte *wav, int wavlength, int newkhz, by
         datap += width;
     }
 
+    assert(iff_end - data_p == 0);
+
     return newdatasize;
 }
 
@@ -414,10 +420,7 @@ DownSampleWav_MILES
 */
 int DownSampleWav_MILES(wavinfo_t *info, byte *wav, int wavlength, int newkhz, byte **newdata)
 {
-    //STUB_DESC("sound stuff");
-    //return 0;
-    // FIXME: unimplemented
-    //  Fallback to software downsampling
+    // Fallback to software downsampling
     return DownSampleWav(info, wav, wavlength, newkhz, newdata);
 }
 
@@ -428,10 +431,10 @@ S_LoadSound
 */
 qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean force_load)
 {
-    int size;
+    int          size;
     fileHandle_t file_handle;
-    char tempName[MAX_RES_NAME + 1];
-    int realKhz;
+    char         tempName[MAX_RES_NAME + 1];
+    int          realKhz;
 
     sfx->buffer = 0;
 
@@ -440,14 +443,11 @@ qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean fo
     }
 
     if (streamed) {
-        //
-        // Added in 2.0
-        //  Will be loaded next time
         sfx->length = 5000;
-        sfx->width = 1;
+        sfx->width  = 1;
         sfx->iFlags |= SFX_FLAG_STREAMED;
         sfx->time_length = 5000.0;
-        sfx->data = NULL;
+        sfx->data        = NULL;
         return qtrue;
     }
 
@@ -460,22 +460,20 @@ qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean fo
     }
 
     size = FS_FOpenFileRead(fileName, &file_handle, qfalse, qtrue);
-    if (size <= 0)
-    {
+    if (size <= 0) {
         if (file_handle) {
             FS_FCloseFile(file_handle);
         }
         return qfalse;
     }
 
-    sfx->data = (byte*)Z_TagMalloc(size, TAG_SOUND);
+    sfx->data = (byte *)Z_TagMalloc(size, TAG_SOUND);
 
     FS_Read(sfx->data, size, file_handle);
     FS_FCloseFile(file_handle);
     sfx->info = GetWavinfo(fileName, sfx->data, size);
 
-    if (sfx->info.channels != 1 && !streamed)
-    {
+    if (sfx->info.channels != 1 && !streamed) {
         Com_Printf("%s is a stereo wav file\n", fileName);
         Z_Free(sfx->data);
         sfx->data = NULL;
@@ -500,8 +498,8 @@ qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean fo
     }
 
     if (!(sfx->iFlags & SFX_FLAG_STREAMED) && realKhz < sfx->info.rate) {
-        byte* newdata;
-        int newdatasize;
+        byte *newdata;
+        int   newdatasize;
 
         newdata = NULL;
         if (sfx->iFlags & SFX_FLAG_NO_OFFSET) {
@@ -512,12 +510,13 @@ qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean fo
 
         if (newdatasize) {
             Z_Free(sfx->data);
-            sfx->data = newdata;
+            sfx->data          = newdata;
+            sfx->info.datasize = newdatasize;
         }
     }
 
-    sfx->length = sfx->info.samples;
-    sfx->width = sfx->info.width;
+    sfx->length      = sfx->info.samples;
+    sfx->width       = sfx->info.width;
     sfx->time_length = sfx->info.samples / sfx->info.rate * 1000.f;
 
     if (sfx->iFlags & SFX_FLAG_STREAMED) {
@@ -525,7 +524,7 @@ qboolean S_LoadSound(const char *fileName, sfx_t *sfx, int streamed, qboolean fo
         sfx->data = NULL;
     }
 
-    sprintf(tempName, "k%s", fileName);
+    Com_sprintf(tempName, sizeof(tempName), "k%s", fileName);
     UI_LoadResource(tempName);
 
     if (strstr(fileName, "sound/null.wav")) {
@@ -543,7 +542,7 @@ S_LoadMP3
 */
 qboolean S_LoadMP3(const char *fileName, sfx_t *sfx)
 {
-    int length;
+    int          length;
     fileHandle_t file_handle;
 
     length = FS_FOpenFileRead(fileName, &file_handle, 0, 1);
@@ -555,9 +554,9 @@ qboolean S_LoadMP3(const char *fileName, sfx_t *sfx)
     }
 
     memset(&sfx->info, 0, sizeof(sfx->info));
-    sfx->data = (byte*)Z_TagMalloc(length, TAG_SOUND);
+    sfx->data   = (byte *)Z_TagMalloc(length, TAG_SOUND);
     sfx->length = length;
-    sfx->width = 1;
+    sfx->width  = 1;
     FS_Read(sfx->data, length, file_handle);
     FS_FCloseFile(file_handle);
 

code/client/snd_openal.c

@@ -233,7 +233,7 @@ static sfxHandle_t S_AL_BufferFind(const char *filename)
 		ptr = &knownSfx[sfx];
 		memset(ptr, 0, sizeof(*ptr));
 		ptr->masterLoopSrc = -1;
-		strcpy(ptr->filename, filename);
+		Q_strncpyz(ptr->filename, filename, sizeof(ptr->filename));
 	}
 
 	// Return the handle

code/client/snd_openal_new.h

@@ -29,22 +29,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 typedef int          S32;
 typedef unsigned int U32;
 
-#define MAX_OPENAL_CHANNELS_3D        32
-#define MAX_OPENAL_CHANNELS_2D        32
-#define MAX_OPENAL_CHANNELS_2D_STREAM 32
-#define MAX_OPENAL_POSITION_CHANNELS  (MAX_OPENAL_CHANNELS_3D + MAX_OPENAL_CHANNELS_2D + MAX_OPENAL_CHANNELS_2D_STREAM)
-#define MAX_OPENAL_SONGS              2
-#define MAX_OPENAL_MISC_CHANNELS      3
-#define MAX_OPENAL_CHANNELS                                                                             \
-    (MAX_OPENAL_CHANNELS_3D + MAX_OPENAL_CHANNELS_2D + MAX_OPENAL_CHANNELS_2D_STREAM + MAX_OPENAL_SONGS \
-     + MAX_OPENAL_MISC_CHANNELS)
-#define MAX_OPENAL_LOOP_SOUNDS 64
-
-#define OPENAL_CHANNEL_MP3_ID \
-    (MAX_OPENAL_CHANNELS_3D + MAX_OPENAL_CHANNELS_2D + MAX_OPENAL_CHANNELS_2D_STREAM + MAX_OPENAL_SONGS)
-#define OPENAL_CHANNEL_TRIGGER_MUSIC_ID (OPENAL_CHANNEL_MP3_ID + 1)
-#define OPENAL_CHANNEL_MOVIE_ID         (OPENAL_CHANNEL_TRIGGER_MUSIC_ID + 1)
-
 #define MAX_STREAM_BUFFERS              16
 #define MAX_BUFFER_SAMPLES              16384
 
@@ -111,6 +95,8 @@ public:
 
     void  set_no_3d();
     void  set_3d();
+    void  set_no_virtualization();
+    void  set_virtualization();
 
     void set_gain(float gain);
     void set_velocity(float v0, float v1, float v2);
@@ -181,22 +167,26 @@ private:
 
     unsigned int getQueueLength() const;
     unsigned int getCurrentStreamPosition() const;
-    unsigned int getBytesPerSample() const;
+    unsigned int getBitsPerSample() const;
+};
+
+struct openal_movie_channel : public openal_channel {
+
 };
 
 struct openal_internal_t {
-    openal_channel              chan_3D[MAX_OPENAL_CHANNELS_3D];
-    openal_channel              chan_2D[MAX_OPENAL_CHANNELS_2D];
-    openal_channel_two_d_stream chan_2D_stream[MAX_OPENAL_CHANNELS_2D_STREAM];
-    openal_channel_two_d_stream chan_song[MAX_OPENAL_SONGS];
+    openal_channel              chan_3D[MAX_SOUNDSYSTEM_CHANNELS_3D];
+    openal_channel              chan_2D[MAX_SOUNDSYSTEM_CHANNELS_2D];
+    openal_channel_two_d_stream chan_2D_stream[MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM];
+    openal_channel_two_d_stream chan_song[MAX_SOUNDSYSTEM_SONGS];
     openal_channel_two_d_stream chan_mp3;
     openal_channel_two_d_stream chan_trig_music;
     openal_channel_two_d_stream chan_movie;
 
     // Pointers to channels
-    openal_channel *channel[MAX_OPENAL_CHANNELS];
+    openal_channel *channel[MAX_SOUNDSYSTEM_CHANNELS];
 
-    openal_loop_sound_t loop_sounds[MAX_OPENAL_LOOP_SOUNDS];
+    openal_loop_sound_t loop_sounds[MAX_SOUNDSYSTEM_LOOP_SOUNDS];
 
     openal_channel movieChannel;
     sfx_t          movieSFX;