Update test-pull_request.yaml

Update build-test.yaml
Update build-release.yaml
2026-11-07 18:31:26 -10:00 · 2025-06-09 09:51:29 -07:00 · 2025-06-09 09:50:22 -07:00 · 2025-06-09 09:49:15 -07:00 · 2025-06-09 09:47:05 -07:00
2246 changed files with 126660 additions and 282858 deletions
@@ -48,7 +48,5 @@ CheckOptions:
    value:        'std::vector;std::deque;std::list;SCP_vector;SCP_deque;SCP_list'
  - key:          'readability-braces-around-statements.ShortStatementLines'
    value:        '4' # Avoid flagging simple if (...) return false; statements
-  - key:          'performance-move-const-arg.CheckTriviallyCopyableMove' # This isn't actually performance relevant, but using move on trivially copyable types can well indicate that the variable should not be used anymore, such as when passing a builder type to the finialization function
-    value:        'false'
 ...

@@ -5,6 +5,9 @@ on:
    tags:
      - 'nightly_*'

+env:
+  QT_VERSION: 5.12.12
+
 jobs:
  build_linux:
    strategy:
@@ -18,25 +21,24 @@ jobs:
            arch: arm64
    name: Linux
    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: gcc-9
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
+        run: |
+          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -49,7 +51,7 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: linux-${{ matrix.configuration }}-${{ matrix.arch }}
          path: ${{ github.workspace }}/build/install/*.AppImage
@@ -57,26 +59,23 @@ jobs:
    name: Build Linux distribution zip
    needs: build_linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
        arch: [x86_64, arm64]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: linux-Release-${{ matrix.arch }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: linux-FastDebug-${{ matrix.arch }}
          path: builds
@@ -102,169 +101,119 @@ jobs:
    strategy:
      matrix:
        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
+        arch: [Win32, x64]
+        simd: [SSE2]
    name: Windows
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      # Tree A: static CRT (/MT) for FSO + FRED2 (no Qt dependency needed)
-      - name: Configure CMake (static CRT /MT - FSO + FRED2)
+      # - name: Cache Qt
+        # id: cache-qt-win
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt (32 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'Win32' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win32_msvc2017
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      # - name: Install Qt (64 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'x64' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win64_msvc2017_64
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
+      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          ARCHITECTURE: ${{ matrix.arch }}
          SIMD: ${{ matrix.simd }}
        shell: bash
        run: |
-          mkdir build-mt
-          cd build-mt
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=OFF -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (static CRT)
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION"
-          ls -alR "$(pwd)/install"
-      # Tree B: dynamic CRT (/MD) for QtFRED only (matches Qt's prebuilt /MD runtime)
-      # Skipped on Win32: Qt6 has no 32-bit Windows support, so CMake force-disables
-      # FSO_BUILD_QTFRED there and the qtfred target would not exist
-      - name: Configure CMake (dynamic CRT /MD - QtFRED)
-        if: matrix.arch != 'Win32'
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-md
-          cd build-md
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=OFF -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON \
-            -G "Visual Studio 18 2026" -T "v143" -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (dynamic CRT)
-        if: matrix.arch != 'Win32'
-        working-directory: ./build-md
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target qtfred -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION" --component qtFRED
-          ls -alR "$(pwd)/install"
-      # Merge both trees into the single install dir the zip job consumes
-      - name: Merge installs
-        shell: bash
-        run: |
-          mkdir -p build/install
-          # build-md does not exist on Win32 (no QtFRED there)
-          if [ -d build-md/install ]; then
-             cp -r build-md/install/. build/install/
+          mkdir build
+          cd build
+
+          if [ "$ARCHITECTURE" = "Win32" ]; then
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                -DFSO_INSTALL_DEBUG_FILES="ON" -DFSO_BUILD_WITH_VULKAN="OFF" -A "$ARCHITECTURE" \
+                -G "Visual Studio 16 2019" -T "v142" ..
+          else
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+                -G "Visual Studio 16 2019" -T "v142" ..
          fi
-          cp -r build-mt/install/. build/install/
-          ls -alR build/install
+      - name: Compile
+        working-directory: ./build
+        env:
+          CONFIGURATION: ${{ matrix.configuration }}
+          COMPILER: ${{ matrix.compiler }}
+        shell: bash
+        run: |
+          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
+          ls -alR "$(pwd)/install"
      - name: Run Tests
-        working-directory: ./build-mt
+        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
-          name: windows-${{ env.artifact_id }}
+          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*
  windows_zip:
    name: Build Windows distribution zip
    needs: build_windows
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
+        arch: [Win32, x64]
+        simd: [SSE2]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-Release-${{ env.artifact_id }}
+          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
+          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Create Distribution package
        working-directory: ./builds
        shell: bash
        env:
-          ID: ${{ env.artifact_id }}
+          ARCH: ${{ matrix.arch }}
+          SIMD: ${{ matrix.simd }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
      - name: Upload result package
        working-directory: ./builds
@@ -285,14 +234,32 @@ jobs:
    name: Mac
    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v7
+      # - name: Cache Qt
+        # id: cache-qt-mac
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt
+        # uses: jurplel/install-qt-action@v2
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
+          # setup-python: 'false'
+          # aqtversion: ==1.1.3
+          # py7zrversion: '==0.19.*'
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Set up test version
        shell: bash
        run: |
@@ -305,10 +272,11 @@ jobs:
          COMPILER: ${{ matrix.compiler }}
          ARCHITECTURE: ${{ matrix.arch }}
          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -334,7 +302,7 @@ jobs:
        # Ref: https://github.com/actions/runner-images/issues/2619
        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
@@ -342,27 +310,24 @@ jobs:
    name: Build Mac distribution zip
    needs: build_mac
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
        arch: [x86_64, arm64]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v2
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-Release-${{ matrix.arch }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-FastDebug-${{ matrix.arch }}
          path: builds
@@ -5,6 +5,9 @@ on:
    tags:
      - 'release_*'

+env:
+  QT_VERSION: 5.12.12
+
 jobs:
  create_release:
    name: Create GitHub release
@@ -47,27 +50,26 @@ jobs:
    name: Linux
    needs: create_release   # Don't run this job until create_release is done and successful
    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        # checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.
        name: Checkout
        with:
          submodules: true  # `true` to checkout submodules, `recursive` to recursively checkout submodules
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: gcc-9
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
+        run: |
+          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -80,7 +82,7 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        # Upload the url file for use with other runners
        # upload-artifact.inputs:
        #   if-no-files-found=warn  What to do if path fails to find any files.
@@ -97,29 +99,26 @@ jobs:
    name: Build Linux distribution zip
    needs: build_linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
        arch: [x86_64, arm64]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'  # value 0 to fetch all history and tags for all branches
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
        # Grab the release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: linux-Release-${{ matrix.arch }}
          path: builds
      - name: Download FastDebug builds
        # Grab the debug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: linux-FastDebug-${{ matrix.arch }}
          path: builds
@@ -136,7 +135,7 @@ jobs:
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
      - name: Upload result package
        # Stash the result to artifact filespace
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ steps.generate_package.outputs.package_name }}
          path: ${{ steps.generate_package.outputs.package_path }}
@@ -152,175 +151,123 @@ jobs:
    strategy:
      matrix:
        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, AVX, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
-          - os: windows-11-arm
-            simd: AVX
+        arch: [Win32, x64]
+        simd: [SSE2, AVX]
    needs: create_release
    name: Windows
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        # Checkout repo
        name: Checkout
        with:
          submodules: true
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      # Tree A: static CRT (/MT) for FSO + FRED2 (no Qt dependency needed)
-      - name: Configure CMake (static CRT /MT - FSO + FRED2)
+      # - name: Cache Qt
+        # # Cache Qt
+        # id: cache-qt-win
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt (32 bit)
+        # # Install Qt 32bit if matrix.arch == Win32
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'Win32' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win32_msvc2017
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      # - name: Install Qt (64 bit)
+        # # Install Qt 64bit if matrix.arch == x64
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'x64' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win64_msvc2017_64
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
+      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          ARCHITECTURE: ${{ matrix.arch }}
          SIMD: ${{ matrix.simd }}
        shell: bash
        run: |
-          mkdir build-mt
-          cd build-mt
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=OFF -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (static CRT)
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION"
-          ls -alR "$(pwd)/install"
-      # Tree B: dynamic CRT (/MD) for QtFRED only (matches Qt's prebuilt /MD runtime)
-      # Skipped on Win32: Qt6 has no 32-bit Windows support, so CMake force-disables
-      # FSO_BUILD_QTFRED there and the qtfred target would not exist
-      - name: Configure CMake (dynamic CRT /MD - QtFRED)
-        if: matrix.arch != 'Win32'
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-md
-          cd build-md
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=OFF -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON \
-            -G "Visual Studio 18 2026" -T "v143" -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (dynamic CRT)
-        if: matrix.arch != 'Win32'
-        working-directory: ./build-md
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target qtfred -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION" --component qtFRED
-          ls -alR "$(pwd)/install"
-      # Merge both trees into the single install dir the zip job consumes
-      - name: Merge installs
-        shell: bash
-        run: |
-          mkdir -p build/install
-          # build-md does not exist on Win32 (no QtFRED there)
-          if [ -d build-md/install ]; then
-             cp -r build-md/install/. build/install/
+          mkdir build
+          cd build
+
+          if [ "$ARCHITECTURE" = "Win32" ]; then
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                  -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                  -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                  -DFSO_INSTALL_DEBUG_FILES="ON" -DFSO_BUILD_WITH_VULKAN="OFF" -A "$ARCHITECTURE" \
+                  -G "Visual Studio 16 2019" -T "v142" ..
+          else
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                  -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                  -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                  -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+                  -G "Visual Studio 16 2019" -T "v142" ..
          fi
-          cp -r build-mt/install/. build/install/
-          ls -alR build/install
+      - name: Compile
+        working-directory: ./build
+        env:
+          CONFIGURATION: ${{ matrix.configuration }}
+          COMPILER: ${{ matrix.compiler }}
+        shell: bash
+        run: |
+          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
+          ls -alR "$(pwd)/install"
      - name: Run Tests
-        working-directory: ./build-mt
+        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
-          name: windows-${{ env.artifact_id }}
+          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*

  windows_zip:
    name: Build Windows distribution zip
    needs: build_windows
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      fail-fast: false  # Run the other jobs in the matrix instead of failing them
      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, AVX, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
-          - arch: ARM64
-            simd: AVX
+        arch: [Win32, x64]
+        simd: [SSE2, AVX]

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-Release-${{ env.artifact_id }}
+          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds

      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
+          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds

      - name: Create Distribution package
@@ -328,17 +275,18 @@ jobs:
        working-directory: ./builds
        shell: bash
        env:
-          ID: ${{ env.artifact_id }}
+          ARCH: ${{ matrix.arch }}
+          SIMD: ${{ matrix.simd }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows

      - name: Upload result package
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ steps.generate_package.outputs.package_name }}
          path: ${{ steps.generate_package.outputs.package_path }}

      - name: Upload debug package
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ steps.generate_package.outputs.debug_name }}
          path: ${{ steps.generate_package.outputs.debug_path }}
@@ -362,25 +310,43 @@ jobs:
    needs: create_release
    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v7
+      # - name: Cache Qt
+        # id: cache-qt-mac
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt
+        # uses: jurplel/install-qt-action@v2
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
+          # setup-python: 'false'
+          # aqtversion: ==1.1.3
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: 0
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: ${{ matrix.compiler }}
          ARCHITECTURE: ${{ matrix.arch }}
          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -406,7 +372,7 @@ jobs:
        # Ref: https://github.com/actions/runner-images/issues/2619
        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
@@ -414,27 +380,24 @@ jobs:
    name: Build Mac distribution zip
    needs: build_mac
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
        arch: [x86_64, arm64]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v2
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-Release-${{ matrix.arch }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-FastDebug-${{ matrix.arch }}
          path: builds
@@ -450,7 +413,7 @@ jobs:
          ARCH: ${{ matrix.arch }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
      - name: Upload result package
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ steps.generate_package.outputs.package_name }}
          path: ${{ steps.generate_package.outputs.package_path }}
@@ -5,28 +5,22 @@ on:
    branches:
      - 'test/*'

+env:
+  QT_VERSION: 5.12.12
+
 jobs:
  build_linux:
    strategy:
      matrix:
        configuration: [FastDebug, Release]
-        os: [ubuntu-latest, ubuntu-24.04-arm]
-        include:
-          - os: ubuntu-latest
-            arch: x86_64
-          - os: ubuntu-24.04-arm
-            arch: arm64
    name: Linux
-    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    runs-on: ubuntu-latest
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Set up test version
        shell: bash
        run: |
@@ -37,12 +31,14 @@ jobs:
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: gcc-9
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
+        run: |
+          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -55,46 +51,34 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
-          name: linux-${{ matrix.configuration }}-${{ matrix.arch }}
+          name: linux-${{ matrix.configuration }}
          path: ${{ github.workspace }}/build/install/*.AppImage
  linux_zip:
    name: Build Linux distribution zip
    needs: build_linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v2
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: linux-Release-${{ matrix.arch }}
+          name: linux-Release
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: linux-FastDebug-${{ matrix.arch }}
+          name: linux-FastDebug
          path: builds
-      - name: Fix permissions
-        working-directory: ./builds
-        shell: bash
-        run: chmod 755 *.AppImage
      - name: Create Distribution package
        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
      - name: Upload result package
        working-directory: ./builds
@@ -109,39 +93,51 @@ jobs:
    strategy:
      matrix:
        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
+        arch: [Win32, x64]
+        simd: [SSE2]
    name: Windows
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Set up test version
        shell: bash
        run: |
          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
          # Override the revision string so that the builds are named correctly
          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
+      # - name: Cache Qt
+        # id: cache-qt-win
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt (32 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'Win32' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win32_msvc2017
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      # - name: Install Qt (64 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.arch == 'x64' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win64_msvc2017_64
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -151,11 +147,20 @@ jobs:
        run: |
          mkdir build
          cd build
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DQT_USE_PRECOMPILED=ON -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
+
+          if [ "$ARCHITECTURE" = "Win32" ]; then
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                -DFSO_INSTALL_DEBUG_FILES="ON" -DFSO_BUILD_WITH_VULKAN="OFF" -A "$ARCHITECTURE" \
+                -G "Visual Studio 16 2019" -T "v142" ..
+          else
+              cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+                -DFSO_USE_VOICEREC="ON" -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
+                -DFSO_BUILD_QTFRED=OFF -DFSO_BUILD_TESTS=ON \
+                -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+                -G "Visual Studio 16 2019" -T "v142" ..
+          fi
      - name: Compile
        working-directory: ./build
        env:
@@ -171,72 +176,43 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
-          name: windows-${{ env.artifact_id }}
+          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*
  windows_zip:
    name: Build Windows distribution zip
    needs: build_windows
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
+        arch: [Win32, x64]
+        simd: [SSE2]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v2
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-Release-${{ env.artifact_id }}
+          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
+          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Create Distribution package
        working-directory: ./builds
        shell: bash
        env:
-          ID: ${{ env.artifact_id }}
+          ARCH: ${{ matrix.arch }}
+          SIMD: ${{ matrix.simd }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
      - name: Upload result package
        working-directory: ./builds
@@ -257,14 +233,32 @@ jobs:
    name: Mac
    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v7
+      # - name: Cache Qt
+        # id: cache-qt-mac
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt
+        # uses: jurplel/install-qt-action@v2
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
+          # setup-python: 'false'
+          # aqtversion: ==1.1.3
+          # py7zrversion: '==0.19.*'
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Set up test version
        shell: bash
        run: |
@@ -276,10 +270,11 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: ${{ matrix.compiler }}
          ARCHITECTURE: ${{ matrix.arch }}
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -305,7 +300,7 @@ jobs:
        # Ref: https://github.com/actions/runner-images/issues/2619
        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
      - name: Upload build result
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
        with:
          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
@@ -313,27 +308,24 @@ jobs:
    name: Build Mac distribution zip
    needs: build_mac
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
    strategy:
      matrix:
        arch: [x86_64, arm64]
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v2
        name: Checkout
        with:
          submodules: true
          fetch-depth: '0'
          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Download Release builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-Release-${{ matrix.arch }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
        with:
          name: mac-FastDebug-${{ matrix.arch }}
          path: builds
@@ -5,13 +5,15 @@ on:
    branches:
      - master

+env:
+  QT_VERSION: 5.12.12
+
 jobs:
  build_linux:
    strategy:
      matrix:
        configuration: [Debug, Release]
        compiler: [gcc-9, gcc-13, clang-16]
-        arch: [x86_64]
        cmake_options: [""]
        include:
          # Also include configurations that check if the code compiles without the graphics backends
@@ -23,20 +25,16 @@ jobs:
            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1
        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}-${{ matrix.arch }}
-          max-size: 750MB
+          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
      - name: Configure ccache
        run: |
          ccache --set-config=sloppiness=pch_defines,time_macros
@@ -48,51 +46,11 @@ jobs:
          COMPILER: ${{ matrix.compiler }}
          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
          CCACHE_PATH: /usr/local/bin/ccache
+          ENABLE_QTFRED: ON
+          Qt5_DIR: /qt/${{ env.QT_VERSION }}/gcc_64/lib/cmake/Qt5
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja -k 20 all
-      - name: Show CCache statistics
-        run: ccache --show-stats
-
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-        cmake_options: [""]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: ccache
-        uses: hendrikmuhs/[email protected]
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.arch }}
-          max-size: 750MB
-      - name: Configure ccache
-        run: |
-          ccache --set-config=sloppiness=pch_defines,time_macros
-          ccache -p
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja -k 20 all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
      - name: Show CCache statistics
        run: ccache --show-stats
@@ -33,7 +33,6 @@ env:
  NEBULA_PASSWORD: ${{ secrets.NEBULA_PASSWORD }}
  HLP_API: ${{ secrets.HLP_API }}
  HLP_KEY: ${{ secrets.HLP_KEY }}
-  FORUM_SECRET: ${{ secrets.FORUM_SECRET }}
  RELEASE_TAG: ${{ inputs.releaseTag }}

 jobs:
@@ -46,13 +45,11 @@ jobs:
        run: echo "github.event_name= ${{ github.event_name }}"

      - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v3
        with:
          fetch-depth: '0'
          ref: ${{ env.RELEASE_TAG }}
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
      - name: Install Python dependencies
        run: pip install -r ci/post/requirements.txt

@@ -70,7 +67,6 @@ jobs:
          HLP_API: ${{ secrets.HLP_API }}
          HLP_KEY: ${{ secrets.HLP_KEY }}
          RELEASE_TAG: ${{ inputs.releaseTag }}
-          FORUM_SECRET: ${{ secrets.FORUM_SECRET }}
        run: python ci/post/main.py release

      - name: Post Builds (Manual trigger)
@@ -2,6 +2,9 @@ name: Check a pull request

 on: [pull_request]

+env:
+  QT_VERSION: 5.12.12
+
 jobs:
  build_linux:
    strategy:
@@ -17,26 +20,23 @@ jobs:
          - configuration: Release
            compiler: gcc-13
            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          # - configuration: Debug
-          #   compiler: gcc-13
-          #   cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
-          # - configuration: Release
-          #   compiler: gcc-13
-          #   cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
+          - configuration: Debug
+            compiler: gcc-13
+            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
+          - configuration: Release
+            compiler: gcc-13
+            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1
        with:
          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
          save: false # Caches are created by a separate job and only restored for PRs
@@ -49,10 +49,12 @@ jobs:
          COMPILER: ${{ matrix.compiler }}
          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
          CCACHE_PATH: /usr/local/bin/ccache
+          ENABLE_QTFRED: ON
+          Qt5_DIR: /qt/${{ env.QT_VERSION }}/gcc_64/lib/cmake/Qt5
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja -k 20 all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -74,25 +76,48 @@ jobs:
  build_windows:
    strategy:
      matrix:
-        configuration: [Debug, FastDebug, Release]
+        configuration: [Debug, Release]
        compiler: [MSVC]
        arch: [Win32, x64]
    name: Windows
-    runs-on: windows-2025
+    runs-on: windows-2022
    steps:
      - name: Prepare Environment
        run: choco install ninja
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        if: matrix.compiler == 'MSVC'
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
+      # - name: Cache Qt
+        # id: cache-qt-win
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt (32 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'Win32' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win32_msvc2017
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      # - name: Install Qt (64 bit)
+        # uses: jurplel/install-qt-action@v2
+        # if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'x64' }}
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # arch: win64_msvc2017_64
+          # cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
+          # aqtversion: ==0.8
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -104,12 +129,23 @@ jobs:
          cd build

          if [ "$COMPILER" = "MinGW" ]; then
-              cmake -DFSO_USE_SPEECH=OFF -DFSO_FATAL_WARNINGS=ON -DFSO_USE_VOICEREC=OFF -DFSO_BUILD_TESTS=ON \
-                  -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
+              if [ "$ARCHITECTURE" = "Win32" ]; then
+                  cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+                      -DFSO_BUILD_FRED2="OFF" -DFSO_BUILD_WITH_VULKAN="OFF" -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
+              else
+                  cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+                      -DFSO_BUILD_FRED2="OFF" -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
+              fi
          else
-              cmake -DFSO_USE_SPEECH=ON -DFSO_FATAL_WARNINGS=ON -DFSO_USE_VOICEREC=OFF -DFSO_BUILD_TESTS=ON \
-                  -DFORCED_SIMD_INSTRUCTIONS=SSE2 -G "Visual Studio 18 2026" -T "v143"  -A "$ARCHITECTURE" \
-                  -DQT_USE_PRECOMPILED=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
+              if [ "$ARCHITECTURE" = "Win32" ]; then
+                  cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+                      -DFORCED_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -DFSO_BUILD_WITH_VULKAN="OFF" -G "Visual Studio 16 2019" \
+                      -DFSO_BUILD_QTFRED=OFF -T "v142" -A "$ARCHITECTURE" ..
+              else
+                  cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+                      -DFORCED_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "Visual Studio 16 2019" \
+                      -DFSO_BUILD_QTFRED=OFF -T "v142" -A "$ARCHITECTURE" ..
+              fi
          fi
      - name: Compile
        working-directory: ./build
@@ -146,32 +182,48 @@ jobs:
    name: Mac
    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v7
+      # - name: Cache Qt
+        # id: cache-qt-mac
+        # uses: actions/cache@v1
+        # with:
+          # path: ${{ github.workspace }}/../Qt
+          # key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      # - name: Install Qt
+        # uses: jurplel/install-qt-action@v2
+        # with:
+          # version: ${{ env.QT_VERSION }}
+          # dir: ${{ github.workspace }}/..
+          # cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
+          # setup-python: 'false'
+          # aqtversion: ==1.1.3
+          # py7zrversion: '==0.19.*'
+      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1
        with:
          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}-${{ matrix.arch }}
          save: false # Caches are created by a separate job and only restored for PRs
-      - name: Configure ccache
-        run: ccache --set-config=sloppiness=pch_defines,time_macros
+      - name: Prepare Vulkan SDK
+        uses: humbletim/[email protected]
+        with:
+          vulkan-query-version: 1.4.304.1
+          vulkan-components: Vulkan-Headers, Vulkan-Loader
+          vulkan-use-cache: true
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          COMPILER: ${{ matrix.compiler }}
          ARCHITECTURE: ${{ matrix.arch }}
          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
-        run: ninja all
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
      - name: Run Tests
        working-directory: ./build
        env:
@@ -179,24 +231,12 @@ jobs:
          ARCH: ${{ matrix.arch }}
          XDG_RUNTIME_DIR: /root
        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Show CCache statistics
-        run: ccache --show-stats
-      - name: Install clang-tidy
-        # macOS runners don't ship clang-tidy; pin to the same version as the Linux
-        # container's clang-tidy-16 for consistent diagnostics. pyyaml is required
-        # too: clang-tidy-diff.py only accepts -export-fixes when it can import yaml.
-        # --break-system-packages is required since the runner's Homebrew Python
-        # is externally managed (PEP 668); the runner is ephemeral so this is safe.
-        if: startsWith(matrix.compiler, 'clang')
-        run: pip3 install --break-system-packages clang-tidy==16.0.4 pyyaml
      - name: Run Clang Tidy
        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang')
-        env:
-          CLANG_TIDY_BINARY: clang-tidy
+        if: startsWith(matrix.compiler, 'clang-')
        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang')
+        if: startsWith(matrix.compiler, 'clang-')
        uses: asarium/clang-tidy-action@v1
        with:
          fixesFile: clang-fixes.yaml
@@ -11,6 +11,7 @@ on:
    - cron: "5 0 * * 5" # Run once per a week on Friday morning (midnight UTC, 4 AM EST), to avoid Coverity's submission limits

 env:
+  QT_VERSION: 5.12.12
  coverity_email: [email protected]
  coverity_token: ${{ secrets.COVERITY_TOKEN }}

@@ -19,7 +20,7 @@ jobs:
    name: Build FSO With Coverity Wrapper
    if: github.repository == 'scp-fs2open/fs2open.github.com'
    runs-on: ${{ matrix.config.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
+    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
    strategy:
      fail-fast: false
      matrix:
@@ -28,12 +29,9 @@ jobs:

    steps:
      - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v1
        with:
          submodules: recursive # `true` to checkout submodules, `recursive` to recursively checkout submodules
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"

      # pipe results of wget to a log file because it's very verbose and rarely fails
      - name: Install Coverity
@@ -51,6 +49,7 @@ jobs:
        env:
          CONFIGURATION: Release
          COMPILER: gcc-9
+          ENABLE_QTFRED: OFF
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh

      - name: Build FSO with Coverity Wrapper
@@ -42,7 +42,6 @@ _ReSharper*/

 #Project files
 [Bb]uild/
-[Oo]ut/

 #Subversion files
 .svn
@@ -260,10 +259,3 @@ CMakePresets.json
 !/code/scripting/lua/LuaConvert.h
 !/code/debugconsole/
 !/docker/build
-CMakeFiles/cmake.check_cache
-CMakeCache.txt
-
-# Written by the unittests binary at runtime
-test/test_data/**/*_settings.ini
-test/test_data/data/players/presets/asdf.json
-test/test_data/pilotfile/data/asdf.hdp
@@ -1,3 +1,6 @@
+[submodule "cmake/external/rpavlik-cmake-modules"]
+	path = cmake/external/rpavlik-cmake-modules
+	url = https://github.com/rpavlik/cmake-modules.git
 [submodule "lib/libRocket"]
 	path = lib/libRocket
 	url = https://github.com/scp-fs2open/libRocket.git
@@ -1,5 +1,5 @@

-CMAKE_MINIMUM_REQUIRED(VERSION 3.21)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.9)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)

 # Make sure the source and binary directory are not the sample
@@ -8,12 +8,12 @@ if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
 endif()

 include(cmake/util.cmake)
+include(cmake/embed_file.cmake)

 # Set a few policies
 set_policy(CMP0051 NEW)
 set_policy(CMP0053 NEW)
 set_policy(CMP0054 NEW)
-set_policy(CMP0091 NEW) # Enable use of CMAKE_MSVC_RUNTIME_LIBRARY

 SET(FSO_PROJECT_DESCRIPTION "Open source project based on the original FreeSpace 2 source code.")

@@ -29,68 +29,40 @@ ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
 SET(TARGET_COPY_FILES "" CACHE INTERNAL "" FORCE)
 SET(TARGET_COPY_DIRS "" CACHE INTERNAL "" FORCE)

-get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-
-# Override standard CMake configurations
-set(FSO_BUILD_TYPES Debug Release FastDebug)
-
-if(is_multi_config)
-	set(CMAKE_CONFIGURATION_TYPES "${FSO_BUILD_TYPES}" CACHE STRING "Configuration types" FORCE)
-elseif(NOT CMAKE_BUILD_TYPE)
+### Define options and editable variables in the section below:
+# This is only needed for single configuration generators so don't annoy others
+if(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
 	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Default build configuration used." FORCE)
 	message(WARNING "CMAKE_BUILD_TYPE was not specified, defaulting to Release configuration.")
-	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${FSO_BUILD_TYPES}")
-endif()
+endif(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
+
+# Override standard CMake configurations
+set(CMAKE_CONFIGURATION_TYPES Debug Release FastDebug CACHE STRING "Available configurations" FORCE)

 set(FSO_LANGUAGES C CXX)

 if(APPLE)
 	set(FSO_LANGUAGES ${FSO_LANGUAGES} OBJC OBJCXX)
-
-	# 10.15 for c++17 std::filesystem
-	# NOTE: this must be set *before* the project() call to work properly!!
-	set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "macOS deployment target")
-
-	# fix all targets in scheme (so it's not just qtfred)
-	set(CMAKE_XCODE_GENERATE_SCHEME TRUE)
 endif()

 PROJECT(FS2_Open LANGUAGES ${FSO_LANGUAGES})

-if (ANDROID)
-    message(STATUS "Building for Android (NDK)")
-	set(FSO_BUILD_INCLUDED_LIBS ON CACHE BOOL "" FORCE)
-	set(USING_PREBUILT_LIBS ON CACHE BOOL "" FORCE)
-	set(SDL3_USE_PRECOMPILED ON CACHE BOOL "" FORCE)
-	set(OPENAL_USE_PRECOMPILED ON CACHE BOOL "" FORCE)
-	set(USING_PREBUILT_VULKAN ON CACHE BOOL "" FORCE)
-endif()
-
 # Check if the external modules exists
-IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libRocket/Build")
+IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules/launcher-templates")
 	message(FATAL_ERROR "External submodules could not be found. Please make sure you have updated your submodules.")
 endif()

 LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/finder")
-
-# this must be set before include(toolchain)
-if(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-	set(FSO_BUILD_QTFRED OFF CACHE INTERNAL "" FORCE)
-else()
-	OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" ON)
-endif()
-
-INCLUDE(globals)
-INCLUDE(toolchain)
-include(embed_file)
+LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules")
+LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/cotire")

 IF(RESET_INSTALL_PREFIX)
 	IF(NOT $ENV{FS2PATH} STREQUAL "")
 		IF(NOT IS_DIRECTORY $ENV{FS2PATH})
 			MESSAGE(WARNING "The path '$ENV{FS2PATH}' of the environment variable FS2PATH does not point to a directory! Install prefix wasn't set.")
 		ELSE(NOT IS_DIRECTORY $ENV{FS2PATH})
-			SET(CMAKE_INSTALL_PREFIX "$ENV{FS2PATH}" CACHE PATH "Install path" FORCE)
+			SET(CMAKE_INSTALL_PREFIX "$ENV{FS2PATH}" CACHE FILEPATH "Install path" FORCE)
 			FILE(TO_CMAKE_PATH ${CMAKE_INSTALL_PREFIX} CMAKE_INSTALL_PREFIX)
 		ENDIF(NOT IS_DIRECTORY $ENV{FS2PATH})
 	ELSE(NOT $ENV{FS2PATH} STREQUAL "")
@@ -98,11 +70,9 @@ IF(RESET_INSTALL_PREFIX)
 	ENDIF(NOT $ENV{FS2PATH} STREQUAL "")
 ENDIF(RESET_INSTALL_PREFIX)

-IF(WIN32 OR APPLE OR ANDROID OR CMAKE_SYSTEM_NAME STREQUAL "Linux")
+IF(WIN32 OR APPLE)
 	OPTION(FSO_USE_SPEECH "Use text-to-speach libraries" ON)
-ELSE()
-	OPTION(FSO_USE_SPEECH "Use text-to-speach libraries" OFF)
-ENDIF()
+ENDIF(WIN32 OR APPLE)

 IF (WIN32)
 	OPTION(FSO_USE_VOICEREC "Enable voice recognition support" ON)
@@ -118,8 +88,10 @@ OPTION(FSO_BUILD_TESTS "Build unit tests" OFF)

 OPTION(FSO_DEVELOPMENT_MODE "Generate binaries in development mode, only use if you know what you're doing!" OFF)

-IF(WIN32 OR APPLE OR ANDROID)
-	# On windows, mac and android the default should be to always build the included libraries
+OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" OFF)
+
+IF(WIN32 OR APPLE)
+	# On windows and mac the default should be to always build the included libraries
 	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT ON)
 ELSE()
 	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT OFF)
@@ -133,12 +105,14 @@ OPTION(FSO_USE_OPENALSOFT "Download and build OpenAL Soft instead of using the s

 OPTION(FSO_FATAL_WARNINGS "Determines if warnings in the build are considered fatal errors, primarily used for CI" OFF)

-SET(FSO_FREESPACE_PATH "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path of the FreeSpace directory you want to use. Please note that you will have to change CMAKE_INSTALL_PREFIX if you change this at some point.")
+SET(FSO_FREESPACE_PATH "${CMAKE_INSTALL_PREFIX}" CACHE FILEPATH "The path of the FreeSpace directory you want to use. Please note that you will have to change CMAKE_INSTALL_PREFIX if you change this at some point.")

 SET(FSO_RUN_ARGUMENTS "" CACHE STRING "Additional arguments passed to a generated executable when run with the generated build files.")

 option(FSO_INSTALL_DEBUG_FILES "Install some debug files (currently only PDB files on windows)" OFF)

+option(ENABLE_COTIRE "Enable cotire for faster compilation. Enabled by default." ON)
+
 option(FSO_RELEASE_LOGGING "Enable logging output for release builds" OFF)

 OPTION(FSO_BUILD_WITH_FFMPEG "Enable the usage of FFmpeg for sound and custscenes" ON)
@@ -147,25 +121,10 @@ OPTION(FSO_BUILD_WITH_DISCORD "Build with Discord support" ON)

 OPTION(FSO_BUILD_WITH_OPENGL "Enable compilation of the OpenGL renderer" ON)
 OPTION(FSO_BUILD_WITH_OPENGL_DEBUG "Enables debug option for OpenGL" OFF)
-OPTION(FSO_BUILD_WITH_OPENGL_ES "When building OpenGL, use OpenGL ES compatibility layer" OFF)

-OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" ON)
+OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" OFF)

-if(NOT FSO_BUILD_WITH_OPENGL AND FSO_BUILD_WITH_OPENGL_ES)
-	# Disable GLES if not building with OpenGL
-	set(FSO_BUILD_WITH_OPENGL_ES OFF CACHE BOOL "" FORCE)
-endif()
-
-
-if(FSO_BUILD_WITH_OPENGL_ES)
-	add_definitions(-DUSE_OPENGL_ES)
-	IF(FSO_BUILD_WITH_OPENXR)
-		MESSAGE(WARNING "FSO_BUILD_WITH_OPENXR is ON. But not supported on OpenGL ES for now - setting to OFF.")
-		SET(FSO_BUILD_WITH_OPENXR OFF CACHE BOOL "" FORCE)
-	endif()
-endif()
-
-IF(NOT APPLE AND NOT FSO_BUILD_WITH_OPENGL_ES)
+IF(NOT APPLE)
 	SET(OPENXR_BUILD_DEFAULT ON)
 ELSE()
 	SET(OPENXR_BUILD_DEFAULT OFF)
@@ -187,16 +146,21 @@ MARK_AS_ADVANCED(FORCE FSO_USE_LUAJIT)
 MARK_AS_ADVANCED(FORCE FSO_DEVELOPMENT_MODE)
 MARK_AS_ADVANCED(FORCE FSO_FATAL_WARNINGS)
 mark_as_advanced(FORCE FSO_INSTALL_DEBUG_FILES)
+mark_as_advanced(FORCE ENABLE_COTIRE)
 mark_as_advanced(FORCE FSO_RELEASE_LOGGING)
 mark_as_advanced(FORCE FSO_BUILD_WITH_FFMPEG)
 mark_as_advanced(FORCE FSO_BUILD_WITH_DISCORD)
 mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL)
 mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL_DEBUG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL_ES)
 mark_as_advanced(FORCE FSO_BUILD_WITH_VULKAN)
 mark_as_advanced(FORCE FSO_BUILD_WITH_OPENXR)
 mark_as_advanced(FORCE FSO_BUILD_WITH_OPENXR_DEBUG)

+# Include cotire file from https://github.com/sakra/cotire/
+include(cotire)
+
+INCLUDE(globals)
+INCLUDE(toolchain)
 INCLUDE(platforms)
 include(version)

@@ -207,19 +171,18 @@ SET(GENERATED_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated_source)
 include(generateHeaders)

 if(FSO_BUILD_APPIMAGE)
-	SET(BINARY_DESTINATION "bin")
-	SET(LIBRAY_DESTINATION "lib")
+	include(appimage)
 endif()

 include(clang-tidy)

 include(CheckIPOSupported)
 check_ipo_supported(RESULT LTO_AVAILABLE)
-if (FSO_USE_LTO AND LTO_AVAILABLE)
+if (CMAKE_BUILD_TYPE STREQUAL "Release" AND FSO_USE_LTO AND LTO_AVAILABLE)
 	set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
-	message("Enabled LTO for Release builds")
-	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
-endif (FSO_USE_LTO AND LTO_AVAILABLE)
+	message("Enabled LTO")
+	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif (CMAKE_BUILD_TYPE STREQUAL "Release" AND FSO_USE_LTO AND LTO_AVAILABLE)

 # This includes source code for some tools, either used in the build or also for something else
 ADD_SUBDIRECTORY(tools)
@@ -264,7 +227,9 @@ include(package)
 include(doxygen)

 # Print used options to log
-message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
+IF(WIN32 OR APPLE)
+	message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
+ENDIF()
 IF (WIN32)
 	message(STATUS "Using voice recogition: ${FSO_USE_VOICEREC}")
 	message(STATUS "Building FRED2: ${FSO_BUILD_FRED2}")
@@ -278,6 +243,5 @@ message(STATUS "Release logging: ${FSO_RELEASE_LOGGING}")
 message(STATUS "With FFmpeg: ${FSO_BUILD_WITH_FFMPEG}")
 message(STATUS "With Discord: ${FSO_BUILD_WITH_DISCORD}")
 message(STATUS "With OpenGL: ${FSO_BUILD_WITH_OPENGL}")
-message(STATUS "With OpenGL ES: ${FSO_BUILD_WITH_OPENGL_ES}")
 message(STATUS "With Vulkan: ${FSO_BUILD_WITH_VULKAN}")
 message(STATUS "With OpenXR: ${FSO_BUILD_WITH_OPENXR}")
@@ -18,16 +18,13 @@ fi
 # branch
 BASE_COMMIT=$(git merge-base $1 $2)

-# Allow the caller to override the clang-tidy binary and job count, since neither
-# /usr/bin/clang-tidy-16 nor nproc are available outside the Linux CI container
-# (e.g. macOS runners install clang-tidy via pip and use sysctl for core count).
-CLANG_TIDY_BINARY="${CLANG_TIDY_BINARY:-/usr/bin/clang-tidy-16}"
-NUM_JOBS="${NUM_JOBS:-$( (command -v nproc >/dev/null 2>&1 && nproc) || sysctl -n hw.ncpu )}"
-
 # Note: Manually passing in the Vulkan flags that are normally provided by cmake (but are not so, here), to ensure
 # that the source files are checked with the actual configuration used.
 echo "Running clang-tidy on changed files"
 git diff -U0 --no-color "$BASE_COMMIT..$2" | \
    $HERE/clang-tidy-diff.py -path "$(pwd)/build" -p1 \
-    -regex '(code(?!((\/graphics\/shaders\/compiled)|(\/globalincs\/windebug)|(\/def_files\/data)))|freespace2|qtfred|test\/src|build|tools)\/.*\.(cpp|h)' \
-    -clang-tidy-binary "$CLANG_TIDY_BINARY" -j"$NUM_JOBS" -export-fixes "$(pwd)/clang-fixes.yaml"
+    -extra-arg="-DWITH_VULKAN" \
+    -extra-arg="-DVULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1" \
+    -extra-arg="-DVK_NO_PROTOTYPES" \
+    -regex '(code(?!((\/graphics\/shaders\/compiled)|(\/globalincs\/windebug)))|freespace2|qtfred|test|build|tools)\/.*\.(cpp|h)' \
+    -clang-tidy-binary /usr/bin/clang-tidy-16 -j$(nproc) -export-fixes "$(pwd)/clang-fixes.yaml"
@@ -13,32 +13,21 @@ if [ "$COMPILER" = "clang-16" ]; then
    export CXX=clang++-16
 fi

+LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH
 if [ "$RUNNER_OS" = "macOS" ]; then
    CXXFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
    CFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
+    # TODO: Vulkan support is disabled on MacOS due to issues with the test suite not linking correctly
+    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_WITH_VULKAN=OFF"
    export CMAKE_OSX_ARCHITECTURES="$ARCHITECTURE"
 else
-    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON -DFORCED_SIMD_INSTRUCTIONS=SSE2"
-
-    # Optionally use static libstdc++/libc++ on Linux, but default to off
-    # (Issue #5571 enabled it as a fix for 20.04 compatibility, but we've moved to 22.04)
-    PLATFORM_CMAKE_OPTIONS="$PLATFORM_CMAKE_OPTIONS -DUSE_STATIC_LIBCXX=${USE_STATIC_LIBCXX:-OFF}"
+    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON -DFORCED_SIMD_INSTRUCTIONS=SSE2 -DUSE_STATIC_LIBCXX=ON"
 fi

 CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
 if [[ "$COMPILER" =~ ^clang.*$ ]]; then
-    # Default to allowing system standard c++ library be used. On Linux, which
-    # typically uses libstdc++ by default, using libc++ causes a conflict with
-    # Qt6 libs. So an error/warning is in place to catch that case when QtFRED
-    # is enabled.
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=${CLANG_USE_LIBCXX:-OFF}"
-fi
-
-if [ ! "$CCACHE_PATH" = "" ] && [ ! -x "$CCACHE_PATH" ]; then
-    # The configured path doesn't exist on this runner (e.g. macOS runners on Apple
-    # Silicon hosts install Homebrew under /opt/homebrew instead of /usr/local),
-    # so fall back to whatever ccache is actually on PATH.
-    CCACHE_PATH="$(command -v ccache || true)"
+    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=ON"
+    # force clang to silently allow -static-libstdc++ flag
 fi

 if [ ! "$CCACHE_PATH" = "" ]; then
@@ -46,10 +35,6 @@ if [ ! "$CCACHE_PATH" = "" ]; then
    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_C_COMPILER_LAUNCHER=$CCACHE_PATH -DCMAKE_CXX_COMPILER_LAUNCHER=$CCACHE_PATH"
 fi

-if [ -n "${ENABLE_QTFRED:-}" ]; then
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DFSO_BUILD_QTFRED=${ENABLE_QTFRED}"
-fi
-
 mkdir build
 cd build

@@ -57,7 +42,7 @@ export CXXFLAGS
 export CFLAGS
 export LD_LIBRARY_PATH

-if [ "$RUNNER_OS" = "macOS" ] && [ ! -x "$(which ninja)" ]; then
+if [ "$RUNNER_OS" = "macOS" ]; then
    brew install ninja
 fi

@@ -65,6 +50,6 @@ fi
 # we have some build rules that do not play nice with parallel invocation and that fixes these issues

 cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS $PLATFORM_CMAKE_OPTIONS \
-    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DCMAKE_BUILD_TYPE=$CONFIGURATION -DQT_USE_PRECOMPILED=ON \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON \
-    -DCMAKE_JOB_POOLS=link=1 -DCMAKE_JOB_POOL_LINK=link ..
+    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DCMAKE_BUILD_TYPE=$CONFIGURATION \
+    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=${ENABLE_QTFRED:-OFF} \
+    -DSHADERS_ENABLE_COMPILATION=ON -DCMAKE_JOB_POOLS=link=1 -DCMAKE_JOB_POOL_LINK=link ..
@@ -14,17 +14,17 @@ if [ "$OS" = "Linux" ]; then
    echo "package_name=$(get_package_name)-builds-Linux-$ARCH.tar.gz" >> $GITHUB_OUTPUT
    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux-$ARCH.tar.gz")" >> $GITHUB_OUTPUT
 elif [ "$OS" = "Windows" ]; then
-    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ID.zip" "*"
+    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"

-    echo "package_path=$(pwd)/$(get_package_name)-builds-$ID.zip" >> $GITHUB_OUTPUT
-    echo "package_name=$(get_package_name)-builds-$ID.zip" >> $GITHUB_OUTPUT
-    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ID.zip")" >> $GITHUB_OUTPUT
+    echo "package_path=$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip" >> $GITHUB_OUTPUT
+    echo "package_name=$(get_package_name)-builds-$ARCH-$SIMD.zip" >> $GITHUB_OUTPUT
+    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip")" >> $GITHUB_OUTPUT

-    7z a "$(get_package_name)-debug-$ID.7z" "*.pdb"
+    7z a "$(get_package_name)-debug-$ARCH-$SIMD.7z" "*.pdb"

-    echo "debug_path=$(pwd)/$(get_package_name)-debug-$ID.7z" >> $GITHUB_OUTPUT
-    echo "debug_name=$(get_package_name)-debug-$ID.7z" >> $GITHUB_OUTPUT
-    echo "debug_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ID.7z")" >> $GITHUB_OUTPUT
+    echo "debug_path=$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z" >> $GITHUB_OUTPUT
+    echo "debug_name=$(get_package_name)-debug-$ARCH-$SIMD.7z" >> $GITHUB_OUTPUT
+    echo "debug_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z")" >> $GITHUB_OUTPUT
 elif [ "$OS" = "Mac" ]; then
    tar -cvzf "$(get_package_name)-builds-Mac-$ARCH.tar.gz" *.app

@@ -2,48 +2,13 @@

 INSTALL_FOLDER=$1

-# safety check
-if [ ! -d bin -o ! -f cmake_install.cmake ]; then
-	echo "ERROR! This script must be run from within the build root!"
-	exit 1
-fi
-
-if [ ! -x "$(which wget)" ]; then
-	echo "ERROR! Required utility is not available: wget"
-	exit 1
-fi
-
-# install newest appimagetool if it's not already available
-if [ ! -x ./bin/appimagetool ]; then
-	APPIMAGE_TOOL_URL="https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-$(uname -m).AppImage"
-
-	wget -O ./bin/appimagetool "$APPIMAGE_TOOL_URL" || { echo "ERROR! Failed to get appimagetool!" && exit 1; }
-	chmod +x ./bin/appimagetool
-fi
-
-# This shouldn't be needed with newer runtimes, but they still generate an
-# error if fusermount is missing even though it works. So to skip error msg
-# and have max compatibility with runtimes and containers we'll use it.
-export APPIMAGE_EXTRACT_AND_RUN=1
-
 # Install Freespace2 targets
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/Freespace2 -DCOMPONENT=Unspecified -P cmake_install.cmake
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/Freespace2 -DCOMPONENT=Freespace2 -P cmake_install.cmake
+cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Unspecified -P cmake_install.cmake
+cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Freespace2 -P cmake_install.cmake

 # We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-FILENAME="$(find $INSTALL_FOLDER/Freespace2/bin -maxdepth 1 -name 'fs2_open_*' -type f -executable -printf "%f\n").AppImage"
-./bin/appimagetool -n "$INSTALL_FOLDER/Freespace2" "$INSTALL_FOLDER/$FILENAME"
+FILENAME="$(find $INSTALL_FOLDER/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
+appimagetool -n $INSTALL_FOLDER "$INSTALL_FOLDER/$FILENAME"
 chmod +x "$INSTALL_FOLDER/$FILENAME"

-# Maybe install qtFRED targets
-if [ -f qtfred/cmake_install.cmake ]; then
-	cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/qtFRED -DCOMPONENT=Unspecified -P cmake_install.cmake
-	cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/qtFRED -DCOMPONENT=qtFRED -P cmake_install.cmake
-
-	# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-	FILENAME="$(find $INSTALL_FOLDER/qtFRED/bin -maxdepth 1 -iname 'qtfred_*' -type f -executable -printf "%f\n").AppImage"
-	./bin/appimagetool -n "$INSTALL_FOLDER/qtFRED" "$INSTALL_FOLDER/$FILENAME"
-	chmod +x "$INSTALL_FOLDER/$FILENAME"
-fi
-
 ls -al $INSTALL_FOLDER
@@ -5,14 +5,6 @@ HERE=$(dirname "$SCRIPT")

 export LD_LIBRARY_PATH=$(pwd)/bin/lib:$LD_LIBRARY_PATH

-# The unit tests never open a window, but a few of them reach code that brings SDL's video
-# subsystem up (os_init() and resolution_default(), the latter via gr_init()). Left to itself SDL
-# probes its real backends and dlopens libX11, which leaks a handful of blocks per init/quit cycle
-# that SDL_QuitSubSystem() does not reclaim -- those are the "definitely lost" contexts memcheck
-# fails the Debug legs on. Pinning the dummy driver skips the probing entirely, so the leaks never
-# happen, and it makes the tests behave the same way whether or not the runner has a display.
-export SDL_VIDEODRIVER=dummy
-
 # if on mac and building for architecture that doesn't match host
 # then unittests will fail so we just need to skip it (for now)
 if [ "$RUNNER_OS" = "macOS" ] && [ "$ARCH" != "$(uname -m)" ]; then
@@ -20,7 +12,7 @@ if [ "$RUNNER_OS" = "macOS" ] && [ "$ARCH" != "$(uname -m)" ]; then
    exit 0
 fi

-if [ "$CONFIGURATION" = "Debug" ] && [[ "$RUNNER_OS" != "macOS" ]] ; then
+if [ "$CONFIGURATION" = "Debug"] && [[ "$RUNNER_OS" != "macOS" ]] ; then
    valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
        --suppressions="$HERE/valgrind.supp" ./bin/unittests --gtest_shuffle
 else
@@ -8,6 +8,24 @@
   obj:*
   obj:*
 }
+{
+    Travis memleak
+    Memcheck:Leak
+    match-leak-kinds: definite
+    fun:malloc
+    fun:_dl_signal_error
+    fun:_dl_open
+    fun:dlopen_doit
+    fun:_dl_catch_error
+    fun:_dlerror_run
+    fun:dlopen@@GLIBC_2.2.5
+    obj:/usr/lib/x86_64-linux-gnu/libmirclient.so.7
+    fun:call_init.part.0
+    fun:call_init
+    fun:_dl_init
+    fun:dl_open_worker
+    fun:_dl_catch_error
+}
 {
   CLang Lua unitialized value error
   Memcheck:Cond
@@ -109,31 +127,37 @@
   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
 }
 {
-   SDL_Init one-time internal allocation via os_init
+   <insert_a_suppression_name_here>
   Memcheck:Leak
   match-leak-kinds: definite
   fun:malloc
-   obj:*
-   obj:*
-   obj:*
-   obj:*
-   fun:_Z7os_initPKcS0_S0_
-   fun:_ZN4test13FSTestFixture5SetUpEv
-}
-# Kept only as a backstop for running memcheck by hand. run_tests.sh pins SDL_VIDEODRIVER=dummy, so
-# the X11 backend is never created there; this block also cannot match the prebuilt libSDL3 anymore,
-# since that library is now stripped and X11_CreateDevice is a static symbol.
-{
-   SDL3 X11 video backend internal allocations, not freed by SDL_VideoQuit
-   Memcheck:Leak
-   match-leak-kinds: definite,possible
-   ...
-   fun:X11_CreateDevice
-}
-{
-   glibc loader bookkeeping and library constructor allocations retained across dlopen
-   Memcheck:Leak
-   match-leak-kinds: definite,possible
-   ...
+   fun:_dl_signal_error
   fun:_dl_open
+   fun:dlopen_doit
+   fun:_dl_catch_error
+   fun:_dlerror_run
+   fun:dlopen@@GLIBC_2.2.5
+   obj:*
+   obj:*
+   fun:call_init.part.0
+   fun:call_init
+   fun:_dl_init
+   fun:dl_open_worker
+}
+{
+   dlopen leak
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   fun:_dl_exception_create
+   fun:_dl_signal_error
+   fun:_dl_map_object
+   fun:dl_open_worker
+   fun:_dl_catch_exception
+   fun:_dl_open
+   fun:dlopen_doit
+   fun:_dl_catch_exception
+   fun:_dl_catch_error
+   fun:_dlerror_run
+   fun:dlopen@@GLIBC_2.2.5
 }
@@ -149,8 +149,6 @@ def get_release_files(tag_name, config) -> Tuple[List[ReleaseFile], Dict[str, So
            # x64 is the Visual Studio name but for consistency we need Win64
            if platform == "x64":
                platform = "Win64"
-            elif platform == "ARM64":
-                platform = "WinARM64"

            binary_files.append(ReleaseFile(name, url, platform, group_match.group(3)))
        else:
@@ -215,8 +213,6 @@ def get_ftp_files(build_type, tag_name, config) -> List[ReleaseFile] :
        # x64 is the name Visual Studio uses but Win64 works better for us since that gets displayed in the nightly post
        if "x64" in group_match:
            group_match = group_match.replace("x64", "Win64")
-        elif "ARM64" in group_match:
-            group_match = group_match.replace("ARM64", "WinARM64")

        # construct the download URL list for all mirrors.  The first listed ftp location is taken as the Primary
        for mirror in config["ftp"]["mirrors"]:
@@ -229,4 +225,4 @@ def get_ftp_files(build_type, tag_name, config) -> List[ReleaseFile] :
        # Form the List[ReleaseFile] list with the download URL links
        out_data.append(ReleaseFile(file, primary_url, group_match, None, mirrors))

-    return out_data
+    return out_data
@@ -1,4 +1,3 @@
-import os
 from typing import List

 import requests
@@ -34,14 +33,12 @@ class ForumAPI:
            print("Post failed! No API or API_KEY given!")
            return

-        resp = requests.post(self.config["hlp"]["api"],
-                             headers={"X-HLP-Bot": os.environ["FORUM_SECRET"]},
-                             data={
-                                "api_key": self.config["hlp"]["key"],
-                                "board": str(board),
-                                "subject": title,
-                                "body": content
-                            })
+        resp = requests.post(self.config["hlp"]["api"], data={
+            "api_key": self.config["hlp"]["key"],
+            "board": str(board),
+            "subject": title,
+            "body": content
+        })

        if resp.status_code != 200:
            print("Post failed! Response: %s" %resp.text)
@@ -18,7 +18,6 @@
 # Credentials into hard-light.net for forum post
 # HLP_API:
 # HLP_KEY:
-# FORUM_SECRET:

 # LINUX_RESULT: bool, if the linux builds were successfully uploaded
 # WINDOWS_RESULT: bool, if the windows builds were successfully uploaded
@@ -125,10 +124,6 @@ def get_source_version(date_version: datetime, tag_name: str) -> semantic_versio


 def main():
-	if "FORUM_SECRET" not in os.environ or not os.environ["FORUM_SECRET"]:
-		print("  ERROR: FORUM_SECRET environment variable not set")
-		sys.exit(1)
-
 	os.chdir(os.path.dirname(__file__))	# Change working directory to this file's directory

 	# Aggregate configuration data in a dictionary
@@ -15,7 +15,6 @@ WIN32_SSE2_KEY = "Win32-SSE2"
 WIN64_SSE2_KEY = "Win64-SSE2"
 WIN32_AVX_KEY = "Win32-AVX"
 WIN64_AVX_KEY = "Win64-AVX"
-WINARM64_KEY = "WinARM64"

 metadata = {
    'type': 'engine',
@@ -43,8 +42,7 @@ platforms = {
    WIN32_SSE2_KEY: 'windows',
    WIN64_SSE2_KEY: 'windows',
    WIN32_AVX_KEY: 'windows',
-    WIN64_AVX_KEY: 'windows',
-    WINARM64_KEY: 'windows',
+    WIN64_AVX_KEY: 'windows'
 }

 envs = {
@@ -55,8 +53,7 @@ envs = {
    WIN32_SSE2_KEY: 'windows',
    WIN64_SSE2_KEY: 'windows && x86_64',
    WIN32_AVX_KEY: 'windows && avx',
-    WIN64_AVX_KEY: 'windows && avx && x86_64',
-    WINARM64_KEY: 'windows && arm64'
+    WIN64_AVX_KEY: 'windows && avx && x86_64'
 }

 subdirs = {
@@ -194,7 +191,6 @@ def render_nebula_release(version, stability, files, config):
                    "sse2": "SSE2" in fn or "AVX" in fn,  # AVX implies SSE2
                    "avx": "AVX" in fn,  # This conveniently also covers the AVX2 case since AVX2 implies AVX
                    "avx2": "AVX2" in fn,
-                    "arm64": "arm64" in fn,
                }

                pkg['executables'].append({
@@ -22,7 +22,7 @@ Windows:  [url=http://scp.fsmods.net/builds/Launcher55g.zip]Launcher 5.5g[/url]
 OS X:  Soulstorm's [url=https://www.hard-light.net/forums/index.php/topic,51391.0.html]OS X Launcher 3.0[/url]
 Linux:  [url=https://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[/url] or [url=https://www.hard-light.net/wiki/index.php/Fs2_open_on_Linux/Graphics_Settings]by hand[/url] or whatever you can figure out.[/hidden]

-[img]https://scp.indiegames.us/img/windows-icon.png[/img] [color=green][size=12pt]Windows (32/64-bit/ARM64)[/size][/color]
+[img]https://scp.indiegames.us/img/windows-icon.png[/img] [color=green][size=12pt]Windows (32/64-bit)[/size][/color]
 [size=8pt]Compiled using GitHub Actions on Windows Server 2019 (10.0.17763), Visual Studio Enterprise 2019[/size]

 [b]64-bit:[/b] ${build(groups["Win64"].mainFile)}
@@ -30,8 +30,6 @@ Linux:  [url=https://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[
 [b]32-bit:[/b] ${build(groups["Win32"].mainFile)}
 [size=8pt]This one is based on the SSE2 Optimizations from the MSVC Compiler.[/size]

-[b]ARM64:[/b] ${build(groups["WinARM64"].mainFile)}
-
 [hidden=Alternative builds]

 [b]64-bit AVX:[/b] ${build(groups["Win64"].subFiles["AVX"])}
@@ -1,3 +1,3 @@
-Mako==1.4.2
-requests==2.33.0
+Mako==1.2.2
+requests==2.32.0
 semantic-version==2.8.5
@@ -1,34 +0,0 @@
-# Installs ATL and MFC for the v143 toolset, which the Visual Studio 2026 runner images
-# only ship for the latest toolset.  ATL is needed by SAPI speech (sphelper.h) and MFC by FRED2.
-
-$ErrorActionPreference = 'Stop'
-
-$msvcVersion = '14.44'
-$component = 'Microsoft.VisualStudio.Component.VC.14.44.17.14'
-$suffix = if ($env:RUNNER_ARCH -eq 'ARM64') { '.ARM64' } else { '' }
-
-$installerDir = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer"
-$installPath = & "$installerDir\vswhere.exe" -version '[18.0,19.0)' -latest -property installationPath
-if (-not $installPath) {
-    Write-Error 'Visual Studio 2026 was not found'
-}
-
-$arguments = @(
-    '/c', 'vs_installer.exe', 'modify',
-    '--installPath', "`"$installPath`"",
-    '--add', "$component.ATL$suffix",
-    '--add', "$component.MFC$suffix",
-    '--quiet', '--norestart', '--nocache'
-)
-$process = Start-Process -FilePath cmd.exe -ArgumentList $arguments -WorkingDirectory $installerDir -Wait -PassThru -NoNewWindow
-# 3010 = success, reboot required
-if ($process.ExitCode -notin 0, 3010) {
-    Write-Error "vs_installer exited with code $($process.ExitCode)"
-}
-
-# fail here rather than with a confusing compile error if the components didn't install
-foreach ($header in 'atlbase.h', 'afxwin.h') {
-    if (-not (Test-Path "$installPath\VC\Tools\MSVC\$msvcVersion.*\atlmfc\include\$header")) {
-        Write-Error "$header for MSVC $msvcVersion is missing after install"
-    }
-}
@@ -1,48 +0,0 @@
-# - Removes duplicate entries and non-directories from a provided list
-#
-#  clean_directory_list(<listvar> [<additional list items>...])
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__clean_directory_list)
-	return()
-endif()
-set(__clean_directory_list YES)
-
-function(clean_directory_list _var)
-	# combine variable's current value with additional list items
-	set(_in ${${_var}} ${ARGN})
-
-	if(_in)
-		# Initial list cleaning
-		list(REMOVE_DUPLICATES _in)
-
-		# Grab the absolute path of each actual directory
-		set(_out)
-		foreach(_dir ${_in})
-			if(IS_DIRECTORY "${_dir}")
-				get_filename_component(_dir "${_dir}" ABSOLUTE)
-				file(TO_CMAKE_PATH "${_dir}" _dir)
-				list(APPEND _out "${_dir}")
-			endif()
-		endforeach()
-
-		if(_out)
-			# Clean up the output list now
-			list(REMOVE_DUPLICATES _out)
-		endif()
-
-		# return _out
-		set(${_var} "${_out}" PARENT_SCOPE)
-	endif()
-endfunction()
@@ -1,311 +0,0 @@
-# - Create launchers to set working directory, env. vars, etc.
-#
-#  include(CreateLaunchers) - to make these available
-#  guess_runtime_library_dirs(<outputvarname> [<extralibrary> ...])
-#  create_default_target_launcher(<targetname>
-#    [ARGS <args...>]
-#    [FORWARD_ARGS]
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#
-#  create_target_launcher(<targetname>
-#    [ARGS <args...>]
-#    [FORWARD_ARGS]
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#
-#  create_generic_launcher(<launchername>
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#    - sets GENERIC_LAUNCHER_COMMAND and GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION
-#
-# Requires these CMake modules:
-#  ListFilter
-#  ProgramFilesGlob
-#  CleanDirectoryList
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__create_launchers)
-	return()
-endif()
-set(__create_launchers YES)
-
-include(CleanDirectoryList)
-
-# We must run the following at "include" time, not at function call time,
-# to find the path to this module rather than the path to a calling list file
-get_filename_component(_launchermoddir
-	${CMAKE_CURRENT_LIST_FILE}
-	PATH)
-set(_launchermoddir "${_launchermoddir}/launcher-templates")
-
-macro(_launcher_system_settings)
-	if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-		set(BITS 64)
-	else()
-		set(BITS 32)
-	endif()
-
-	if(WIN32)
-		# Find user and system name
-		set(SYSTEM_NAME $ENV{USERDOMAIN})
-		set(USER_NAME $ENV{USERNAME})
-		set(VCPROJ_TYPE vcproj)
-		set(USERFILE_EXTENSION ${SYSTEM_NAME}.${USER_NAME}.user)
-		set(LAUNCHER_LINESEP "&#x0A;")
-		if(MSVC90)
-			set(USERFILE_VC_VERSION 9.00)
-		elseif(MSVC80)
-			set(USERFILE_VC_VERSION 8.00)
-		elseif(MSVC71)
-			set(USERFILE_VC_VERSION 7.10)
-		elseif(MSVC10 OR (MSVC AND MSVC_VERSION GREATER 1600)) # 2010 or newer
-			set(LAUNCHER_LINESEP "\n")
-			set(USERFILE_VC_VERSION 10.00)
-			set(USERFILE_EXTENSION user)
-			set(VCPROJ_TYPE vcxproj)
-		endif()
-		if(BITS EQUAL 64)
-			set(USERFILE_PLATFORM x64)
-		else()
-			set(USERFILE_PLATFORM Win${BITS})
-		endif()
-		set(_pathdelim ";")
-		set(_suffix "cmd")
-	else()
-		set(_pathdelim ":")
-		set(USERFILE_PLATFORM ${CMAKE_SYSTEM_NAME}${BITS})
-		set(_suffix "sh")
-		find_package(GDB QUIET)
-		if(GDB_FOUND)
-			set(LAUNCHERS_GOT_GDB YES)
-			if(GDB_HAS_RETURN_CHILD_RESULT)
-				set(LAUNCHERS_GDB_ARG --return-child-result)
-			endif()
-		else()
-			set(LAUNCHERS_GOT_GDB)
-		endif()
-	endif()
-
-	if(WIN32 AND NOT USERFILE_REMOTE_MACHINE)
-		site_name(USERFILE_REMOTE_MACHINE)
-		mark_as_advanced(USERFILE_REMOTE_MACHINE)
-	endif()
-endmacro()
-
-macro(_launcher_process_args)
-	set(_nowhere)
-	set(_curdest _nowhere)
-	set(_val_args
-		ARGS
-		RUNTIME_LIBRARY_DIRS
-		WORKING_DIRECTORY
-		ENVIRONMENT)
-	set(_bool_args FORWARD_ARGS)
-	foreach(_arg ${_val_args} ${_bool_args})
-		set(${_arg})
-	endforeach()
-	foreach(_element ${ARGN})
-		list(FIND _val_args "${_element}" _val_arg_find)
-		list(FIND _bool_args "${_element}" _bool_arg_find)
-		if("${_val_arg_find}" GREATER "-1")
-			set(_curdest "${_element}")
-		elseif("${_bool_arg_find}" GREATER "-1")
-			set("${_element}" ON)
-			set(_curdest _nowhere)
-		else()
-			list(APPEND ${_curdest} "${_element}")
-		endif()
-	endforeach()
-
-	if(_nowhere)
-		message(FATAL_ERROR
-			"Syntax error in use of a function in CreateLaunchers!")
-	endif()
-
-	# Turn into a list of native paths
-	set(_runtime_lib_dirs)
-	foreach(_dlldir ${RUNTIME_LIBRARY_DIRS})
-		file(TO_NATIVE_PATH "${_dlldir}" _path)
-		set(_runtime_lib_dirs "${_runtime_lib_dirs}${_path}${_pathdelim}")
-	endforeach()
-
-	if(NOT WORKING_DIRECTORY)
-		set(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-	endif()
-
-	if(FORWARD_ARGS)
-		if(WIN32)
-			set(FWD_ARGS %*)
-		else()
-			set(FWD_ARGS $*)
-		endif()
-	else()
-		set(FWD_ARGS)
-	endif()
-
-	set(USERFILE_WORKING_DIRECTORY "${WORKING_DIRECTORY}")
-	set(USERFILE_COMMAND_ARGUMENTS "${ARGS}")
-	set(LAUNCHERSCRIPT_COMMAND_ARGUMENTS "${ARGS} ${FWD_ARGS}")
-
-	if(WIN32)
-		set(RUNTIME_LIBRARIES_ENVIRONMENT "PATH=${_runtime_lib_dirs};%PATH%")
-		file(READ
-			"${_launchermoddir}/launcher.env.cmd.in"
-			_cmdenv)
-	else()
-		if(APPLE)
-			set(RUNTIME_LIBRARIES_ENVIRONMENT
-				"DYLD_LIBRARY_PATH=${_runtime_lib_dirs}:$DYLD_LIBRARY_PATH")
-		else()
-			set(RUNTIME_LIBRARIES_ENVIRONMENT
-				"LD_LIBRARY_PATH=${_runtime_lib_dirs}:$LD_LIBRARY_PATH")
-		endif()
-		file(READ
-			"${_launchermoddir}/launcher.env.sh.in"
-			_cmdenv)
-	endif()
-	set(USERFILE_ENVIRONMENT "${RUNTIME_LIBRARIES_ENVIRONMENT}")
-
-	set(USERFILE_ENV_COMMANDS)
-	foreach(_arg "${RUNTIME_LIBRARIES_ENVIRONMENT}" ${ENVIRONMENT})
-		string(CONFIGURE
-			"@USERFILE_ENVIRONMENT@@LAUNCHER_LINESEP@@_arg@"
-			USERFILE_ENVIRONMENT
-			@ONLY)
-		string(CONFIGURE
-			"@USERFILE_ENV_COMMANDS@${_cmdenv}"
-			USERFILE_ENV_COMMANDS
-			@ONLY)
-	endforeach()
-endmacro()
-
-macro(_launcher_produce_vcproj_user)
-	if(MSVC)
-		file(READ
-			"${_launchermoddir}/perconfig.${VCPROJ_TYPE}.user.in"
-			_perconfig)
-		file(TO_NATIVE_PATH "${USERFILE_WORKING_DIRECTORY}" NATIVE_WORKING_DIRECTORY)
-		set(USERFILE_CONFIGSECTIONS)
-		foreach(USERFILE_CONFIGNAME ${CMAKE_CONFIGURATION_TYPES})
-			string(CONFIGURE "${_perconfig}" _temp @ONLY ESCAPE_QUOTES)
-			set(USERFILE_CONFIGSECTIONS "${USERFILE_CONFIGSECTIONS}${_temp}")
-		endforeach()
-
-
-		configure_file("${_launchermoddir}/${VCPROJ_TYPE}.user.in"
-			"${VCPROJNAME}.${VCPROJ_TYPE}.${USERFILE_EXTENSION}"
-			@ONLY)
-	endif()
-
-endmacro()
-
-macro(_launcher_configure_executable _src _tmp _target)
-#    get_filename_component(_targetname "${_target}" NAME)
-    get_filename_component(_targetpath "${_target}" PATH)
-	configure_file("${_src}"
-		"${_tmp}"
-		@ONLY)
-	file(COPY "${_tmp}"
-	    DESTINATION "${_targetpath}"
-	    FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-endmacro()
-
-macro(_launcher_create_target_launcher)
-	set(TARGET_NAME ${_targetname})
-	
-	set(_fn "launch-${_targetname}-generator.${_suffix}")
-	
-	configure_file("${_launchermoddir}/targetlauncher.${_suffix}.in" 
-					"${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_fn}"
-					@ONLY)
-	
-	file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/launch-${_targetname}-$<CONFIGURATION>.${_suffix}"
-			INPUT "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_fn}")
-endmacro()
-
-function(create_default_target_launcher _targetname)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	set(VCPROJNAME "${CMAKE_BINARY_DIR}/ALL_BUILD")
-	_launcher_produce_vcproj_user()
-
-	_launcher_create_target_launcher()
-endfunction()
-
-function(create_target_launcher _targetname)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	set(VCPROJNAME "${CMAKE_CURRENT_BINARY_DIR}/${_targetname}")
-	_launcher_produce_vcproj_user()
-
-	_launcher_create_target_launcher()
-endfunction()
-
-function(create_generic_launcher _launchername)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	if(NOT IS_ABSOLUTE _launchername)
-		set(_launchername
-			"${CMAKE_CURRENT_BINARY_DIR}/${_launchername}.${_suffix}")
-	else()
-		set(_launchername "${_launchername}.${_suffix}")
-	endif()
-	if(WIN32)
-		set(GENERIC_LAUNCHER_COMMAND "${_launchername}" PARENT_SCOPE)
-		set(GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION)
-	else()
-		set(GENERIC_LAUNCHER_COMMAND sh "${_launchername}" PARENT_SCOPE)
-		set(GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION
-			"Program terminated with signal")
-	endif()
-
-	_launcher_configure_executable("${_launchermoddir}/genericlauncher.${_suffix}.in"
-	    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/genericlauncher.${_suffix}.in"
-		"${_launchername}")
-endfunction()
-
-function(guess_runtime_library_dirs _var)
-	# Start off with the link directories of the calling listfile's directory
-	get_directory_property(_libdirs LINK_DIRECTORIES)
-
-	# Add additional libraries passed to the function
-	foreach(_lib ${ARGN})
-		get_filename_component(_libdir "${_lib}" PATH)
-		list(APPEND _libdirs "${_libdir}")
-	endforeach()
-
-	# Now, build a list of potential dll directories
-	set(_dlldirs)
-	foreach(_libdir ${_libdirs})
-		# Add the libdir itself
-		list(APPEND _dlldirs "${_libdir}")
-
-		# Look also in libdir/../bin since the dll might not be with the lib
-		get_filename_component(_libdir "${_libdir}/../bin" ABSOLUTE)
-		list(APPEND _dlldirs "${_libdir}")
-	endforeach()
-
-	# Only keep the valid, unique directories
-	clean_directory_list(_dlldirs)
-
-	# Return _dlldirs
-	set(${_var} "${_dlldirs}" PARENT_SCOPE)
-endfunction()
@@ -1,88 +0,0 @@
-# - Add flags to compile with extra warnings
-#
-#  enable_extra_compiler_warnings(<targetname>)
-#  globally_enable_extra_compiler_warnings() - to modify CMAKE_CXX_FLAGS, etc
-#    to change for all targets declared after the command, instead of per-command
-#
-#
-# Original Author:
-# 2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__enable_extra_compiler_warnings)
-	return()
-endif()
-set(__enable_extra_compiler_warnings YES)
-
-macro(_enable_extra_compiler_warnings_flags)
-	set(_flags)
-	if(MSVC)
-		option(COMPILER_WARNINGS_EXTREME
-			"Use compiler warnings that are probably overkill."
-			off)
-		mark_as_advanced(COMPILER_WARNINGS_EXTREME)
-		set(_flags "/W4")
-		if(COMPILER_WARNINGS_EXTREME)
-			set(_flags "${_flags} /Wall /wd4619 /wd4668 /wd4820 /wd4571 /wd4710")
-		endif()
-	else()
-		include(CheckCXXCompilerFlag)
-		set(_flags)
-
-		check_cxx_compiler_flag(-W SUPPORTS_W_FLAG)
-		if(SUPPORTS_W_FLAG)
-			set(_flags "${_flags} -W")
-		endif()
-
-		check_cxx_compiler_flag(-Wall SUPPORTS_WALL_FLAG)
-		if(SUPPORTS_WALL_FLAG)
-			set(_flags "${_flags} -Wall")
-		endif()
-
-		check_cxx_compiler_flag(-Wextra SUPPORTS_WEXTRA_FLAG)
-		if(SUPPORTS_WEXTRA_FLAG)
-			set(_flags "${_flags} -Wextra")
-		endif()
-
-		if(SUPPORTS_WALL_FLAG)
-			# At least GCC includes -Wmaybe-uninitialized in -Wall, which
-			# unneccesarily whines about boost::optional (by it's nature
-			# it's a "maybe" warning - prone to noisy false-positives)
-			check_cxx_compiler_flag(-Wno-maybe-uninitialized SUPPORTS_WNO_MAYBE_UNINITIALIZED_FLAG)
-			if(SUPPORTS_WNO_MAYBE_UNINITIALIZED_FLAG)
-				set(_flags "${_flags} -Wno-maybe-uninitialized")
-			endif()
-		endif()
-	endif()
-endmacro()
-
-function(enable_extra_compiler_warnings _target)
-	_enable_extra_compiler_warnings_flags()
-	get_target_property(_origflags ${_target} COMPILE_FLAGS)
-	if(_origflags)
-		set_property(TARGET
-			${_target}
-			PROPERTY
-			COMPILE_FLAGS
-			"${_flags} ${_origflags}")
-	else()
-		set_property(TARGET
-			${_target}
-			PROPERTY
-			COMPILE_FLAGS
-			"${_flags}")
-	endif()
-
-endfunction()
-
-function(globally_enable_extra_compiler_warnings)
-	_enable_extra_compiler_warnings_flags()
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_flags}" PARENT_SCOPE)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flags}" PARENT_SCOPE)
-endfunction()
@@ -1,53 +0,0 @@
-# - Combine lists of prefixes and suffixes in all combinations
-#
-#  list_combinations(var PREFIXES listitems... SUFFIXES listitems...) -
-#   where var is the name of your desired output variable and PREFIXES
-#   and SUFFIXES are special arguments that indicate the start of your
-#   list of prefixes or suffixes respectively.
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__list_combinations)
-	return()
-endif()
-set(__list_combinations YES)
-
-function(list_combinations var)
-	# Parse arguments
-	set(_prefixes)
-	set(_suffixes)
-	set(_nowhere)
-	set(_curdest _nowhere)
-	foreach(_element ${ARGN})
-		if("${_element}" STREQUAL "PREFIXES")
-			set(_curdest _prefixes)
-		elseif("${_element}" STREQUAL "SUFFIXES")
-			set(_curdest _suffixes)
-		else()
-			list(APPEND ${_curdest} "${_element}")
-		endif()
-	endforeach()
-	if(_nowhere)
-		message(STATUS "_prefixes ${_prefixes}")
-		message(STATUS "_prefixes ${_suffixes}")
-		message(STATUS "_prefixes ${_nowhere}")
-		message(FATAL_ERROR
-			"Syntax error in use of ${CMAKE_CURRENT_LIST_FILE}")
-	endif()
-
-	foreach(_prefix ${_prefixes})
-		foreach(_suffix ${_suffixes})
-			list(APPEND _out "${_prefix}${_suffix}")
-		endforeach()
-	endforeach()
-
-	set(${var} "${_out}" PARENT_SCOPE)
-endfunction()
@@ -1,31 +0,0 @@
-# - Compile with multiple processes on MSVC
-#
-#  include(MSVCMultipleProcessCompile)
-#
-# Requires these CMake modules:
-#  ListCombinations.cmake
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(MSVC AND NOT "${MSVC_VERSION}" LESS 1400)
-	# Only available in VS 2005 and newer
-	string(TOUPPER "${CMAKE_CONFIGURATION_TYPES}" _conftypesUC)
-	include(ListCombinations)
-	list_combinations(_varnames
-		PREFIXES
-		CMAKE_C_FLAGS_
-		CMAKE_CXX_FLAGS_
-		SUFFIXES
-		${_conftypesUC})
-	foreach(_var ${_varnames})
-		set(${_var} "${${_var}} /MP")
-	endforeach()
-endif()
@@ -0,0 +1,21 @@
+
+SET(BINARY_DESTINATION "bin")
+SET(LIBRAY_DESTINATION "lib")
+
+configure_file("${CMAKE_CURRENT_LIST_DIR}/AppRun.in" "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen" @ONLY)
+file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>"
+    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen")
+
+install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>" DESTINATION "." RENAME "AppRun"
+        COMPONENT "Freespace2")
+
+
+configure_file("${CMAKE_CURRENT_LIST_DIR}/AppImage.desktop.in" "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen" @ONLY)
+file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop"
+    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen")
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop" DESTINATION "." RENAME "fso.desktop"
+        COMPONENT "Freespace2")
+
+install(FILES "${CMAKE_SOURCE_DIR}/freespace2/resources/app_icon.png" DESTINATION "."
+        COMPONENT "Freespace2")
@@ -11,10 +11,6 @@ if (WIN32)
 	endif()
 elseif(APPLE)
 	# it should just work
-elseif(ANDROID)
-	# connects to a java TTS manager via SDL activity class
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-	# uses speech-dispatcher with dlopen
 else()
 	message(SEND_ERROR "Text to Speech is not supported on this platform!")
 endif()
@@ -9,19 +9,14 @@ else()
 endif()

 set(IS_ARM64 FALSE)
-set(IS_ARMV7A FALSE)

 if (NOT "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "")   # needed to cover Visual Studio generator
    if(CMAKE_GENERATOR_PLATFORM MATCHES "^(aarch64|arm64|ARM64)")
        set(IS_ARM64 TRUE)
-	elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^(armv7)")
-        set(IS_ARMV7A TRUE)
    endif()
 else()
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)")
        set(IS_ARM64 TRUE)
-    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7)")
-        set(IS_ARMV7A TRUE)
    endif()
 endif()

@@ -38,6 +33,6 @@ else()
 endif()

 set(IS_X86 FALSE)
-if (NOT IS_ARM64 AND NOT IS_RISCV AND NOT IS_ARMV7A)
+if (NOT IS_ARM64 AND NOT IS_RISCV)
    set(IS_X86 TRUE)
 endif()
@@ -1,14 +0,0 @@
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-
-IF NOT [x%1]==[x--debugger] GOTO SkipDebuggingMess
-
-ECHO Need to ditch the debugger!
-SHIFT /1
-%1 %2 %3 %4 %5 %6 %7 %8 %9
-GOTO EOF
-
-:SkipDebuggingMess
-%*
-
-:EOF
@@ -1,18 +0,0 @@
-#!/bin/sh
-bindir=$(pwd)
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if test "x$1" = "x--debugger"; then
-	shift
-	cmd="$1"
-	shift
-	if test "x@LAUNCHERS_GOT_GDB@" = "xYES"; then
-		echo "r $@" > $bindir/gdbscript
-		echo "bt" >> $bindir/gdbscript
-		@GDB_COMMAND@ -batch -command=$bindir/gdbscript @LAUNCHERS_GDB_ARG@ $cmd
-	else
-		$cmd $@
-	fi
-else
-	$@
-fi
@@ -1 +0,0 @@
-set @_arg@
@@ -1 +0,0 @@
-export @_arg@
@@ -1,28 +0,0 @@
-		<Configuration
-			Name="@USERFILE_CONFIGNAME@|@USERFILE_PLATFORM@"
-			>
-			<DebugSettings
-				Command="${USERFILE_@USERFILE_CONFIGNAME@_COMMAND}"
-				WorkingDirectory="@USERFILE_WORKING_DIRECTORY@"
-				CommandArguments="@USERFILE_COMMAND_ARGUMENTS@"
-				Attach="false"
-				DebuggerType="3"
-				Remote="1"
-				RemoteMachine="@USERFILE_REMOTE_MACHINE@"
-				RemoteCommand=""
-				HttpUrl=""
-				PDBPath=""
-				SQLDebugging=""
-				Environment="@USERFILE_ENVIRONMENT@"
-				EnvironmentMerge="true"
-				DebuggerFlavor=""
-				MPIRunCommand=""
-				MPIRunArguments=""
-				MPIRunWorkingDirectory=""
-				ApplicationCommand=""
-				ApplicationArguments=""
-				ShimCommand=""
-				MPIAcceptMode=""
-				MPIAcceptFilter=""
-			/>
-		</Configuration>
@@ -1,7 +0,0 @@
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='@USERFILE_CONFIGNAME@|@USERFILE_PLATFORM@'">
-    <LocalDebuggerEnvironment>@USERFILE_ENVIRONMENT@</LocalDebuggerEnvironment>
-    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommand>$(TargetPath)</LocalDebuggerCommand>
-    <LocalDebuggerCommandArguments>@USERFILE_COMMAND_ARGUMENTS@</LocalDebuggerCommandArguments>
-    <LocalDebuggerWorkingDirectory>@NATIVE_WORKING_DIRECTORY@</LocalDebuggerWorkingDirectory>
-  </PropertyGroup>
@@ -1,8 +0,0 @@
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if [%1]==[--debugger] (
-	SHIFT
-)
-
-"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-pause
@@ -1,16 +0,0 @@
-#!/bin/sh
-bindir=$(pwd)
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if test "x$1" = "x--debugger"; then
-	shift
-	if test "x@LAUNCHERS_GOT_GDB@" = "xYES"; then
-		echo "r @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@" > $bindir/gdbscript
-		echo "bt" >> $bindir/gdbscript
-		@GDB_COMMAND@ -batch -command=$bindir/gdbscript @LAUNCHERS_GDB_ARG@ @USERFILE_COMMAND@ 
-	else
-		"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-	fi
-else
-	"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-fi
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioUserFile
-	ProjectType="Visual C++"
-	Version="@USERFILE_VC_VERSION@"
-	ShowAllFiles="false"
-	>
-	<Configurations>
-@USERFILE_CONFIGSECTIONS@
-	</Configurations>
-</VisualStudioUserFile>
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-@USERFILE_CONFIGSECTIONS@
-</Project>
@@ -11,6 +11,9 @@ endif()

 target_link_libraries(platform INTERFACE ${COCOA_LIBRARY})

+# To support C++17 we need to target at least 10.13. maybe 10.14 for some rare features
+SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.13")
+
 SET(CMAKE_SKIP_RPATH FALSE)
 SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
 SET(CMAKE_INSTALL_RPATH @loader_path/../Frameworks/)
@@ -15,4 +15,4 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")

 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-unused-variable -Wno-unused-parameter")

-set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -Wshadow")
+set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -Wshadow")
@@ -43,6 +43,7 @@ endif()

 if (USE_STATIC_LIBCXX)
 	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -static-libstdc++ -Qunused-arguments")
+	set(CLANG_USE_LIBCXX ON)
 endif()

 # For C and C++, the values can be overwritten independently
@@ -118,14 +119,14 @@ string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
 # If no user-set opt flag, set -O3 and -Og
 if ("${CXX_OPT_FLAG}" STREQUAL "")
 	set(CXX_OPT_FLAG_RELEASE "-O3")
-	set(CXX_OPT_FLAG_DEBUG "-O0")
+	set(CXX_OPT_FLAG_DEBUG "-Og")
 else()
 	set(CXX_OPT_FLAG_RELEASE "${CXX_OPT_FLAG}")
 	set(CXX_OPT_FLAG_DEBUG "${CXX_OPT_FLAG}")
 endif()
 if ("${C_OPT_FLAG}" STREQUAL "")
 	set(C_OPT_FLAG_RELEASE "-O3")
-	set(C_OPT_FLAG_DEBUG "-O0")
+	set(C_OPT_FLAG_DEBUG "-Og")
 else()
 	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
 	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
@@ -134,10 +135,8 @@ endif()
 set(CXX_FLAGS_RELEASE "${CXX_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-parameter")
 set(C_FLAGS_RELEASE "${C_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-parameter")

-# Valgrind (as used by CI) does not understand the DWARF5 debug info that clang
-# emits by default, so force DWARF4 to keep memcheck able to symbolize the binary.
-set(CXX_FLAGS_DEBUG "${CXX_OPT_FLAG_DEBUG} -g -gdwarf-4 -Wshadow")
-set(C_FLAGS_DEBUG "${C_OPT_FLAG_DEBUG} -g -gdwarf-4 -Wshadow")
+set(CXX_FLAGS_DEBUG "${CXX_OPT_FLAG_DEBUG} -g -Wshadow")
+set(C_FLAGS_DEBUG "${C_OPT_FLAG_DEBUG} -g -Wshadow")

 # Always use the base flags and add our compiler flags at the back
 set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
@@ -161,14 +161,14 @@ string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
 # If no user-set opt flag, set -O3 and -Og
 if ("${CXX_OPT_FLAG}" STREQUAL "")
 	set(CXX_OPT_FLAG_RELEASE "-O3")
-	set(CXX_OPT_FLAG_DEBUG "-O0")
+	set(CXX_OPT_FLAG_DEBUG "-Og")
 else()
 	set(CXX_OPT_FLAG_RELEASE "${CXX_OPT_FLAG}")
 	set(CXX_OPT_FLAG_DEBUG "${CXX_OPT_FLAG}")
 endif()
 if ("${C_OPT_FLAG}" STREQUAL "")
 	set(C_OPT_FLAG_RELEASE "-O3")
-	set(C_OPT_FLAG_DEBUG "-O0")
+	set(C_OPT_FLAG_DEBUG "-Og")
 else()
 	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
 	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
@@ -13,13 +13,6 @@ option(MSVC_RELEASE_DEBUGGING "Set options that allow to debug release builds" O
 MARK_AS_ADVANCED(FORCE MSVC_USE_RUNTIME_DLL)
 MARK_AS_ADVANCED(FORCE MSVC_RELEASE_DEBUGGING)

-# Qt is only available as DLL-runtime builds, so qtFRED forces the DLL runtime for the whole tree
-if(MSVC_USE_RUNTIME_DLL OR FSO_BUILD_QTFRED)
-	set(FSO_MSVC_RUNTIME_DLL ON)
-else()
-	set(FSO_MSVC_RUNTIME_DLL OFF)
-endif()
-
 # These are the warnings we disable
 set(WARNING_FLAGS
 	/wd4100 # unreferenced formal parameters
@@ -78,19 +71,27 @@ if (MSVC_RELEASE_DEBUGGING)
 	endif()
 endif()

-# The debug runtime is not redistributable (statically linked or not), so only Debug may use it
-IF(FSO_MSVC_RUNTIME_DLL)
-	set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
-	add_compile_definitions(_AFXDLL)
-ELSE()
-	set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-ENDIF()
+IF(MSVC_USE_RUNTIME_DLL)
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MD")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
+ELSE(MSVC_USE_RUNTIME_DLL)
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ENDIF(MSVC_USE_RUNTIME_DLL)

 # Debug
 set(CMAKE_C_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
 set(CMAKE_CXX_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "/DEBUG /INCREMENTAL:NO /MAPINFO:EXPORTS /NODEFAULTLIB:libcmt.lib")

+IF(MSVC_USE_RUNTIME_DLL)
+	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MDd")
+	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
+ELSE(MSVC_USE_RUNTIME_DLL)
+	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
+	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+ENDIF(MSVC_USE_RUNTIME_DLL)
+
 INCLUDE(MSVCMultipleProcessCompile)

 # Visual Studio supports compiling for multiple vector instruction sets
@@ -121,7 +122,8 @@ if(IS_X86)

 endif()

-target_compile_definitions(compiler INTERFACE _CRT_SECURE_NO_DEPRECATE _CRT_SECURE_NO_WARNINGS _SECURE_SCL=0 NOMINMAX _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
+target_compile_definitions(compiler INTERFACE _CRT_SECURE_NO_DEPRECATE _CRT_SECURE_NO_WARNINGS _SECURE_SCL=0 NOMINMAX
+		"$<$<CONFIG:FastDebug>:_ITERATOR_DEBUG_LEVEL=0>" _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)

 if (FSO_FATAL_WARNINGS)
 	# Make warnings fatal if the right variable is set
@@ -3,13 +3,7 @@

 add_library(compiler INTERFACE)

-set(FSO_CONFIG_DEFINITIONS "$<$<CONFIG:Release>:NDEBUG>" "$<$<CONFIG:Debug>:_DEBUG>")
-if(NOT MSVC)
-	# On MSVC the debug runtime flags (/MTd, /MDd) define _DEBUG themselves, and a FastDebug
-	# build on the release runtime must not have it
-	list(APPEND FSO_CONFIG_DEFINITIONS "$<$<CONFIG:FastDebug>:_DEBUG>")
-endif()
-target_compile_definitions(compiler INTERFACE ${FSO_CONFIG_DEFINITIONS})
+target_compile_definitions(compiler INTERFACE "$<$<CONFIG:Release>:NDEBUG>;$<$<CONFIG:Debug>:_DEBUG>;$<$<CONFIG:FastDebug>:_DEBUG>")

 set(FORCED_NATIVE_SIMD_INSTRUCTIONS ON CACHE BOOL "Override instruction set detection and compile with the maximum possible instructions for the current system.")
 IF(IS_X86)
@@ -80,3 +74,12 @@ set(CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_RELEASE}")
 set(CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_RELEASE}")
 set(CMAKE_EXE_LINKER_FLAGS_FASTDEBUG "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
 set(CMAKE_STATIC_LINKER_FLAGS_FASTDEBUG "${CMAKE_STATIC_LINKER_FLAGS_RELEASE}")
+
+if (MSVC)
+	# Adjust runtime library
+	string(REPLACE "/MD" "/MDd" CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_FASTDEBUG}")
+	string(REPLACE "/MT" "/MTd" CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_FASTDEBUG}")
+	
+	string(REPLACE "/MD" "/MDd" CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_FASTDEBUG}")
+	string(REPLACE "/MT" "/MTd" CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_FASTDEBUG}")
+endif()
@@ -66,37 +66,33 @@ ENDIF(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}\")
 	SET(${OUTVAR} "${CMAKE_COMMAND}" -P ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${NAME} PARENT_SCOPE)
 ENDFUNCTION(EP_CHECK_FILE_EXISTS)

-# Use rsync if possible for COPY_FILE_TO_TARGET macro in order to preserve
-# symlinks as copy_if_different follows them which results in multiple copies
-if(PLATFORM_UNIX AND NOT DEFINED RSYNC_BIN)
-	find_program(RSYNC_BIN rsync)
-endif()
-
 MACRO(COPY_FILE_TO_TARGET _target _file)
-	if(RSYNC_BIN)
-		ADD_CUSTOM_COMMAND(
-				TARGET ${_target} POST_BUILD
-				COMMAND ${RSYNC_BIN} -rlq "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}"
-				COMMENT "copying '${_file}'..."
-				VERBATIM
-		)
-	else()
-		if (IS_DIRECTORY "${_file}")
-			get_filename_component(_dirName "${_file}" NAME)
+	if (IS_DIRECTORY "${_file}")
+		get_filename_component(_dirName "${_file}" NAME)
+		if (PLATFORM_MAC AND ("${_file}" MATCHES ".framework$"))
+			# This is stupid, but it preserves symlinks, unlike copy_directory_if_different.
+			# Otherwise we end up creating duplicate files in the copied framework.
 			ADD_CUSTOM_COMMAND(
 					TARGET ${_target} POST_BUILD
-					COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/${_dirName}"
+					COMMAND rsync -rlq "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}"
 					COMMENT "copying '${_file}'..."
 					VERBATIM
 			)
 		else()
 			ADD_CUSTOM_COMMAND(
 					TARGET ${_target} POST_BUILD
-					COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
+					COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/${_dirName}"
 					COMMENT "copying '${_file}'..."
 					VERBATIM
 			)
 		endif()
+	else()
+		ADD_CUSTOM_COMMAND(
+				TARGET ${_target} POST_BUILD
+				COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
+				COMMENT "copying '${_file}'..."
+				VERBATIM
+		)
 	endif()
 endmacro(COPY_FILE_TO_TARGET)

@@ -162,17 +158,27 @@ function(set_precompiled_header _target _headerPath)
 		target_compile_definitions(${_target} PRIVATE CMAKE_PCH)
 		target_precompile_headers(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${_headerPath}>")
 	else()
-		if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-			target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-		elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-			target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/FI ${_headerPath}>")
-		elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-			target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-		elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-			target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-		ELSE()
-			MESSAGE("Unknown compiler for global includes. This will probably break the build.")
-		ENDIF()
+		if (ENABLE_COTIRE)
+			message("${_headerPath}")
+			set_target_properties(${_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${_headerPath}")
+
+			# Disable unity build as it doesn't work well for us
+			set_target_properties(${_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+
+			cotire(${_target})
+		else()
+			if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
+			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/FI ${_headerPath}>")
+			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
+			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
+				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
+			ELSE()
+				MESSAGE("Unknown compiler for global includes. This will probably break the build.")
+			ENDIF()
+		endif()
 	endif()
 endfunction()

@@ -241,17 +247,6 @@ function(suppress_file_warnings)
 	endif()
 endfunction(suppress_file_warnings)

-# Suppress no symbols warnings in static libraries (on Xcode)
-function(suppress_no_symbol_warnings _target)
-	if(XCODE)
-		get_target_property(target_type ${_target} TYPE)
-		if(target_type STREQUAL "STATIC_LIBRARY")
-			set_property(TARGET ${_target} APPEND PROPERTY
-				STATIC_LIBRARY_OPTIONS "-no_warning_for_no_symbols"
-			)
-		endif()
-	endif()
-endfunction(suppress_no_symbol_warnings)

 function(list_target_dependencies _target _out_var)
 	set(out_list)
@@ -6,7 +6,7 @@ if (EXISTS "${PROJECT_SOURCE_DIR}/version_override.cmake")
    include("${PROJECT_SOURCE_DIR}/version_override.cmake")
 endif()

-set_if_not_defined(FSO_VERSION_MAJOR 26)
+set_if_not_defined(FSO_VERSION_MAJOR 24)
 set_if_not_defined(FSO_VERSION_MINOR 3)
 set_if_not_defined(FSO_VERSION_BUILD 0)

@@ -39,7 +39,7 @@ TARGET_LINK_LIBRARIES(code PUBLIC ${PNG_LIBS})
 TARGET_LINK_LIBRARIES(code PUBLIC ${JPEG_LIBS})
 TARGET_LINK_LIBRARIES(code PUBLIC lz4)

-TARGET_LINK_LIBRARIES(code PUBLIC sdl3)
+TARGET_LINK_LIBRARIES(code PUBLIC sdl2)

 if (FSO_BUILD_WITH_FFMPEG)
 	TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)
@@ -59,7 +59,7 @@ endif()

 target_link_libraries(code PUBLIC libRocket)

-target_link_libraries(code PUBLIC pcpnatpmp)
+target_link_libraries(code PUBLIC pcp)

 target_link_libraries(code PUBLIC parsers)

@@ -76,8 +76,9 @@ TARGET_LINK_LIBRARIES(code PUBLIC jansson)

 target_link_libraries(code PUBLIC anl)

+target_link_libraries(code PUBLIC hidapi::hidapi)
+
 target_link_libraries(code PUBLIC imgui)
-target_link_libraries(code PUBLIC implot)

 IF(FSO_BUILD_WITH_OPENXR)
 	target_link_libraries(code PUBLIC OpenXR::openxr_loader)
@@ -112,9 +113,16 @@ if (FSO_BUILD_WITH_OPENGL)
 	target_compile_definitions(code PUBLIC WITH_OPENGL)
 endif()
 if (FSO_BUILD_WITH_VULKAN)
-	target_compile_definitions(code PUBLIC WITH_VULKAN VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1 VK_NO_PROTOTYPES)
-	target_include_directories(code PUBLIC Vulkan::Headers)
-	target_link_libraries(code PUBLIC VulkanMemoryAllocator)
+	find_package(Vulkan REQUIRED)
+	if (Vulkan_FOUND)
+		target_compile_definitions(code PUBLIC WITH_VULKAN)
+		target_link_libraries(code PRIVATE Vulkan::Vulkan)
+
+		target_compile_definitions(code PUBLIC WITH_VULKAN VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1 VK_NO_PROTOTYPES)
+	else()
+		message(WARNING "FSO_BUILD_WITH_VULKAN was set, but the package was unable to be found. Forcing OFF.")
+		set(FSO_BUILD_WITH_VULKAN OFF CACHE BOOL "Enable compilation of the Vulkan renderer" FORCE)
+	endif()
 endif()

 include(shaders.cmake)
@@ -131,8 +139,5 @@ set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_COPY_PHASE_STRIP[variant=D
 set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT[variant=Debug] "NO")
 set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN[variant=Debug] "NO")

-# Prevent warnings on files with no symbols on Mac
-suppress_no_symbol_warnings(code)
-
 # Prevent GCC warnings in third-party BitOp... see GitHub #4366
 suppress_file_warnings(scripting/lua/bitop/bit.c)
@@ -30,7 +30,7 @@ class BuiltinActionDefinition : public ActionDefinition {
 		// This should have been caught earlier
 		Assertion(paramIter != parameterExpressions.cend(), "Could not find built-in parameter!");

-		return std::make_unique<TAction>(paramIter->second.template asTyped<ActionValueType>());
+		return std::unique_ptr<Action>(new TAction(paramIter->second.template asTyped<ActionValueType>()));
 	}
 };

@@ -19,7 +19,7 @@ expression::ProgramVariables getDefaultTableVariables()
 	expression::ProgramVariables vars;

 	vars.setValue({"locals", "position"}, expression::Value(vmd_zero_vector));
-	vars.setValue({"locals", "direction"}, expression::Value(vmd_z_vector));
+	vars.setValue({"locals", "direction"}, expression::Value(vmd_zero_vector));

 	return vars;
 }
@@ -24,7 +24,7 @@ ActionExpression ActionExpression::parseFromTable(ValueType expectedReturnType,

 	stuff_string(expressionText, F_NAME);

-	ExpressionParser parser(std::move(expressionText));
+	ExpressionParser parser(expressionText);

 	auto expression = parser.parse(context);

@@ -45,7 +45,7 @@ ActionExpression ActionExpression::parseFromTable(ValueType expectedReturnType,
 	}

 	// Everything is valid
-	return ActionExpression(std::move(expression));
+	return ActionExpression(expression);
 }

 Value ActionExpression::execute(const ProgramVariables& variables) const
@@ -51,8 +51,8 @@ class ExpressionBuilderVisitor : public ActionExpressionVisitor {
 			operatorText = context->MINUS()->getText();
 		}

-		const auto leftExpr = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(0)));
-		const auto rightExpr = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(1)));
+		const auto leftExpr = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		const auto rightExpr = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();

 		auto operatorExpression = std::make_shared<nodes::FunctionCallExpression>(operatorTok,
 			true,
@@ -88,8 +88,8 @@ class ExpressionBuilderVisitor : public ActionExpressionVisitor {
 	antlrcpp::Any visitRandom_range_expression(ActionExpressionParser::Random_range_expressionContext* context) override
 	{
 		auto expression = std::make_shared<nodes::RandomRangeExpression>(context->RAND_L_PAREN()->getSymbol(),
-			std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(0))),
-			std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(1))));
+			visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>(),
+			visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>());
 		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
 	}
 	antlrcpp::Any visitLiteral_expression(ActionExpressionParser::Literal_expressionContext* context) override
@@ -122,9 +122,9 @@ class ExpressionBuilderVisitor : public ActionExpressionVisitor {
 	}
 	antlrcpp::Any visitVec3d_constructor(ActionExpressionParser::Vec3d_constructorContext* context) override
 	{
-		const auto xExpression = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(0)));
-		const auto yExpression = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(1)));
-		const auto zExpression = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(visit(context->expression(2)));
+		const auto xExpression = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		const auto yExpression = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		const auto zExpression = visit(context->expression(2)).as<std::shared_ptr<nodes::AbstractExpression>>();

 		auto expression = std::make_shared<nodes::VectorConstructorExpression>(context->L_PAREN()->getSymbol(),
 			xExpression,
@@ -157,7 +157,7 @@ std::shared_ptr<nodes::AbstractExpression> ExpressionParser::parse(const ParseCo
 	if (errListener.diagnostics.empty()) {
 		// Only do semantic checking if syntax is valid
 		ExpressionBuilderVisitor builder;
-		exprReturn = std::any_cast<std::shared_ptr<nodes::AbstractExpression>>(tree->accept(&builder));
+		exprReturn = tree->accept(&builder).as<std::shared_ptr<nodes::AbstractExpression>>();

 		if (!exprReturn->validate(&parser, context)) {
 			exprReturn = nullptr;
@@ -6,7 +6,7 @@ namespace expression {

 ProgramVariablesDefinition& ProgramVariablesDefinition::addScope(const SCP_string& name)
 {
-	auto scope = std::make_unique<ProgramVariablesDefinition>();
+	auto scope = std::unique_ptr<ProgramVariablesDefinition>(new ProgramVariablesDefinition());

 	auto scopePtr = scope.get();

@@ -38,7 +38,7 @@ const TypeDefinition& TypeDefinition::forValueType(ValueType type)
 	case ValueType::String:
 		return s_identifier;
 	default:
-		UNREACHABLE("Invalid value type %d!", static_cast<int>(type));
+		UNREACHABLE("Invalid value type!");
 		return s_integer; // Make compiler happy
 	}
 }
@@ -70,7 +70,7 @@ ActionResult MoveToSubmodel::execute(ProgramLocals& locals) const

 std::unique_ptr<Action> MoveToSubmodel::clone() const
 {
-	return std::make_unique<MoveToSubmodel>(*this);
+	return std::unique_ptr<Action>(new MoveToSubmodel(*this));
 }

 } // namespace types
@@ -61,7 +61,7 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
 	matrix orientation;
 	vm_vector_2_matrix_norm(&orientation, &direction);	// direction is normalized in SetDirectionAction::execute

-	source->setHost(std::make_unique<EffectHostObject>(locals.host.objp(), local_pos, orientation, true));
+	source->setHost(make_unique<EffectHostObject>(locals.host.objp(), local_pos, orientation, true));
 	source->finishCreation();

 	return ActionResult::Finished;
@@ -69,7 +69,7 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const

 std::unique_ptr<Action> ParticleEffectAction::clone() const
 {
-	return std::make_unique<ParticleEffectAction>(*this);
+	return std::unique_ptr<Action>(new ParticleEffectAction(*this));
 }

 } // namespace types
@@ -57,7 +57,7 @@ ActionResult PlaySoundAction::execute(ProgramLocals& locals) const
 }
 std::unique_ptr<Action> PlaySoundAction::clone() const
 {
-	return std::make_unique<PlaySoundAction>(*this);
+	return std::unique_ptr<Action>(new PlaySoundAction(*this));
 }
 } // namespace types
 } // namespace actions
@@ -32,7 +32,7 @@ ActionResult SetDirectionAction::execute(ProgramLocals& locals) const

 std::unique_ptr<Action> SetDirectionAction::clone() const
 {
-	return std::make_unique<SetDirectionAction>(*this);
+	return std::unique_ptr<Action>(new SetDirectionAction(*this));
 }

 } // namespace types
@@ -27,7 +27,7 @@ ActionResult SetPositionAction::execute(ProgramLocals& locals) const

 std::unique_ptr<Action> SetPositionAction::clone() const
 {
-	return std::make_unique<SetPositionAction>(*this);
+	return std::unique_ptr<Action>(new SetPositionAction(*this));
 }

 } // namespace types
@@ -41,7 +41,7 @@ ActionResult WaitAction::execute(actions::ProgramLocals& locals) const
 }
 std::unique_ptr<Action> WaitAction::clone() const
 {
-	return std::make_unique<WaitAction>(*this);
+	return std::unique_ptr<Action>(new WaitAction(*this));
 }

 } // namespace types
@@ -16,11 +16,9 @@
 #include "ai/ai.h"
 #include "object/object.h"
 #include "ship/ship.h"
-#include "utils/string_utils.h"


-// heap-allocated rather than SCP_string, so that the pointers held by ai goals stay valid when the vector grows
-SCP_vector<SCP_vm_unique_ptr<char>> Goal_target_names;
+SCP_vector<char *> Goal_target_names;
 ai_info Ai_info[MAX_AI_INFO];
 ai_info *Player_ai;

@@ -59,13 +57,20 @@ const char *ai_get_goal_target_name(const char *name, int *index)
 	Assertion(name != nullptr && index != nullptr, "Arguments cannot be null!");

 	for (int i = 0; i < static_cast<int>(Goal_target_names.size()); ++i) {
-		if (!stricmp(name, Goal_target_names[i].get())) {
+		if (!stricmp(name, Goal_target_names[i])) {
 			*index = i;
-			return Goal_target_names[i].get();
+			return Goal_target_names[i];
 		}
 	}

 	*index = static_cast<int>(Goal_target_names.size());
-	Goal_target_names.push_back(util::vm_unique_copy(name, false));
-	return Goal_target_names.back().get();
+	Goal_target_names.push_back(vm_strdup(name));
+	return Goal_target_names[*index];
+}
+
+void ai_clear_goal_target_names()
+{
+	for (auto ptr : Goal_target_names)
+		vm_free(ptr);
+	Goal_target_names.clear();
 }
@@ -42,7 +42,6 @@ typedef struct ai_flag_description {
 extern ai_flag_name Ai_flag_names[];
 extern ai_flag_description Ai_flag_descriptions[];
 extern const int Num_ai_flag_names;
-extern const size_t Num_ai_flag_descriptions;

 //	dock_orient_and_approach() modes.
 #define	DOA_APPROACH	1		//	Approach the current point on the path (aip->path_cur)
@@ -295,7 +294,6 @@ typedef struct ai_info {
 	vec3d	path_create_pos;		//	Object's position at time of global path creation.
 	matrix	path_create_orient;	//	Object's orientation at time of global path creation.
 	int		mp_index;				//	Model path index.  Index in polymodel:model_paths
-	int		mp_randomized_vert;		//	Vertex of the model path that was given a random offset, or -1
 	fix		path_next_check_time;	//	Last time checked to see if would collide with model.
 	int		path_goal_dist;		// minimum distance to first path point to consider path reached
 	int		path_subsystem_next_check;	// timestamp to next check if subsystem is still visible
@@ -495,8 +493,8 @@ extern int Mission_all_attack;	//	!0 means all teams attack all teams.
 extern ai_info Ai_info[];
 extern ai_info *Player_ai;

-extern SCP_vector<ai_class> Ai_classes;
-extern SCP_vector<const char*> Ai_class_names;
+extern ai_class *Ai_classes;
+extern char** Ai_class_names;

 extern int Num_ai_classes;
 extern int Ai_firing_enabled;
@@ -526,16 +524,16 @@ void ai_object_init(object * obj, int ai_index);
 void ai_process( object * obj, int ai_index, float frametime );

 const char *ai_get_goal_target_name(const char *name, int *index);
+void ai_clear_goal_target_names();

 extern void init_ai_system(void);
-extern void ai_attack_object(object *attacker, object *attacked, int ship_info_index = -1, int class_type = -1);
+extern void ai_attack_object(object *attacker, object *attacked, int ship_info_index = -1);
 extern void ai_evade_object(object *evader, object *evaded);
 extern void ai_ignore_object(object *ignorer, object *ignored, int ignore_new);
 extern void ai_ignore_wing(object *ignorer, int wingnum);
 extern void ai_dock_with_object(object *docker, int docker_index, object *dockee, int dockee_index, int dock_type);
 extern void ai_stay_still(object *still_objp, vec3d *view_pos);
 extern void ai_do_default_behavior(object *obj);
-extern void ai_reset_order_state(ai_info *aip);
 extern void ai_start_waypoints(object *objp, int wl_index, int wp_flags, int start_index, bool force = false);
 extern void ai_ship_hit(object *objp_ship, object *hit_objp, const vec3d *hit_normal);
 extern void ai_ship_destroy(int shipnum);
@@ -561,7 +559,7 @@ extern void ai_set_guard_wing(object *objp, int wingnum);
 extern void ai_warp_out(object *objp, vec3d *vp);
 extern void ai_attack_wing(object *attacker, int wingnum);
 extern void ai_deathroll_start(object *ship_obj);
-extern int set_target_objnum(ai_info* aip, int objnum);
+extern int set_target_objnum(ai_info *aip, int objnum);
 extern void ai_form_on_wing(object *objp, object *goal_objp);
 extern void ai_do_stay_near(object *objp, object *other_obj, float dist, int additional_data);
 extern ship_subsys *set_targeted_subsys(ai_info *aip, ship_subsys *new_subsys, int parent_objnum);
@@ -598,9 +596,7 @@ extern int ai_maybe_fire_afterburner(object *objp, ai_info *aip);
 extern void set_predicted_enemy_pos(vec3d *predicted_enemy_pos, object *pobjp, vec3d *enemy_pos, vec3d *enemy_vel, ai_info *aip);

 extern int is_instructor(object *objp);
-extern int find_enemy(int objnum, float range, int max_attackers, bool for_pursuit, int ship_info_index = -1, int class_type = -1);
-extern bool ai_targets_for_pursuit(const ai_info *aip);
-extern bool ai_declines_pursuit(const object *attacker_objp, const object *target_objp);
+extern int find_enemy(int objnum, float range, int max_attackers, int ship_info_index = -1);

 float ai_get_weapon_speed(const ship_weapon *swp);
 void set_predicted_enemy_pos_turret(vec3d *predicted_enemy_pos, const vec3d *gun_pos, const object *pobjp, const vec3d *enemy_pos, const vec3d *enemy_vel, float weapon_speed, float time_enemy_in_range);
@@ -621,7 +617,7 @@ extern float dock_orient_and_approach(object *docker_objp, int docker_index, obj
 void ai_set_mode_warp_out(object *objp, ai_info *aip);

 // prototyped by Goober5000
-int get_nearest_objnum(int objnum, int enemy_team_mask, int enemy_wing, float range, int max_attackers, bool for_pursuit, int ship_info_index, int class_type = -1);
+int get_nearest_objnum(int objnum, int enemy_team_mask, int enemy_wing, float range, int max_attackers, int ship_info_index);

 // moved to header file by Goober5000
 void ai_announce_ship_dying(object *dying_objp);
@@ -44,15 +44,12 @@ namespace AI {
 		Goal_on_hold,		// when set, this goal cannot currently be satisfied, although it could be in the future
 		Subsys_needs_fixup,	// when set, the subsystem index (for a destroy subsystem goal) is invalid and must be gotten from the subsys name stored in docker.name field!!
 		Goal_override,		// paired with ai_goal_type::DYNAMIC to mean this goal overrides any other goal
-		Want_override,		// a goal should set this flag if Goal_override should be assigned when the goal is achievable
 		Purge,				// purge this goal next time we process
-		Purge_when_new_goal_added,	// this goal is perpetual until any other goal is added, at which time it sets its own Purge flag
-		Goals_purged,		// this goal has already caused other goals to get purged (because it is something like ai-disarm that renders other goals invalid)
+		Goals_purged,		// this goal has already caused other goals to get purged
 		Depart_sound_played,// Goober5000 - replacement for AL's hack ;)
 		Target_own_team,	// this attack goal is allowed to target friendlies
 		Afterburn_hard,		// afterburn as hard as possible to the goal
 		Waypoints_in_reverse,	// decrement instead of increment
-		Clear_all_goals_first,	// this goal wipes all goals (including itself) before it runs (handled separately, and in a different place, from purging invalid goals)

 		NUM_VALUES
 	};
@@ -132,7 +129,6 @@ namespace AI {
        Smart_shield_management,
        Smart_subsystem_targeting_for_turrets,
        Strict_turret_tagged_only_targeting,
-		Ships_intercept_mines,				// all AI-controlled ships autonomously engage hostile mines within mine_targetable_range of themselves
 		Support_dont_add_primaries, //Prevents support ship from equipping new primary as requested in https://scp.indiegames.us/mantis/view.php?id=3198
        Turrets_ignore_target_radius,
        Use_actual_primary_range,
@@ -146,7 +142,6 @@ namespace AI {
 		Fightercraft_nonshielded_ships_can_manage_ets,
 		Ships_playing_dead_dont_manage_ets,
 		Better_combat_collision_avoidance,
-		Better_combat_collision_avoid_includes_target,
 		Better_guard_collision_avoidance,
 		Require_exact_los,
 		Improved_missile_avoidance,
@@ -175,13 +170,6 @@ namespace AI {
 		Debris_respects_big_damage,
 		Dont_limit_change_in_speed_due_to_physics_whack,
 		Guards_ignore_protected_attackers,
-		Fix_standard_strafe,
-		Fix_ai_target_recovery,	// a) strafing ships that lose their target re-process their orders, like chasing ships already do
-								// b) ships parked in AIM_NONE while holding a standing chase order (attack-any etc.) re-process their orders;
-								// c) target selection for pursuit (chasing, guard reactions, retaliation) skips ships outside the attacker's
-								//    actively-pursues list; targets held while not chasing are unaffected, and explicitly ordered targets are
-								//    still assigned but not chased or strafed;
-								// d) enemy_wing is reset when a new order takes over (shared with Fix_stale_ai_order_state)
 		Standard_strafe_used_more,
 		Unify_usage_ai_shield_manage_delay,
 		Fix_AI_shield_management_bug,
@@ -190,24 +178,6 @@ namespace AI {
 		Freespace_1_missile_behavior,
 		ETS_uses_power_output,
 		ETS_energy_same_regardless_of_system_presence,
-		Dont_form_on_wing_at_mission_start,
-		Do_not_clear_goals_when_running_form_on_wing,
-		Do_not_clear_goals_when_running_stay_still,
-		Do_not_set_override_when_assigning_form_on_wing,
-		Purge_player_issued_form_on_wing_after_subsequent_order,
-		Cancel_future_waves_of_any_wing_launched_from_an_exited_ship,
-		Fix_ignore_if_dead_flag,
-		Kamikaze_no_collision_avoidance,
-		Fix_big_ship_waypoint_completion,	// a) big ships complete a waypoint within their radius rather than sqrt(radius);
-											// b) completion no longer requires moving 0.1m in a single frame (framerate-dependent)
-		Fix_shockwave_expire_before_do_damage,	// shockwaves whose lifetime is shorter than one frame apply their area damage at least once before expiring
-		Fix_small_ai_recover_after_engines_repaired, // ensure small ship AI can switch back to useful AI modes if engines get repaired
-		Fix_model_path_refresh_randomization,	// a subsystem path keeps its randomized point when the path is refreshed because the target moved
-		Fix_bay_speed_ramp,		// the fighterbay speed ramp covers only the bay path itself, not points that route a departing ship around the carrier, and never exceeds max speed
-		Fix_stale_ai_order_state,	// a) enemy_wing, guard_*, previous_mode, resume_goal_time, and the targeted subsystem (with its path) are reset when a new order takes over (enemy_wing is also reset under Fix_ai_target_recovery);
-									// b) a dynamic chase saves previous_mode/previous_submode; it and strafe entry leave them alone during an ongoing dynamic goal (evading a weapon still overwrites them, which is harmless since the evade resume re-processes orders);
-									// c) resuming guard duty discards any subsystem target and path left over from the interruption;
-									// d) a ship ordered to guard itself, or to guard a wing it leads (including one that becomes leader mid-mission), treats that goal as unachievable instead of holding it forever

 		NUM_VALUES
 	};
@@ -42,7 +42,6 @@ void set_flag(ai_profile_t *profile, const char *name, AI::Profile_Flags flag)
 const char *AI_path_types[] = {
 	"normal",
 	"alt1",
-	"alt2",
 };

 int Num_ai_path_types = sizeof(AI_path_types)/sizeof(char*);
@@ -140,7 +139,7 @@ void parse_ai_profiles_tbl(const char *filename)
 				// don't create multiple profiles with the same name
 				if (previous_profile != NULL)
 				{
-					Warning(LOCATION, "An AI profile named '%s' already exists!  The new one will not be created.\n", profile_name);
+					Warning(LOCATION, "An ai profile named '%s' already exists!  The new one will not be created.\n", profile_name);
 				}
 				else
 				{
@@ -412,7 +411,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$disable player secondary doublefire:", AI::Profile_Flags::Disable_player_secondary_doublefire);

-				set_flag(profile, "$disable AI secondary doublefire:", AI::Profile_Flags::Disable_ai_secondary_doublefire);
+				set_flag(profile, "$disable ai secondary doublefire:", AI::Profile_Flags::Disable_ai_secondary_doublefire);

 				set_flag(profile, "$disable weapon damage scaling:", AI::Profile_Flags::Disable_weapon_damage_scaling);

@@ -450,7 +449,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$force beam turrets to use normal fov:", AI::Profile_Flags::Force_beam_turret_fov);

-				set_flag(profile, "$fix AI class bug:", AI::Profile_Flags::Fix_ai_class_bug);
+				set_flag(profile, "$fix ai class bug:", AI::Profile_Flags::Fix_ai_class_bug);

 				set_flag(profile, "$turrets ignore targets radius in range checks:", AI::Profile_Flags::Turrets_ignore_target_radius);

@@ -478,9 +477,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$support don't add primaries:", AI::Profile_Flags::Support_dont_add_primaries);

-				if (optional_string("$max allies rearming threshold:"))
-				 	stuff_int(&profile->max_allies_rearming_threshold);
-
 				set_flag(profile, "$firing requires exact los:", AI::Profile_Flags::Require_exact_los);

 				if (optional_string("$exact los minimum detection radius:")) {
@@ -505,13 +501,13 @@ void parse_ai_profiles_tbl(const char *filename)
 						profile->ai_path_mode = j;
 					}
 					else {
-						Warning(LOCATION, "Invalid AI path mode '%s' specified", buf);
+						Warning(LOCATION, "Invalid ai path mode '%s' specified", buf);
 					}
 				}

 				set_flag(profile, "$no warp camera:", AI::Profile_Flags::No_warp_camera);

-				set_flag(profile, "$fix AI path order bug:", AI::Profile_Flags::Fix_ai_path_order_bug);
+				set_flag(profile, "$fix ai path order bug:", AI::Profile_Flags::Fix_ai_path_order_bug);

 				set_flag(profile, "$strict turret-tagged-only targeting:", AI::Profile_Flags::Strict_turret_tagged_only_targeting);

@@ -592,8 +588,6 @@ void parse_ai_profiles_tbl(const char *filename)
 					stuff_float(&profile->better_collision_avoid_aggression_combat);
 				}

-				set_flag(profile, "+combat collision avoidance for fightercraft includes target:", AI::Profile_Flags::Better_combat_collision_avoid_includes_target);
-
 				set_flag(profile, "$better guard collision avoidance for fightercraft:", AI::Profile_Flags::Better_guard_collision_avoidance);

 				if (optional_string("+guard collision avoidance aggression for fightercraft:")) {
@@ -622,7 +616,7 @@ void parse_ai_profiles_tbl(const char *filename)
 						profile->ai_range_aware_secondary_select_mode = j;
 					}
 					else {
-						Warning(LOCATION, "Invalid AI secondary range awareness mode '%s' specified", buf);
+						Warning(LOCATION, "Invalid ai secondary range awareness mode '%s' specified", buf);
 					}
 				}

@@ -675,10 +669,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$fix avoid-shockwave bugs:", AI::Profile_Flags::Fix_avoid_shockwave_bugs);

-				set_flag(profile, "$fix standard strafe:", AI::Profile_Flags::Fix_standard_strafe);
-
-				set_flag(profile, "$fix AI target recovery:", AI::Profile_Flags::Fix_ai_target_recovery);
-
 				set_flag(profile, "$standard strafe used more:", AI::Profile_Flags::Standard_strafe_used_more);

 				if (optional_string("$standard strafe triggers under this speed:")) {
@@ -693,14 +683,6 @@ void parse_ai_profiles_tbl(const char *filename)
 					stuff_float(&profile->strafe_max_unhit_time);
 				}

-				if (optional_string("$strafe retreat collide time:")) {
-					stuff_float(&profile->strafe_retreat_collide_time);
-				}
-
-				if (optional_string("$strafe retreat collide distance:")) {
-					stuff_float(&profile->strafe_retreat_collide_distance);
-				}
-
 				if (optional_string("$guard uses big-orbit for target radius above:")) {
 					stuff_float(&profile->guard_big_orbit_above_target_radius);
 				}
@@ -715,10 +697,6 @@ void parse_ai_profiles_tbl(const char *filename)
 					}
 				}

-				if (optional_string("$attack-any idle circle distance:")) {
-					stuff_float(&profile->attack_any_idle_circle_distance);
-				}
-
 				set_flag(profile, "$unify usage of AI Shield Manage Delay:", AI::Profile_Flags::Unify_usage_ai_shield_manage_delay);

 				set_flag(profile, "$fix AI shield management bug:", AI::Profile_Flags::Fix_AI_shield_management_bug);
@@ -733,45 +711,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$ETS energy same regardless of system presence:", AI::Profile_Flags::ETS_energy_same_regardless_of_system_presence);

-				set_flag(profile, "$don't issue form-on-wing goals at mission start:", AI::Profile_Flags::Dont_form_on_wing_at_mission_start);
-
-				if (optional_string("$default form-on-wing priority:")) {
-					int priority;
-					stuff_int(&priority);
-					if (priority > 0) {
-						profile->default_form_on_wing_priority = priority;
-					} else {
-						mprintf(("Warning: $default form-on-wing priority: should be > 0 (read %d).  Value will not be used.\n", priority));
-					}
-				}
-
-				set_flag(profile, "$do not clear goals when running form-on-wing:", AI::Profile_Flags::Do_not_clear_goals_when_running_form_on_wing);
-
-				set_flag(profile, "$do not clear goals when running stay-still:", AI::Profile_Flags::Do_not_clear_goals_when_running_stay_still);
-
-				set_flag(profile, "$do not set override when assigning form-on-wing:", AI::Profile_Flags::Do_not_set_override_when_assigning_form_on_wing);
-
-				set_flag(profile, "$purge player-issued form-on-wing after subsequent order:", AI::Profile_Flags::Purge_player_issued_form_on_wing_after_subsequent_order);
-
-				set_flag(profile, "$cancel future waves of any wing launched from an exited ship:", AI::Profile_Flags::Cancel_future_waves_of_any_wing_launched_from_an_exited_ship);
-
-				set_flag(profile, "$ships intercept mines:", AI::Profile_Flags::Ships_intercept_mines);
-
-				set_flag(profile, "$fix 'ignore if dead' flag:", AI::Profile_Flags::Fix_ignore_if_dead_flag);
-
-				set_flag(profile, "$no collision avoidance for kamikaze fighters:", AI::Profile_Flags::Kamikaze_no_collision_avoidance);
-
-				set_flag(profile, "$fix big ship waypoint completion:", AI::Profile_Flags::Fix_big_ship_waypoint_completion);
-
-				set_flag(profile, "$fix shockwave expiring before dealing damage:", AI::Profile_Flags::Fix_shockwave_expire_before_do_damage);
-
-				set_flag(profile, "$fix fighter/bomber AI recovers after engines repaired:", AI::Profile_Flags::Fix_small_ai_recover_after_engines_repaired);
-
-				set_flag(profile, "$fix subsystem path randomization on refresh:", AI::Profile_Flags::Fix_model_path_refresh_randomization);
-
-				set_flag(profile, "$fix fighterbay speed ramp:", AI::Profile_Flags::Fix_bay_speed_ramp);
-
-				set_flag(profile, "$fix stale AI order state:", AI::Profile_Flags::Fix_stale_ai_order_state);

 				// end of options ----------------------------------------

@@ -840,7 +779,7 @@ void ai_profiles_init()
 	Ai_profiles_initted = 1;
 }

-int ai_profile_lookup(const char *name)
+int ai_profile_lookup(char *name)
 {
 	for (int i = 0; i < Num_ai_profiles; i++)
 		if (!stricmp(name, Ai_profiles[i].profile_name))
@@ -864,7 +803,6 @@ void ai_profile_t::reset()
 	ai_range_aware_secondary_select_mode = AI_RANGE_AWARE_SEC_SEL_MODE_RETAIL;
 	turret_target_recheck_time = 2000.0f;
 	rot_fac_multiplier_ply_collisions = 0.0f;
-	max_allies_rearming_threshold = 2;

 	better_collision_avoid_aggression_combat = 3.5f;
 	better_collision_avoid_aggression_guard = 3.5f;
@@ -872,14 +810,9 @@ void ai_profile_t::reset()
 	standard_strafe_when_below_speed = 3.0f;
 	strafe_retreat_box_dist = 300.0f;
 	strafe_max_unhit_time = 20.0f;
-	strafe_retreat_collide_time = 2.0f;
-	strafe_retreat_collide_distance = 100.0f;

 	guard_big_orbit_above_target_radius = 500.0f;
 	guard_big_orbit_max_speed_percent = 1.0f;
-	attack_any_idle_circle_distance = 100.0f;
-
-	default_form_on_wing_priority = 99;	// as originally assigned in ai_add_goal_sub_sexp()

    for (int i = 0; i < NUM_SKILL_LEVELS; ++i) {
        max_incoming_asteroids[i] = 0;
@@ -994,21 +927,5 @@ void ai_profile_t::reset()
 	}
 	if (mod_supports_version(25, 0, 0)) {
 		flags.set(AI::Profile_Flags::Fix_avoid_shockwave_bugs);
-		flags.set(AI::Profile_Flags::Purge_player_issued_form_on_wing_after_subsequent_order);
-		flags.set(AI::Profile_Flags::Cancel_future_waves_of_any_wing_launched_from_an_exited_ship);
-	}
-	if (mod_supports_version(26, 0, 0)) {
-		flags.set(AI::Profile_Flags::Fix_ignore_if_dead_flag);
-	}
-	if (mod_supports_version(26, 2, 0)) {
-		flags.set(AI::Profile_Flags::Kamikaze_no_collision_avoidance);
-		flags.set(AI::Profile_Flags::Fix_big_ship_waypoint_completion);
-		flags.set(AI::Profile_Flags::Fix_shockwave_expire_before_do_damage);
-		flags.set(AI::Profile_Flags::Fix_small_ai_recover_after_engines_repaired);
-		flags.set(AI::Profile_Flags::Fix_standard_strafe);
-		flags.set(AI::Profile_Flags::Fix_ai_target_recovery);
-		flags.set(AI::Profile_Flags::Fix_model_path_refresh_randomization);
-		flags.set(AI::Profile_Flags::Fix_bay_speed_ramp);
-		flags.set(AI::Profile_Flags::Fix_stale_ai_order_state);
 	}
 }
@@ -17,7 +17,6 @@
 // AI Path types
 #define	AI_PATH_MODE_NORMAL 0
 #define	AI_PATH_MODE_ALT1	1
-#define AI_PATH_MODE_ALT2   2

 #define	AI_RANGE_AWARE_SEC_SEL_MODE_RETAIL 0
 #define	AI_RANGE_AWARE_SEC_SEL_MODE_AWARE 1
@@ -102,9 +101,6 @@ public:

 	float detail_distance_mult[MAX_DETAIL_VALUE + 1];	//MAX_DETAIL_VALUE really needs to be 4

-	// max number of allies allowed to be rearming at the same time
-	int max_allies_rearming_threshold;	
-
 	// minimum radius for the line-of-sight (los) detection --wookieejedi
 	float los_min_detection_radius;

@@ -143,18 +139,11 @@ public:
 	float standard_strafe_when_below_speed; // Speed at which standard strafing large ships is possibly triggered
 	float strafe_retreat_box_dist;          // Distance beyond the bounding box to retreat to strafing point 
 	float strafe_max_unhit_time;            // Maximum amount of time to stay in strafe mode if not hit
-	float strafe_retreat_collide_time;		// When anticipated collision time is less than this, begin retreat from strafe
-	float strafe_retreat_collide_distance;	// When perpendicular distance to *surface* is less than this, begin retreat from strafe

 	// AI guard options  --wookieejedi
 	float guard_big_orbit_above_target_radius; // Radius of guardee that triggers ai_big_guard() 
 	float guard_big_orbit_max_speed_percent;   // Max percent of forward speed that is used in ai_big_guard() 

-	// AI attack any option --wookieejedi
-	float attack_any_idle_circle_distance; // Radius that AI circles around a point while waiting for new enemies in attack-any mode
-
-	int default_form_on_wing_priority;	// the priority used if not specified in the sexp
-
    void reset();
 };

@@ -163,10 +152,10 @@ extern int Num_ai_profiles;
 extern int Default_ai_profile;
 extern ai_profile_t Ai_profiles[MAX_AI_PROFILES];

-#define AI_PROFILES_INDEX(ai_p) (static_cast<int>((ai_p)-Ai_profiles))
+#define AI_PROFILES_INDEX(ai_p) ((int)((ai_p) - Ai_profiles))

 void ai_profiles_init();

-int ai_profile_lookup(const char *name);
+int ai_profile_lookup(char *name);

 #endif
@@ -40,6 +40,9 @@

 // AI BIG MAGIC NUMBERS
 // Select strafing options are now exposed to modders  --wookieejedi
+#define	STRAFE_RETREAT_COLLIDE_TIME	2.0		// when anticipated collision time is less than this, begin retreat
+#define	STRAFE_RETREAT_COLLIDE_DIST	100		// when perpendicular distance to *surface* is less than this, begin retreat
+
 #define	EVADE_BOX_BASE_DISTANCE			300		// standard distance to end evade submode
 #define	EVADE_BOX_MIN_DISTANCE			200		// minimun distance to end evade submode, after long time

@@ -59,23 +62,13 @@
 void	ai_big_evade_ship();
 void	ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float dist_to_enemy, int modelnum);
 void	ai_big_avoid_ship();
-bool	ai_big_maybe_follow_subsys_path(bool do_dot_check=true);
+int	ai_big_maybe_follow_subsys_path(int do_dot_check=1);
 void ai_big_strafe_position();
-static bool ai_big_strafe_maybe_retreat(const vec3d *target_pos);
+static int ai_big_strafe_maybe_retreat(const vec3d *target_pos);

 extern void compute_desired_rvec(vec3d *rvec, const vec3d *goal_pos, const vec3d *cur_pos);
 extern void big_ship_collide_recover_start(const object *objp, const object *big_objp, const vec3d *collision_normal);

-// Record the mode being left as the one to return to, unless a dynamic goal is already in progress
-// (in which case previous_mode still refers to the mode that goal interrupted).
-static void ai_big_save_previous_mode(ai_info *aip)
-{
-	if (The_mission.ai_profile->flags[AI::Profile_Flags::Fix_stale_ai_order_state] && aip->active_goal == AI_ACTIVE_GOAL_DYNAMIC)
-		return;
-
-	aip->previous_mode = aip->mode;
-}
-

 //	Called by ai_big_pick_attack_point.
 //	Generates a random attack point.
@@ -153,10 +146,6 @@ done_1:

 	*attack_point = best_point;

-	//The following raycast tends to make up 10%(!) of total AI-frametime for basically no benefit, especially in the common case for turrets where the normal isn't even queried.
-	if (surface_normal == nullptr && Disable_expensive_turret_target_check)
-		return;
-
 	// Cast from attack_objp_pos to local_attack_pos and check for nearest collision.
 	// If no collision, cast to (0,0,0) [center of big ship]**  [best_point initialized to 000]

@@ -358,10 +347,10 @@ void ai_big_subsys_path_cleanup(ai_info *aip)
 }

 // Maybe Pl_objp needs to follow a path to get in line-of-sight to a subsystem
-// input:	do_dot_check	=>	default value true, flag to indicate whether check should be done to ensure
+// input:	do_dot_check	=>	default value 0, flag to indicate whether check should be done to ensure
 //										subsystem is within certain field of view.  We don't want to check fov when
 //										strafing, since ship is weaving to avoid turret fire
-bool ai_big_maybe_follow_subsys_path(bool do_dot_check)
+int ai_big_maybe_follow_subsys_path(int do_dot_check)
 {
 	ai_info	*aip;
 	float		dot = 1.0f, min_dot;
@@ -509,7 +498,7 @@ bool ai_big_maybe_follow_subsys_path(bool do_dot_check)
 					// for now, only follow the path to the first point
 					if ( aip->path_cur < (aip->path_start+aip->path_length-1) ) {
 						if ( aip->goal_objnum != aip->target_objnum ) {
-							ai_big_save_previous_mode(aip);
+							aip->previous_mode = aip->mode;
 							aip->mode = AIM_NONE;
 							aip->submode = -1;
 							aip->submode_start_time = Missiontime;
@@ -716,8 +705,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 						if (vm_vec_dot(&in_vec, &objp->orient.vec.fvec) > 0.0f) {
 							dist = vm_vec_normalize(&in_vec);
 							if ((dist < 200.0f) && (vm_vec_dot(&in_vec, &objp->orient.vec.fvec) > 0.95f)) {
-								if ((Objects[objp->parent].signature == objp->parent_sig) && (vm_vec_dist_quick(&objp->pos, &Objects[objp->parent].pos) < 300.0f)
-									&& !ai_declines_pursuit(Pl_objp, &Objects[objp->parent])) {
+								if ((Objects[objp->parent].signature == objp->parent_sig) && (vm_vec_dist_quick(&objp->pos, &Objects[objp->parent].pos) < 300.0f)) {
 									set_target_objnum(aip, objp->parent);
 									aip->submode = SM_ATTACK;
 									aip->submode_start_time = Missiontime;
@@ -738,7 +726,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 		// including ai_profile flag and if enemy fighters are near
 		if (Pl_objp->phys_info.speed < The_mission.ai_profile->standard_strafe_when_below_speed && 
 			(The_mission.ai_profile->flags[AI::Profile_Flags::Standard_strafe_used_more] || ai_big_maybe_start_strafe(aip, sip))) {
-			ai_big_save_previous_mode(aip);
+			aip->previous_mode = aip->mode;
 			aip->mode = AIM_STRAFE;
 			aip->submode_parm0 = Missiontime;	// use parm0 as time strafe mode entered (i.e. MODE start time)
 			ai_big_strafe_position();
@@ -747,7 +735,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d

 		//Maybe enter glide strafe (check every 8 seconds, on a different schedule for each ship)
 		if ((sip->can_glide == true) && !(aip->ai_flags[AI::AI_Flags::Kamikaze]) && static_randf((Missiontime + static_rand(aip->shipnum)) >> 19) < aip->ai_glide_strafe_percent) {
-			ai_big_save_previous_mode(aip);
+			aip->previous_mode = aip->mode;
 			aip->mode = AIM_STRAFE;
 			aip->submode_parm0 = Missiontime;	// use parm0 as time strafe mode entered (i.e. MODE start time)
 			aip->submode = AIS_STRAFE_GLIDE_ATTACK;
@@ -876,7 +864,7 @@ void ai_big_chase_ct()
 extern bool ai_select_secondary_weapon(object *objp, ship_weapon *swp, int priority1 = -1, int priority2 = -1);
 extern float set_secondary_fire_delay(ai_info *aip, ship *shipp, weapon_info *swip, bool burst);
 extern bool ai_choose_secondary_weapon(object *objp, ai_info *aip, object *en_objp);
-extern bool maybe_avoid_big_ship(object *objp, object *ignore_objp, ai_info *aip, vec3d *goal_point, float delta_time, float time_scale = 1.f);
+extern int maybe_avoid_big_ship(object *objp, object *ignore_objp, ai_info *aip, vec3d *goal_point, float delta_time, float time_scale = 1.f);

 extern void maybe_cheat_fire_synaptic(object *objp);

@@ -1019,7 +1007,7 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 // switch ai ship into chase mode
 void ai_big_switch_to_chase_mode(ai_info *aip)
 {
-	ai_big_save_previous_mode(aip);
+	aip->previous_mode = aip->mode;
 	aip->mode = AIM_CHASE;
 	aip->submode = SM_ATTACK;
 	aip->submode_start_time = Missiontime;
@@ -1119,7 +1107,7 @@ void ai_big_chase()
 	} else if (En_objp->flags[Object::Object_Flags::Protected]) {	//	If protected and we're not attacking a subsystem, stop attacking!
 		update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy - En_objp->radius, En_objp->radius);
 		aip->target_objnum = -1;
-		if (find_enemy(OBJ_INDEX(Pl_objp), MAX_ENEMY_DISTANCE, The_mission.ai_profile->max_attackers[Game_skill_level], ai_targets_for_pursuit(aip)) == -1) {
+		if (find_enemy(OBJ_INDEX(Pl_objp), MAX_ENEMY_DISTANCE, The_mission.ai_profile->max_attackers[Game_skill_level]) == -1) {
 			ai_do_default_behavior(Pl_objp);
 			return;
 		}
@@ -1206,78 +1194,70 @@ void ai_big_chase()
 		}

 		//	If a collision is expected, pull out!
-		if (!(The_mission.ai_profile->flags[AI::Profile_Flags::Kamikaze_no_collision_avoidance] && aip->ai_flags[AI::AI_Flags::Kamikaze])) {
+		float dist_normal_to_enemy;

-			float dist_normal_to_enemy;
-
-			if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
-				if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing])
-					dist_normal_to_enemy = fl_abs((dist_to_enemy / vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
-				else // I'm fairly sure this retail code VVV meant to use / instead of * 
-					dist_normal_to_enemy = fl_abs((dist_to_enemy * vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
-			}
-			else {
-				// don;t have normal so use a conservative value here
-				dist_normal_to_enemy = 0.3f * dist_to_enemy;
-			}
-
-			//		float time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed * fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
-			//		if (Framecount % 30 == 1) {
-			//			mprintf(("normal dist; %.1f, time: %.1f\n", dist_normal_to_enemy, time_to_enemy));
-			//		}
-
-					// since we're not in strafe and we may get a bad normal, cap dist_normal_to_enemy as MIN(0.3*dist_to_enemy, self)
-					// this will allow us to get closer on a bad normal
-			dist_normal_to_enemy = MAX(0.3f * dist_to_enemy, dist_normal_to_enemy);
-
-			if (dist_to_enemy < ATTACK_COLLIDE_BASE_DIST) {
-				// within 50m or 1sec
-				float time_to_enemy;
-				if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
-					if (Pl_objp->phys_info.speed > 0.1) {
-						time_to_enemy = dist_normal_to_enemy / fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
-					}
-					else {
-						// a big time
-						time_to_enemy = 100.0f;
-					}
-				}
-				else {
-					if (Pl_objp->phys_info.speed > 0.1) {
-						time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed;
-					}
-					else {
-						// a big time
-						time_to_enemy = 100.0f;
-					}
-				}
-
-				float speed_dist = MAX(0.0f, (Pl_objp->phys_info.speed - 50) * 2);
-				if ((dist_normal_to_enemy < ATTACK_COLLIDE_AVOID_DIST + speed_dist) || (time_to_enemy < ATTACK_COLLIDE_AVOID_TIME)) {
-					// get away, simulate crsh recovery (don't use avoid)
-	//				accelerate_ship(aip, -1.0f);
-					big_ship_collide_recover_start(Pl_objp, En_objp, nullptr);
-					//				aip->submode = SM_AVOID;
-					//				aip->submode_start_time = Missiontime;
-				}
-				else if ((dist_normal_to_enemy < ATTACK_COLLIDE_SLOW_DIST) || (time_to_enemy < ATTACK_COLLIDE_SLOW_TIME)) {
-					// slow down
-					accelerate_ship(aip, -1.0f);
-				}
-			}
-
-			/*
-			if ((dot_to_enemy > 1.0f - 0.1f * En_objp->radius/(dist_to_enemy + 1.0f)) && (Pl_objp->phys_info.speed > dist_to_enemy/5.0f)) {
-				if (might_collide_with_ship(Pl_objp, En_objp, dot_to_enemy, dist_to_enemy, (aip->targeted_subsys == NULL)*2.0f + 1.5f)) {
-					if ((Missiontime - aip->last_hit_time > F1_0*4) && (dist_to_enemy < Pl_objp->radius*2 + En_objp->radius*2)) {
-						accelerate_ship(aip, -1.0f);
-					} else {
-						aip->submode = SM_AVOID;
-						aip->submode_start_time = Missiontime;
-					}
-				}
-			} */
+		if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
+			if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing])
+				dist_normal_to_enemy = fl_abs((dist_to_enemy / vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
+			else // I'm fairly sure this retail code VVV meant to use / instead of * 
+				dist_normal_to_enemy = fl_abs((dist_to_enemy * vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
+		} else {
+			// don;t have normal so use a conservative value here
+			dist_normal_to_enemy = 0.3f * dist_to_enemy;
 		}
+
+//		float time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed * fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
+//		if (Framecount % 30 == 1) {
+//			mprintf(("normal dist; %.1f, time: %.1f\n", dist_normal_to_enemy, time_to_enemy));
+//		}
+		
+		// since we're not in strafe and we may get a bad normal, cap dist_normal_to_enemy as MIN(0.3*dist_to_enemy, self)
+		// this will allow us to get closer on a bad normal
+		dist_normal_to_enemy = MAX(0.3f*dist_to_enemy, dist_normal_to_enemy);
+
+		if (dist_to_enemy < ATTACK_COLLIDE_BASE_DIST) {
+			// within 50m or 1sec
+			float time_to_enemy;
+			if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
+				if (Pl_objp->phys_info.speed > 0.1) {
+					time_to_enemy = dist_normal_to_enemy / fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
+				} else {
+					// a big time
+					time_to_enemy = 100.0f;
+				}
+			} else {
+				if (Pl_objp->phys_info.speed > 0.1) {
+					time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed;
+				} else {
+					// a big time
+					time_to_enemy = 100.0f;
+				}
+			}
+
+			float speed_dist = MAX(0.0f, (Pl_objp->phys_info.speed-50) * 2);
+			if ((dist_normal_to_enemy < ATTACK_COLLIDE_AVOID_DIST + speed_dist) || (time_to_enemy < ATTACK_COLLIDE_AVOID_TIME) ) {
+				// get away, simulate crsh recovery (don't use avoid)
+//				accelerate_ship(aip, -1.0f);
+				big_ship_collide_recover_start(Pl_objp, En_objp, nullptr);
+//				aip->submode = SM_AVOID;
+//				aip->submode_start_time = Missiontime;
+			} else if ((dist_normal_to_enemy < ATTACK_COLLIDE_SLOW_DIST) || (time_to_enemy < ATTACK_COLLIDE_SLOW_TIME) ) {
+				// slow down
+				accelerate_ship(aip, -1.0f);
+			}
+		}
+
+		/*
+		if ((dot_to_enemy > 1.0f - 0.1f * En_objp->radius/(dist_to_enemy + 1.0f)) && (Pl_objp->phys_info.speed > dist_to_enemy/5.0f)) {
+			if (might_collide_with_ship(Pl_objp, En_objp, dot_to_enemy, dist_to_enemy, (aip->targeted_subsys == NULL)*2.0f + 1.5f)) {
+				if ((Missiontime - aip->last_hit_time > F1_0*4) && (dist_to_enemy < Pl_objp->radius*2 + En_objp->radius*2)) {
+					accelerate_ship(aip, -1.0f);
+				} else {
+					aip->submode = SM_AVOID;
+					aip->submode_start_time = Missiontime;
+				}
+			}
+		} */
 	}

 	switch (aip->submode) {
@@ -1436,7 +1416,7 @@ void ai_big_attack_get_data(vec3d *enemy_pos, float *dist_to_enemy, float *dot_t

 // check to see if Pl_objp has gotten too close to attacking point.. if so, break off by entering
 // AIS_STRAFE_RETREAT
-static bool ai_big_strafe_maybe_retreat(const vec3d *target_pos)
+static int ai_big_strafe_maybe_retreat(const vec3d *target_pos)
 {
 	ai_info	*aip;
 	aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
@@ -1444,42 +1424,25 @@ static bool ai_big_strafe_maybe_retreat(const vec3d *target_pos)
 	vec3d vec_to_target;
 	vm_vec_sub(&vec_to_target, target_pos, &Pl_objp->pos);

-	float dist_to_target = vm_vec_mag(&vec_to_target);
+	float dist_to_target, dist_normal_to_target, time_to_target;
+	dist_to_target = vm_vec_mag_quick(&vec_to_target);
+	if (vm_vec_mag_quick(&aip->big_attack_surface_normal) > 0.9) {
+		dist_normal_to_target = -vm_vec_dot(&vec_to_target, &aip->big_attack_surface_normal);
+	} else {
+		dist_normal_to_target = 0.2f * vm_vec_mag_quick(&vec_to_target);
+	}
+
+	dist_normal_to_target = MAX(0.2f*dist_to_target, dist_normal_to_target);
+	time_to_target = dist_normal_to_target / Pl_objp->phys_info.speed;

 	// add distance penalty for going too fast
 	float speed_to_dist_penalty = MAX(0.0f, (Pl_objp->phys_info.speed-50));

-	bool collide_time;
-	bool collide_distance;
-	if (The_mission.ai_profile->flags[AI::Profile_Flags::Fix_standard_strafe]) {
-		// check if ship facing target, as likely will only collide if facing
-		vec3d vec_to_tpos;
-		vm_vec_normalized_dir(&vec_to_tpos, target_pos, &Pl_objp->pos);
-		float dot = vm_vec_dot(&vec_to_tpos, &Pl_objp->orient.vec.fvec);
-		if (dot <= 0.0f) {
-			collide_time = false;
-			collide_distance = false;
-		} else {
-			collide_time = (Pl_objp->phys_info.speed > 0.0f) && (dist_to_target / Pl_objp->phys_info.speed) < (The_mission.ai_profile->strafe_retreat_collide_time);
-			collide_distance = dist_to_target < ((The_mission.ai_profile->strafe_retreat_collide_distance) + speed_to_dist_penalty);
-		}
-	} else {
-		float dist_normal_to_target;
-		if (vm_vec_mag(&aip->big_attack_surface_normal) > 0.9) {
-			dist_normal_to_target =
-				MAX(0.2f * dist_to_target, -vm_vec_dot(&vec_to_target, &aip->big_attack_surface_normal));
-		} else {
-			dist_normal_to_target = 0.2f * dist_to_target;
-		}
-		collide_time = (Pl_objp->phys_info.speed > 0.0f) && (dist_normal_to_target / Pl_objp->phys_info.speed) < (The_mission.ai_profile->strafe_retreat_collide_time);
-		collide_distance = dist_normal_to_target < ((The_mission.ai_profile->strafe_retreat_collide_distance) + speed_to_dist_penalty);
-	}
-
 	//if ((dot_to_enemy > 1.0f - 0.1f * En_objp->radius/(dist_to_enemy + 1.0f)) && (Pl_objp->phys_info.speed > dist_to_enemy/5.0f))

 	// Inside 2 sec retreat, setting goal point to box point + strafe_retreat_box_dist
 	// If collision, use std collision resolution.
-	if ( !(aip->ai_flags[AI::AI_Flags::Kamikaze]) && ((aip->ai_flags[AI::AI_Flags::Target_collision]) || (collide_time) || (collide_distance)) ) {
+	if ( !(aip->ai_flags[AI::AI_Flags::Kamikaze]) && ((aip->ai_flags[AI::AI_Flags::Target_collision]) || (time_to_target < STRAFE_RETREAT_COLLIDE_TIME) || (dist_normal_to_target < STRAFE_RETREAT_COLLIDE_DIST + speed_to_dist_penalty)) ) {
 		if (aip->ai_flags[AI::AI_Flags::Target_collision]) {
 			// use standard collision resolution
 			aip->ai_flags.remove(AI::AI_Flags::Target_collision);
@@ -1523,7 +1486,7 @@ void ai_big_strafe_attack()
 	if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing]) {
 		if (ai_new_maybe_reposition_attack_subsys())
 			return;
-	} else if (ai_big_maybe_follow_subsys_path(false))
+	} else if (ai_big_maybe_follow_subsys_path(0))
 		return;

 	ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);
@@ -1643,7 +1606,7 @@ void ai_big_strafe_glide_attack()
 	if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing]) {
 		if (ai_new_maybe_reposition_attack_subsys())
 			return;
-	} else if (ai_big_maybe_follow_subsys_path(false))
+	} else if (ai_big_maybe_follow_subsys_path(0))
 		return;

 	//Gets a point on the target ship to attack, as well as distance and the angle between the nose of the attacker and that point.
@@ -1878,7 +1841,7 @@ void ai_big_strafe()

 /*
 	if ( aip->goal_objnum != aip->target_objnum ) {
-		Assertion(false, "The goal objnum does not match the target objnum in ai_big_strafe(), please report to the SCP!");	// what is going on here? - Get Alan
+		UNREACHABLE("The goal objnum does not match the target objnum in ai_big_strafe(), please report to the SCP!");	// what is going on here? - Get Alan
 		aip->mode = AIM_NONE;
 		return;
 	}
@@ -1979,25 +1942,26 @@ int ai_big_maybe_enter_strafe_mode(const object *pl_objp, int weapon_objnum)
 		return 0;
 	}

-	if (ai_declines_pursuit(pl_objp, parent_objp)) {
-		return 0;
-	}
-
 	// Maybe the ship which fired the weapon isn't the current target
 	if ( OBJ_INDEX(parent_objp) != aip->target_objnum ) {
+
+//JAS IMPOSSIBLE		if (1) { // consider_target_only ) {
+//JAS IMPOSSIBLE			return 0;
+//JAS IMPOSSIBLE		} else {
 			// switch targets
 			sip = &Ship_info[Ships[parent_objp->instance].ship_info_index];
 			if ( !(sip->is_big_or_huge()) || (sip->flags[Ship::Info_Flags::Transport]) ) {
 				return 0;
 			}
 			set_target_objnum(aip, OBJ_INDEX(parent_objp));
+//JAS IMPOSSIBLE		}
 	}

 	ai_big_strafe_maybe_attack_turret(pl_objp, weapon_objp);

 	// if we've got this far, the weapon must have come from the player's target, and it is a 
 	// big/capital ship... so enter strafe mode
-	ai_big_save_previous_mode(aip);
+	aip->previous_mode = aip->mode;
 	aip->mode = AIM_STRAFE;
 	aip->submode_parm0 = Missiontime;	// use parm0 as time strafe mode entered (i.e. MODE start time)
 	aip->submode = AIS_STRAFE_AVOID;
@@ -40,43 +40,28 @@ struct ship_registry_entry;
 // dynamic goals are not handled here.

 // defines for player issued goal priorities
-constexpr int PLAYER_PRIORITY_MIN         =  90;
-constexpr int PLAYER_PRIORITY_SHIP        = 100;
-constexpr int PLAYER_PRIORITY_WING        =  95;
-constexpr int PLAYER_PRIORITY_SUPPORT_LOW =  10;
+#define PLAYER_PRIORITY_MIN				90
+#define PLAYER_PRIORITY_SHIP				100
+#define PLAYER_PRIORITY_WING				95
+#define PLAYER_PRIORITY_SUPPORT_LOW		10

-constexpr int MAX_GOAL_PRIORITY = 200;
-constexpr int MIN_GOAL_PRIORITY = 1;
-
-
-// note: "purging" is not the same as "clearing" here
-// purging: any goal that no longer makes sense (i.e. is "invalid") in light of a new goal is removed
-// clearing: every goal is removed, including, ironically, the goal that caused the clearing
+#define MAX_GOAL_PRIORITY				200

+// define for which goals cause other goals to get purged
 // Goober5000 - okay, this seems really stupid.  If any ship in the mission is assigned a goal
 // in PURGE_GOALS_ALL_SHIPS, *every* other ship will have certain goals purged.  So I added
 // PURGE_GOALS_ONE_SHIP for goals which should only purge other goals in the one ship.
 // Goober5000 - note that the new disable and disarm goals (AI_GOAL_DISABLE_SHIP_TACTICAL and
 // AI_GOAL_DISARM_SHIP_TACTICAL) do not purge ANY goals, not even the ones in the one ship
-[[nodiscard]] bool causes_invalid_goal_purge_all_ships(ai_goal_mode ai_mode)
+inline bool purge_goals_all_ships(ai_goal_mode ai_mode)
 {
 	return ai_mode == AI_GOAL_IGNORE || ai_mode == AI_GOAL_DISABLE_SHIP || ai_mode == AI_GOAL_DISARM_SHIP;
 }
-[[nodiscard]] bool causes_invalid_goal_purge_one_ship(ai_goal_mode ai_mode)
+inline bool purge_goals_one_ship(ai_goal_mode ai_mode)
 {
 	return ai_mode == AI_GOAL_IGNORE_NEW;
 }

-// function for which goals cause other goals to be cleared -- see comments above on purging vs clearing
-// NOTE: this function is only evaluated in ai_add_goal_sub_player() and ai_add_goal_sub_scripting(); for
-// ai_add_goal_sub_sexp(), the goal clearing is integrated into the logic of the relevant sexp operators
-[[nodiscard]] bool causes_goal_clearing(ai_goal_mode ai_mode)
-{
-	return ((ai_mode == AI_GOAL_STAY_STILL && !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_clear_goals_when_running_stay_still])
-	     || (ai_mode == AI_GOAL_FORM_ON_WING && !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_clear_goals_when_running_form_on_wing])
-	     || (ai_mode == AI_GOAL_PLAY_DEAD));
-}
-
 // goals given from the player to other ships in the game are also handled in this
 // code

@@ -115,7 +100,6 @@ ai_goal_list Ai_goal_names[] =
 	{ "Attack weapon",			AI_GOAL_CHASE_WEAPON,			0 },
 	{ "Fly to ship",			AI_GOAL_FLY_TO_SHIP,			0 },
 	{ "Attack ship class",		AI_GOAL_CHASE_SHIP_CLASS,		0 },
-	{ "Attack ship type",		AI_GOAL_CHASE_SHIP_TYPE,		0 },
 };

 int Num_ai_goals = sizeof(Ai_goal_names) / sizeof(ai_goal_list);
@@ -130,7 +114,6 @@ const char *Ai_goal_text(ai_goal_mode goal, int submode)
 	case AI_GOAL_CHASE:
 	case AI_GOAL_CHASE_WING:
 	case AI_GOAL_CHASE_SHIP_CLASS:
-	case AI_GOAL_CHASE_SHIP_TYPE:
 		return XSTR( "attack ", 474);
 	case AI_GOAL_DOCK:
 		return XSTR( "dock ", 475);
@@ -212,15 +195,12 @@ void ai_maybe_add_form_goal(wing* wingp)
 		return;
 	}

-	// we may simply not want the mission to do this
-	if (The_mission.ai_profile->flags[AI::Profile_Flags::Dont_form_on_wing_at_mission_start]) {
-		return;
-	}
+	int j;

 	// iterate through the ship_index list of this wing and check for orders.  We will do
 	// this for all ships in the wing instead of on a wing only basis in case some ships
 	// in the wing actually have different orders than others
-	for (int j = 0; j < wingp->current_count; j++) {
+	for (j = 0; j < wingp->current_count; j++) {
 		ai_info* aip;

 		Assert(wingp->ship_index[j] != -1);						// get Allender
@@ -232,8 +212,7 @@ void ai_maybe_add_form_goal(wing* wingp)
 		}

 		// need to add a form on my wing goal here.  Ships are always forming on the player's wing.
-		// it is sufficient enough to check the first goal entry to see if it has a valid goal.
-		// Note: Although the player didn't explicitly order this, it is treated as a player-issued order
+		// it is sufficient enough to check the first goal entry to see if it has a valid goal
 		if (aip->goals[0].ai_mode == AI_GOAL_NONE) {
 			// Need to have a more specific target in multi, or they may end up trying to target standalone placeholder.
 			// So form on their team leader.  In dogfight, all player-slot ai die, so just exclude.
@@ -534,25 +513,13 @@ void ai_goal_purge_invalid_goals( ai_goal *aigp, ai_goal *goal_list, ai_info *ai
 		if ( purge_goal->target_name == NULL )
 			continue;

-		// goals operating on ship classes and ship types are handled slightly differently
+		// goals operating on ship classes are handled slightly differently
 		if ( purge_ai_mode == AI_GOAL_CHASE_SHIP_CLASS ) {
 			// if the target of the purge goal is the same class of ship we are concerned about, then we have a match;
 			// if it is not, then we can continue (see standard ship check below)
 			if ( stricmp(purge_goal->target_name, Ship_info[Ships[ship_index].ship_info_index].name) != 0 )
 				continue;
 		}
-		else if (purge_ai_mode == AI_GOAL_CHASE_SHIP_TYPE) {
-			// Get the ship type of the ship we're concerned about
-			int ship_type = Ship_info[Ships[ship_index].ship_info_index].class_type;
-
-			// If the ship type is invalid, we can't match it, so continue
-			if (ship_type < 0)
-				continue;
-
-			// Check if the target name of the purge goal matches the ship type name
-			if (stricmp(purge_goal->target_name, Ship_types[ship_type].name) != 0)
-				continue;
-		}
 		// standard goals operating on either wings or ships
 		else {
 			// determine if the purge goal is acting either on the ship or the ship's wing.
@@ -621,8 +588,8 @@ void ai_goal_purge_all_invalid_goals(ai_goal *aigp)
 	int i;
 	ship_obj *sop;

-	// only purge goals if a new goal is one of the types that require purging
-	if (!causes_invalid_goal_purge_all_ships(aigp->ai_mode))
+	// only purge goals if a new goal is one of the types in next statement
+	if (!purge_goals_all_ships(aigp->ai_mode))
 		return;
 	
 	for (sop = GET_FIRST(&Ship_obj_list); sop != END_OF_LIST(&Ship_obj_list); sop = GET_NEXT(sop))
@@ -765,14 +732,12 @@ void ai_goal_fixup_dockpoints(ai_info *aip, ai_goal *aigp)
 // from the mission goals (i.e. those goals which come from events) in that we don't
 // use sexpressions for goals from the player...so we enumerate all the parameters

-void ai_add_goal_sub_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *target_name, ai_goal *aigp, int int_data, float float_data, const ai_lua_parameters& lua_target )
+void ai_add_goal_sub_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *target_name, ai_goal *aigp, const ai_lua_parameters& lua_target )
 {
 	Assert ( (type == ai_goal_type::PLAYER_WING) || (type == ai_goal_type::PLAYER_SHIP) );

 	ai_goal_reset(aigp, true, mode, submode, type);

-	aigp->int_data = int_data;
-	aigp->float_data = float_data;
 	aigp->lua_ai_target = lua_target;

 	if ( mode == AI_GOAL_WARP ) {
@@ -790,18 +755,6 @@ void ai_add_goal_sub_player(ai_goal_type type, ai_goal_mode mode, int submode, c
 	if ( target_name != NULL )
 		aigp->target_name = ai_get_goal_target_name( target_name, &aigp->target_name_index );

-	// set up the clear-goals flag for certain goals
-	if (causes_goal_clearing(mode))
-		aigp->flags.set(AI::Goal_Flags::Clear_all_goals_first);
-
-	// also set up the override, since it's no longer done automatically in ai_mission_goal_achievable
-	if (mode == AI_GOAL_FORM_ON_WING && !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_set_override_when_assigning_form_on_wing])
-		aigp->flags.set(AI::Goal_Flags::Want_override);
-
-	// generally, players want ships to form-on-wing only until they need to do something else
-	if (mode == AI_GOAL_FORM_ON_WING && The_mission.ai_profile->flags[AI::Profile_Flags::Purge_player_issued_form_on_wing_after_subsequent_order])
-		aigp->flags.set(AI::Goal_Flags::Purge_when_new_goal_added);
-
 	if (The_mission.ai_profile->flags[AI::Profile_Flags::Player_orders_afterburn_hard])
 		aigp->flags.set(AI::Goal_Flags::Afterburn_hard);

@@ -813,6 +766,10 @@ void ai_add_goal_sub_player(ai_goal_type type, ai_goal_mode mode, int submode, c
 	if ( (mode == AI_GOAL_STAY_NEAR_SHIP) || (mode == AI_GOAL_KEEP_SAFE_DISTANCE) )
 		aigp->priority = PLAYER_PRIORITY_SUPPORT_LOW;

+	// Goober5000 - same with form-on-wing, since it's a type of staying near
+	else if ( mode == AI_GOAL_FORM_ON_WING )
+		aigp->priority = PLAYER_PRIORITY_SUPPORT_LOW;
+
 	else if ( aigp->type == ai_goal_type::PLAYER_WING )	// NOLINT(readability-braces-around-statements)
 		aigp->priority = PLAYER_PRIORITY_WING;			// player wing goals not as high as ship goals
 	else
@@ -825,25 +782,19 @@ void ai_add_goal_sub_player(ai_goal_type type, ai_goal_mode mode, int submode, c
 // friendlies want to rearm at the same time.  The support ship forgets what it's doing and flies
 // off to repair somebody while still docked.  I reproduced this with retail, so it's not a bug in
 // my new docking code. :)
-// Note that this function is now where Purge_when_new_goal_added is checked to set the Purge flag.
-int ai_goal_allocate_slot( ai_goal *goals, int active_goal )
+int ai_goal_find_empty_slot( ai_goal *goals, int active_goal )
 {
-	int oldest_index = -1, first_empty_index = -1;
+	int gindex, oldest_index;

-	for ( int gindex = 0; gindex < MAX_AI_GOALS; gindex++ )
+	oldest_index = -1;
+	for ( gindex = 0; gindex < MAX_AI_GOALS; gindex++ )
 	{
 		// get the index for the first unused goal
 		if (goals[gindex].ai_mode == AI_GOAL_NONE)
-		{
-			if (first_empty_index < 0)
-				first_empty_index = gindex;
-		}
-		// if any goal needs to be purged when we add a goal, set the flag
-		else if (goals[gindex].flags[AI::Goal_Flags::Purge_when_new_goal_added])
-			goals[gindex].flags.set(AI::Goal_Flags::Purge);
+			return gindex;

-		// if this is the active goal, and a real goal, don't consider it for pre-emption!!
-		if (gindex == active_goal && goals[gindex].ai_mode != AI_GOAL_NONE)
+		// if this is the active goal, don't consider it for pre-emption!!
+		if (gindex == active_goal)
 			continue;

 		// store the index of the oldest goal
@@ -853,10 +804,6 @@ int ai_goal_allocate_slot( ai_goal *goals, int active_goal )
 			oldest_index = gindex;
 	}

-	// try to use the first empty slot
-	if (first_empty_index >= 0)
-		return first_empty_index;
-
 	// if we didn't find an empty slot, use the oldest goal's slot
 	return oldest_index;
 }
@@ -889,51 +836,17 @@ void ai_add_goal_sub_scripting(ai_goal_type type, ai_goal_mode mode, int submode
 	if ( target_name != NULL )
 		aigp->target_name = ai_get_goal_target_name( target_name, &aigp->target_name_index );

-	// set up the clear-goals flag for certain goals
-	if (causes_goal_clearing(mode))
-		aigp->flags.set(AI::Goal_Flags::Clear_all_goals_first);
-
-	// also set up the override, since it's no longer done automatically in ai_mission_goal_achievable
-	if (mode == AI_GOAL_FORM_ON_WING && !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_set_override_when_assigning_form_on_wing])
-		aigp->flags.set(AI::Goal_Flags::Want_override);
-
 	aigp->priority = priority;
 	aigp->int_data = int_data;
 	aigp->float_data = float_data;
-
-	// range check
-	if ( aigp->priority > MAX_GOAL_PRIORITY ) {
-		nprintf (("AI", "bashing scripting priority of goal %d from %d to %d.\n", mode, aigp->priority, MAX_GOAL_PRIORITY));
-		aigp->priority = MAX_GOAL_PRIORITY;
-	} else if ( aigp->priority < MIN_GOAL_PRIORITY ) {
-		nprintf (("AI", "bashing scripting priority of goal %d from %d to %d.\n", mode, aigp->priority, MIN_GOAL_PRIORITY));
-		aigp->priority = MIN_GOAL_PRIORITY;
-	}
 }

-// find a dockpoint on the given ship that is compatible with the specified dock-type flags (c.f. ai_goal_fixup_dockpoints)
-static int ai_goal_find_compatible_dockpoint(int shipnum, int type_flags)
-{
-	for (int i = 0; i < Num_dock_type_names; i++)
-	{
-		if (type_flags & Dock_type_names[i].def)
-		{
-			int dock_index = ai_goal_find_dockpoint(shipnum, Dock_type_names[i].def);
-			if (dock_index >= 0)
-				return dock_index;
-		}
-	}
-
-	// no compatible type-specific point found; fall back to a generic one
-	return ai_goal_find_dockpoint(shipnum, DOCK_TYPE_GENERIC);
-}
-
-void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, const char *shipname, ai_info *aip, int int_data, float float_data, int docker_index, int dockee_index)
+void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, const char *shipname, ai_info *aip, int int_data, float float_data)
 {
 	int empty_index;
 	ai_goal *aigp;

-	empty_index = ai_goal_allocate_slot(aip->goals, aip->active_goal);
+	empty_index = ai_goal_find_empty_slot(aip->goals, aip->active_goal);
 	aigp = &aip->goals[empty_index];
 	ai_add_goal_sub_scripting(ai_goal_type::PLAYER_SHIP, mode, submode, priority, shipname, aigp, int_data, float_data);

@@ -944,27 +857,7 @@ void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, co
 	}

 	if ( (mode == AI_GOAL_REARM_REPAIR) || (mode == AI_GOAL_DOCK) ) {
-		// if the caller specified one or both dockpoints, honor them and choose the other side to match
-		if ( mode == AI_GOAL_DOCK && (docker_index >= 0 || dockee_index >= 0) ) {
-			int dockee_shipnum = ship_name_lookup(shipname);
-			Assertion(dockee_shipnum >= 0, "Couldn't find dock target '%s'; get a coder!", shipname);
-
-			// if only one point was given, choose the other to match its dock type
-			if ( docker_index < 0 ) {
-				polymodel *dockee_pm = model_get(Ship_info[Ships[dockee_shipnum].ship_info_index].model_num);
-				docker_index = ai_goal_find_compatible_dockpoint(aip->shipnum, dockee_pm->docking_bays[dockee_index].type_flags);
-			} else if ( dockee_index < 0 ) {
-				polymodel *docker_pm = model_get(Ship_info[Ships[aip->shipnum].ship_info_index].model_num);
-				dockee_index = ai_goal_find_compatible_dockpoint(dockee_shipnum, docker_pm->docking_bays[docker_index].type_flags);
-			}
-
-			aigp->docker.index = docker_index;
-			aigp->dockee.index = dockee_index;
-			aigp->flags.set(AI::Goal_Flags::Docker_index_valid);
-			aigp->flags.set(AI::Goal_Flags::Dockee_index_valid);
-		} else {
-			ai_goal_fixup_dockpoints( aip, aigp );
-		}
+		ai_goal_fixup_dockpoints( aip, aigp );
 	}
 }

@@ -972,14 +865,14 @@ void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, co
 // is issued to ship or wing (from player),  mode is AI_GOAL_*. submode is the submode the
 // ship should go into.  shipname is the object of the action.  aip is the ai_info pointer
 // of the ship receiving the order
-void ai_add_ship_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *shipname, ai_info *aip, int int_data, float float_data, const ai_lua_parameters& lua_target)
+void ai_add_ship_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *shipname, ai_info *aip, const ai_lua_parameters& lua_target)
 {
 	int empty_index;
 	ai_goal *aigp;

-	empty_index = ai_goal_allocate_slot( aip->goals, aip->active_goal );
+	empty_index = ai_goal_find_empty_slot( aip->goals, aip->active_goal );
 	aigp = &aip->goals[empty_index];
-	ai_add_goal_sub_player( type, mode, submode, shipname, aigp, int_data, float_data, lua_target );
+	ai_add_goal_sub_player( type, mode, submode, shipname, aigp, lua_target );

 	// if the goal is to dock, then we must determine which dock points on the two ships to use.
 	// If the target of the dock is a cargo type container, then we should use DOCK_TYPE_CARGO
@@ -993,7 +886,7 @@ void ai_add_ship_goal_player(ai_goal_type type, ai_goal_mode mode, int submode,

 // adds a goal from the player to the given wing (which in turn will add it to the proper
 // ships in the wing
-void ai_add_wing_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *shipname, int wingnum, int int_data, float float_data, const ai_lua_parameters& lua_target)
+void ai_add_wing_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char *shipname, int wingnum, const ai_lua_parameters& lua_target)
 {
 	int i, empty_index;
 	wing *wingp = &Wings[wingnum];
@@ -1004,15 +897,15 @@ void ai_add_wing_goal_player(ai_goal_type type, ai_goal_mode mode, int submode,
 			int num = wingp->ship_index[i];
 			if ( num == -1 )			// ship must have been destroyed or departed
 				continue;
-			ai_add_ship_goal_player( type, mode, submode, shipname, &Ai_info[Ships[num].ai_index], int_data, float_data, lua_target );
+			ai_add_ship_goal_player( type, mode, submode, shipname, &Ai_info[Ships[num].ai_index], lua_target );
 		}
 	}

 	// add the sexpression index into the wing's list of goal sexpressions if
 	// there are more waves to come.  We use the same method here as when adding a goal to
 	// a ship -- find the first empty entry.  If none exists, take the oldest entry and replace it.
-	empty_index = ai_goal_allocate_slot( wingp->ai_goals, -1 );
-	ai_add_goal_sub_player( type, mode, submode, shipname, &wingp->ai_goals[empty_index], int_data, float_data, lua_target );
+	empty_index = ai_goal_find_empty_slot( wingp->ai_goals, -1 );
+	ai_add_goal_sub_player( type, mode, submode, shipname, &wingp->ai_goals[empty_index], lua_target );
 }


@@ -1045,9 +938,11 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 		// for achievability.
 		aigp->target_name = ai_get_goal_target_name(CTEXT(CDR(node)), &aigp->target_name_index);  // waypoint path name;

-		aigp->priority = eval_num(CDDR(node), priority_is_nan, priority_is_nan_forever);
-		aigp->ai_mode = (op == OP_AI_WAYPOINTS_ONCE) ? AI_GOAL_WAYPOINTS_ONCE : AI_GOAL_WAYPOINTS;

+		aigp->priority = eval_num(CDDR(node), priority_is_nan, priority_is_nan_forever);
+		aigp->ai_mode = AI_GOAL_WAYPOINTS;
+		if ( op == OP_AI_WAYPOINTS_ONCE )
+			aigp->ai_mode = AI_GOAL_WAYPOINTS_ONCE;
 		if (CDDDDR(node) < 0)
 			aigp->int_data = 0;	// handle optional node separately because we don't subtract 1 here
 		else
@@ -1126,27 +1021,10 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 	}

 	case OP_AI_STAY_STILL:
-	{
-		int n = CDR(node);
-
-		aigp->target_name = ai_get_goal_target_name(CTEXT(n), &aigp->target_name_index);  // waypoint path name;
-		n = CDR(n);
-
-		aigp->priority = eval_num(n, priority_is_nan, priority_is_nan_forever);
-		n = CDR(n);
-
-		bool clear_goals = !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_clear_goals_when_running_stay_still];
-		if (n >= 0)
-		{
-			clear_goals = is_sexp_true(n);
-			n = CDR(n);
-		}
-		if (clear_goals)
-			aigp->flags.set(AI::Goal_Flags::Clear_all_goals_first);
-
 		aigp->ai_mode = AI_GOAL_STAY_STILL;
+		aigp->target_name = ai_get_goal_target_name(CTEXT(CDR(node)), &aigp->target_name_index);  // waypoint path name;
+		aigp->priority = eval_num(CDDR(node), priority_is_nan, priority_is_nan_forever);
 		break;
-	}

 	case OP_AI_DOCK:
 		aigp->target_name = ai_get_goal_target_name( CTEXT(CDR(node)), &aigp->target_name_index );
@@ -1164,12 +1042,13 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 		break;

 	case OP_AI_PLAY_DEAD:
-		// we don't clear out ship goals for the "persistent" goal variant
-		aigp->flags.set(AI::Goal_Flags::Clear_all_goals_first);
-		FALLTHROUGH;
+		aigp->priority = eval_num(CDR(node), priority_is_nan, priority_is_nan_forever);
+		aigp->ai_mode = AI_GOAL_PLAY_DEAD;
+		break;
+
 	case OP_AI_PLAY_DEAD_PERSISTENT:
 		aigp->priority = eval_num(CDR(node), priority_is_nan, priority_is_nan_forever);
-		aigp->ai_mode = (op == OP_AI_PLAY_DEAD) ? AI_GOAL_PLAY_DEAD : AI_GOAL_PLAY_DEAD_PERSISTENT;
+		aigp->ai_mode = AI_GOAL_PLAY_DEAD_PERSISTENT;
 		break;

 	case OP_AI_KEEP_SAFE_DISTANCE:
@@ -1205,53 +1084,14 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 	}

 	case OP_AI_FORM_ON_WING:
-	{
-		int n = CDR(node);
-
-		aigp->target_name = ai_get_goal_target_name(CTEXT(n), &aigp->target_name_index);
-		n = CDR(n);
-
-		if (n >= 0)
-		{
-			aigp->priority = eval_num(n, priority_is_nan, priority_is_nan_forever);
-			n = CDR(n);
-		}
-		else
-			aigp->priority = The_mission.ai_profile->default_form_on_wing_priority;
-
-		bool clear_goals = !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_clear_goals_when_running_form_on_wing];
-		if (n >= 0)
-		{
-			clear_goals = is_sexp_true(n);
-			n = CDR(n);
-		}
-		if (clear_goals)
-			aigp->flags.set(AI::Goal_Flags::Clear_all_goals_first);
-
-		bool set_override = !The_mission.ai_profile->flags[AI::Profile_Flags::Do_not_set_override_when_assigning_form_on_wing];
-		if (n >= 0)
-		{
-			set_override = is_sexp_true(n);
-			n = CDR(n);
-		}
-		if (set_override)
-			aigp->flags.set(AI::Goal_Flags::Want_override);
-
-		if (n >= 0)
-		{
-			if (is_sexp_true(n))
-				aigp->flags.set(AI::Goal_Flags::Purge_when_new_goal_added);
-			n = CDR(n);
-		}
-
+		aigp->priority = 99;
+		aigp->target_name = ai_get_goal_target_name(CTEXT(CDR(node)), &aigp->target_name_index);
 		aigp->ai_mode = AI_GOAL_FORM_ON_WING;
 		break;
-	}

 	case OP_AI_CHASE:
 	case OP_AI_CHASE_WING:
 	case OP_AI_CHASE_SHIP_CLASS:
-	case OP_AI_CHASE_SHIP_TYPE:
 	case OP_AI_GUARD:
 	case OP_AI_GUARD_WING:
 	case OP_AI_EVADE_SHIP:
@@ -1283,14 +1123,12 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 			aigp->ai_mode = AI_GOAL_CHASE_WING;
 		} else if (op == OP_AI_CHASE_SHIP_CLASS) {
 			aigp->ai_mode = AI_GOAL_CHASE_SHIP_CLASS;
-		} else if (op == OP_AI_CHASE_SHIP_TYPE) {
-			aigp->ai_mode = AI_GOAL_CHASE_SHIP_TYPE;
 		} else if ( op == OP_AI_IGNORE ) {
 			aigp->ai_mode = AI_GOAL_IGNORE;
 		} else if ( op == OP_AI_IGNORE_NEW ) {
 			aigp->ai_mode = AI_GOAL_IGNORE_NEW;
 		} else
-			UNREACHABLE("Coding error: unhandled AI goal %d in ai_add_goal_sub_sexp!", op);
+			UNREACHABLE("Coding error: unhandled AI goal in ai_add_goal_sub_sexp!");

 		break;

@@ -1326,13 +1164,10 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 	} else if ( aigp->priority > MAX_GOAL_PRIORITY ) {
 		nprintf (("AI", "bashing add-goal sexpression priority of goal %s from %d to %d.\n", Sexp_nodes[CAR(sexp)].text, aigp->priority, MAX_GOAL_PRIORITY));
 		aigp->priority = MAX_GOAL_PRIORITY;
-	} else if ( aigp->priority < MIN_GOAL_PRIORITY ) {
-		nprintf (("AI", "bashing add-goal sexpression priority of goal %s from %d to %d.\n", Sexp_nodes[CAR(sexp)].text, aigp->priority, MIN_GOAL_PRIORITY));
-		aigp->priority = MIN_GOAL_PRIORITY;
 	}

 	// Goober5000 - we now have an extra optional chase argument to allow chasing our own team
-	if (op == OP_AI_CHASE || op == OP_AI_CHASE_WING || op == OP_AI_CHASE_SHIP_CLASS || op == OP_AI_CHASE_SHIP_TYPE
+	if ( op == OP_AI_CHASE || op == OP_AI_CHASE_WING || op == OP_AI_CHASE_SHIP_CLASS
 		|| op == OP_AI_DISABLE_SHIP || op == OP_AI_DISABLE_SHIP_TACTICAL || op == OP_AI_DISARM_SHIP || op == OP_AI_DISARM_SHIP_TACTICAL ) {
 		if (is_sexp_true(CDDDR(node)))
 			aigp->flags.set(AI::Goal_Flags::Target_own_team);
@@ -1357,7 +1192,6 @@ void ai_add_goal_sub_sexp( int sexp, ai_goal_type type, ai_info *aip, ai_goal *a
 	if (op == OP_AI_CHASE || 
 		op == OP_AI_CHASE_WING || 
 		op == OP_AI_CHASE_SHIP_CLASS || 
-		op == OP_AI_CHASE_SHIP_TYPE ||
 		op == OP_AI_DISABLE_SHIP || 
 		op == OP_AI_DISABLE_SHIP_TACTICAL || 
 		op == OP_AI_DISARM_SHIP || 
@@ -1441,11 +1275,6 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more )
 			nprintf(("AI", "bashing remove-goal sexpression priority of goal %s from %d to %d.\n", Sexp_nodes[CAR(sexp)].text, _priority, MAX_GOAL_PRIORITY));
 			_priority = MAX_GOAL_PRIORITY;
 		}
-		else if (_priority < MIN_GOAL_PRIORITY)
-		{
-			nprintf(("AI", "bashing remove-goal sexpression priority of goal %s from %d to %d.\n", Sexp_nodes[CAR(sexp)].text, _priority, MIN_GOAL_PRIORITY));
-			_priority = MIN_GOAL_PRIORITY;
-		}

 		if (n >= 0)
 		{
@@ -1466,9 +1295,12 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more )
 	/* We now need to determine what the mode and submode values are*/
 	switch( op )
 	{
-	case OP_AI_WAYPOINTS:
 	case OP_AI_WAYPOINTS_ONCE:
-		goalmode = (op == OP_AI_WAYPOINTS_ONCE) ? AI_GOAL_WAYPOINTS_ONCE : AI_GOAL_WAYPOINTS;
+		goalmode = AI_GOAL_WAYPOINTS_ONCE;
+		priority = eval_priority_et_seq(CDDR(node));
+		break;
+	case OP_AI_WAYPOINTS:
+		goalmode = AI_GOAL_WAYPOINTS;
 		priority = eval_priority_et_seq(CDDR(node));
 		break;
 	case OP_AI_DESTROY_SUBSYS:
@@ -1546,10 +1378,6 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more )
 		priority = eval_priority_et_seq(CDDR(node));
 		goalmode = AI_GOAL_CHASE_SHIP_CLASS;
 		break;
-	case OP_AI_CHASE_SHIP_TYPE:
-		priority = eval_priority_et_seq(CDDR(node));
-		goalmode = AI_GOAL_CHASE_SHIP_TYPE;
-		break;
 	case OP_AI_EVADE_SHIP:
 		priority = eval_priority_et_seq(CDDR(node));
 		goalmode = AI_GOAL_EVADE_SHIP;
@@ -1564,7 +1392,7 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more )
 		goalmode = (op == OP_AI_IGNORE) ? AI_GOAL_IGNORE : AI_GOAL_IGNORE_NEW;
 		break;
 	case OP_AI_FORM_ON_WING:
-		priority = eval_priority_et_seq(CDDR(node), The_mission.ai_profile->default_form_on_wing_priority);
+		priority = eval_priority_et_seq(-1, 99);
 		goalmode = AI_GOAL_FORM_ON_WING;
 		break;
 	case OP_AI_FLY_TO_SHIP:
@@ -1651,7 +1479,7 @@ void ai_add_ship_goal_sexp( int sexp, ai_goal_type type, ai_info *aip )
 {
 	int gindex;

-	gindex = ai_goal_allocate_slot( aip->goals, aip->active_goal );
+	gindex = ai_goal_find_empty_slot( aip->goals, aip->active_goal );
 	ai_add_goal_sub_sexp( sexp, type, aip, &aip->goals[gindex], Ships[aip->shipnum].ship_name );
 }

@@ -1675,7 +1503,7 @@ void ai_add_wing_goal_sexp(int sexp, ai_goal_type type, wing *wingp)
 	if ((wingp->num_waves - wingp->current_wave > 0) || Fred_running) {
 		int gindex;

-		gindex = ai_goal_allocate_slot( wingp->ai_goals, -1 );
+		gindex = ai_goal_find_empty_slot( wingp->ai_goals, -1 );
 		ai_add_goal_sub_sexp( sexp, type, nullptr, &wingp->ai_goals[gindex], wingp->name );
 	}
 }
@@ -1698,7 +1526,7 @@ void ai_add_goal_ship_internal( ai_info *aip, int goal_type, char *name, int  /*
 	Assertion(strcmp(name, Ships[aip->shipnum].ship_name) != 0, "The goals apply to the actor in ai_add_goal_ship_internal for ship %s, please report to the SCP!", name);

 	// find an empty slot to put this goal in.
-	gindex = ai_goal_allocate_slot( aip->goals, aip->active_goal );
+	gindex = ai_goal_find_empty_slot( aip->goals, aip->active_goal );
 	aigp = &(aip->goals[gindex]);
 	ai_goal_reset(aigp, true);

@@ -1803,20 +1631,6 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )

 	auto target_ship_entry = aigp->target_name == nullptr ? nullptr : ship_registry_get(aigp->target_name);

-	// a ship can't guard itself, and the leader of a wing is the ship the rest of the wing guards
-	if (The_mission.ai_profile->flags[AI::Profile_Flags::Fix_stale_ai_order_state])
-	{
-		if (aigp->ai_mode == AI_GOAL_GUARD && target_ship_entry && target_ship_entry->has_shipp() && target_ship_entry->shipp() == shipp)
-			return ai_achievability::NOT_ACHIEVABLE;
-
-		if (aigp->ai_mode == AI_GOAL_GUARD_WING)
-		{
-			int wingnum = wing_name_lookup(aigp->target_name);
-			if (wingnum >= 0 && Wings[wingnum].ship_index[0] == objp->instance)
-				return ai_achievability::NOT_ACHIEVABLE;
-		}
-	}
-
 	// warp (depart) only achievable if there's somewhere to depart to
 	if (aigp->ai_mode == AI_GOAL_WARP)
 	{
@@ -1841,7 +1655,7 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 		if (!target_ship_entry || !target_ship_entry->has_shipp())
 			return ai_achievability::NOT_ACHIEVABLE;

-		// the override flag is now set in the calling function, validate_mission_goals
+		aigp->flags.set(AI::Goal_Flags::Goal_override);
 		return ai_achievability::ACHIEVABLE;
 	}

@@ -1873,20 +1687,7 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 		}
 		return ai_achievability::NOT_KNOWN;
 	}
-	// and similarly for chasing all ships of a certain ship type
-	if (aigp->ai_mode == AI_GOAL_CHASE_SHIP_TYPE) {
-		for (auto so : list_range(&Ship_obj_list)) {
-			auto type_objp = &Objects[so->objnum];
-			if (type_objp->type != OBJ_SHIP || type_objp->flags[Object::Object_Flags::Should_be_dead])
-				continue;
-			int ship_info_idx = Ships[type_objp->instance].ship_info_index;
-			int class_type = Ship_info[ship_info_idx].class_type;
-			if (class_type >= 0 && !strcmp(aigp->target_name, Ship_types[class_type].name)) {
-				return ai_achievability::ACHIEVABLE;
-			}
-		}
-		return ai_achievability::NOT_KNOWN;
-	}
+

 	return_val = ai_achievability::SATISFIED;

@@ -2107,7 +1908,7 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 			if (target_ship_entry->shipp()->subsys_info[SUBSYSTEM_TURRET].type_count == 0)
 				return ai_achievability::NOT_ACHIEVABLE;
 		} else {
-			Assertion(false, "Target name %s is not an arrived ship!", aigp->target_name);
+			UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 			return ai_achievability::NOT_ACHIEVABLE;			// force this goal to be invalid
 		}
 	}
@@ -2116,15 +1917,15 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 	// Goober5000 - see note at PURGE_GOALS_ALL_SHIPS... this is bizarre
 	if ((status == SHIP_STATUS_ARRIVED) && !(aigp->flags[AI::Goal_Flags::Goals_purged]))
 	{
-		if (causes_invalid_goal_purge_all_ships(aigp->ai_mode)) {
+		if (purge_goals_all_ships(aigp->ai_mode)) {
 			ai_goal_purge_all_invalid_goals(aigp);
 			aigp->flags.set(AI::Goal_Flags::Goals_purged);
 		}
-		else if (causes_invalid_goal_purge_one_ship(aigp->ai_mode)) {
+		else if (purge_goals_one_ship(aigp->ai_mode)) {
 			ai_goal_purge_invalid_goals(aigp, aip->goals, aip, -1);
 			aigp->flags.set(AI::Goal_Flags::Goals_purged);
 		}
-	}
+	}	

 	// if we are docking, validate the docking indices on both ships.  We might have to change names to indices.
 	// only enter this calculation if the ship we are docking with has arrived.  If the ship is gone, then
@@ -2156,8 +1957,8 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 			return ai_achievability::NOT_KNOWN;

 		// we must also determine if we're prevented from docking for any reason
-		Assertion(target_ship_entry && target_ship_entry->has_shipp(), "Target name %s is not an arrived ship!", aigp->target_name);
 		if (!target_ship_entry || !target_ship_entry->has_shipp()) {
+			UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 			return ai_achievability::NOT_ACHIEVABLE;			// force this goal to be invalid
 		}
 		auto goal_objp = target_ship_entry->objp();
@@ -2214,7 +2015,7 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 				if (aip->goal_objnum != target_ship_entry->objnum)
 					return ai_achievability::NOT_KNOWN;
 			} else {
-				Assertion(false, "Target name %s is not an arrived ship!", aigp->target_name);
+				UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 				return ai_achievability::NOT_ACHIEVABLE;			// force this goal to be invalid
 			}
 		}
@@ -2228,14 +2029,14 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 				aigp->ai_submode = ship_find_subsys( target_ship_entry->shipp(), aigp->docker.name );
 				aigp->flags.remove(AI::Goal_Flags::Subsys_needs_fixup);
 			} else {
-				Assertion(false, "Target name %s is not an arrived ship!", aigp->target_name);
+				UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 				return ai_achievability::NOT_ACHIEVABLE;			// force this goal to be invalid
 			}
 		}
 	} else if ( ((aigp->ai_mode == AI_GOAL_IGNORE) || (aigp->ai_mode == AI_GOAL_IGNORE_NEW)) && (status == SHIP_STATUS_ARRIVED) ) {
 		// for ignoring a ship, call the ai_ignore object function, then declare the goal satisfied
-		Assertion(target_ship_entry && target_ship_entry->has_objp(), "Target name %s is not an arrived ship!", aigp->target_name);
 		if (!target_ship_entry || !target_ship_entry->has_objp()) {
+			UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 			return ai_achievability::NOT_ACHIEVABLE;			// force this goal to be invalid
 		}
 		auto ignored = target_ship_entry->objp();
@@ -2284,16 +2085,16 @@ ai_achievability ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 		{
 			// short circuit a couple of cases.  Ship not arrived shouldn't happen.  Ship gone means
 			// we mark the goal as not achievable.
-			Assertion(status != SHIP_STATUS_NOT_ARRIVED, "Ship %s cannot rearm a target %s that hasn't arrived; get Allender or a SCP member", shipp->ship_name, aigp->target_name);	// get Allender.  this shouldn't happen!!!
 			if ( status == SHIP_STATUS_NOT_ARRIVED ) {
+				UNREACHABLE("Ship %s cannot rearm a target %s that hasn't arrived; get Allender or a SCP member", shipp->ship_name, aigp->target_name);	// get Allender.  this shouldn't happen!!!
 				return ai_achievability::NOT_ACHIEVABLE;
 			}

 			if ( status == SHIP_STATUS_GONE )
 				return ai_achievability::NOT_ACHIEVABLE;

-			Assertion(target_ship_entry && target_ship_entry->has_shipp(), "Target name %s is not an arrived ship!", aigp->target_name);
 			if ( !target_ship_entry || !target_ship_entry->has_shipp() ) {
+				UNREACHABLE("Target name %s is not an arrived ship!", aigp->target_name);
 				return ai_achievability::NOT_ACHIEVABLE;
 			}

@@ -2424,10 +2225,6 @@ void validate_mission_goals(int objnum, ai_info *aip)
 			continue;
 		}

-		// if the status is achievable, and we want to set the override, set it
-		if ( (state == ai_achievability::ACHIEVABLE) && (aigp->flags[AI::Goal_Flags::Want_override]))
-			aigp->flags.set(AI::Goal_Flags::Goal_override);
-
 		// if the status is achievable, and the on_hold flag is set, clear the flagb
 		if ( (state == ai_achievability::ACHIEVABLE) && (aigp->flags[AI::Goal_Flags::Goal_on_hold]) )
 			aigp->flags.remove(AI::Goal_Flags::Goal_on_hold);
@@ -2477,7 +2274,7 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	object	*objp = &Objects[objnum];
 	object	*other_obj;
 	ai_goal	*current_goal;
-	int		wingnum;
+	int		wingnum, shipnum;
 	int		original_signature;

 /*	if (!stricmp(Ships[objp->instance].ship_name, "gtt comet")) {
@@ -2549,38 +2346,17 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	if ( !(Player_use_ai) && (objp->flags[Object::Object_Flags::Player_ship]) && (current_goal->ai_mode != AI_GOAL_FORM_ON_WING) )
 	{
 		return;
-	}
+	}	

-	ai_reset_order_state(aip);

-	std::unique_ptr<ai_goal> current_goal_backup;
-	auto current_goal_target_ship = current_goal->target_name ? ship_registry_get(current_goal->target_name) : nullptr;
-
-	if (current_goal->flags[AI::Goal_Flags::Clear_all_goals_first]) {
-		// save the current goal before we wipe it out by clearing everything
-		current_goal_backup.reset(new ai_goal(*current_goal));
-		current_goal = current_goal_backup.get();
-
-		// stay-still, form-on-wing, and play-dead all clear their goals here...
-		// 
-		// clear out the object's goals.  Seems to me that if a ship is staying still for a purpose
-		// then we need to clear everything out since there is not a real way to get rid of this goal
-		// 
-		// for form on wing, we need to clear out all goals for this ship, and then call the form on wing AI code
-		// 
-		// if a ship is playing dead, MWA says that it shouldn't try to do anything else.
-		// 
-		// clearing out goals is okay here since we are now what mode to set this AI object to.
-
-		ai_clear_ship_goals(aip);
-	}

 	switch ( current_goal->ai_mode ) {

 	case AI_GOAL_CHASE:
-		if (current_goal->target_name) {
-			Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-			other_obj = current_goal_target_ship->objp();
+		if ( current_goal->target_name ) {
+			shipnum = ship_name_lookup( current_goal->target_name );
+			Assert (shipnum != -1 );			// shouldn't get here if this is false!!!!
+			other_obj = &Objects[Ships[shipnum].objnum];
 		} else
 			other_obj = NULL;						// we get this case when we tell ship to engage enemy!

@@ -2597,8 +2373,9 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		break;

 	case AI_GOAL_GUARD:
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert (shipnum != -1 );			// shouldn't get here if this is false!!!!
+		other_obj = &Objects[Ships[shipnum].objnum];
 		// shipnum and other_obj are the shipnumber and object pointer of the object that you should
 		// guard.
 		if (objp != other_obj) {
@@ -2629,8 +2406,9 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	}

 	case AI_GOAL_DOCK: {
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert (shipnum != -1 );			// shouldn't get here if this is false!!!!
+		other_obj = &Objects[Ships[shipnum].objnum];

 		// be sure that we have indices for docking points here!  If we ever had names, they should
 		// get fixed up in goal_achievable so that the points can be checked there for validity
@@ -2640,22 +2418,24 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	}

 	case AI_GOAL_UNDOCK:
-		// try to find the object with which this object is docked.  Use that object as the
+		// try to find the object which which this object is docked with.  Use that object as the
 		// "other object" for the undocking proceedure.  If "other object" isn't found, then the undock
 		// goal cannot continue.  Spit out a warning and remove the goal.

 		// Goober5000 - do we have a specific ship to undock from?
-		if (current_goal->target_name)
+		if ( current_goal->target_name != NULL )
 		{
+			shipnum = ship_name_lookup( current_goal->target_name );
+
 			// hmm, perhaps he was destroyed
-			if (!current_goal_target_ship || !current_goal_target_ship->has_objp())
+			if (shipnum == -1)
 			{
 				other_obj = NULL;
 			}
 			// he exists... let's undock from him
 			else
 			{
-				other_obj = current_goal_target_ship->objp();
+				other_obj = &Objects[Ships[shipnum].objnum];
 			}
 		}
 		// no specific ship
@@ -2708,15 +2488,16 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	case AI_GOAL_DISABLE_SHIP_TACTICAL:
 	case AI_GOAL_DISARM_SHIP:
 	case AI_GOAL_DISARM_SHIP_TACTICAL: {
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert( shipnum >= 0 );
+		other_obj = &Objects[Ships[shipnum].objnum];
 		ai_attack_object( objp, other_obj);
 		ai_set_attack_subsystem( objp, current_goal->ai_submode );		// submode stored the subsystem type

 		// don't protect-ship for tactical goals
 		if (current_goal->ai_mode != AI_GOAL_DESTROY_SUBSYSTEM && current_goal->ai_mode != AI_GOAL_DISABLE_SHIP_TACTICAL && current_goal->ai_mode != AI_GOAL_DISARM_SHIP_TACTICAL) {
 			if (aip->target_objnum != -1) {
-				int class_type = Ship_info[current_goal_target_ship->shipp()->ship_info_index].class_type;
+				int class_type = Ship_info[Ships[shipnum].ship_info_index].class_type;
 				//	Only protect if _not_ a capital ship.  We don't want the Lucifer accidentally getting protected.
 				if (class_type >= 0 && Ship_types[class_type].flags[Ship::Type_Info_Flags::AI_protected_on_cripple])
 					Objects[aip->target_objnum].flags.set(Object::Object_Flags::Protected);
@@ -2740,20 +2521,10 @@ void ai_process_mission_orders( int objnum, ai_info *aip )

 	// chase-ship-class is chase-any but restricted to a subset of ships
 	case AI_GOAL_CHASE_SHIP_CLASS:
-	{
-		int ship_info_index = ship_info_lookup(current_goal->target_name);
-		Assertion(ship_info_index >= 0, "The target of AI_GOAL_CHASE_SHIP_CLASS must refer to a valid ship class!");
-		ai_attack_object(objp, nullptr, ship_info_index);
+		shipnum = ship_info_lookup( current_goal->target_name );
+		Assertion( shipnum >= 0, "The target of AI_GOAL_CHASE_SHIP_CLASS must refer to a valid ship class!" );
+		ai_attack_object( objp, nullptr, shipnum );
 		break;
-	}
-	// similarly for chase-ship-type
-	case AI_GOAL_CHASE_SHIP_TYPE:
-	{
-		int class_type = ship_type_name_lookup(current_goal->target_name);
-		Assertion(class_type >= 0, "The target of AI_GOAL_CHASE_SHIP_TYPE must refer to a valid ship type!");
-		ai_attack_object(objp, nullptr, -1, class_type);
-		break;
-	}

 	case AI_GOAL_WARP: {
 		mission_do_departure( objp, true );
@@ -2761,29 +2532,46 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	}

 	case AI_GOAL_EVADE_SHIP:
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert( shipnum >= 0 );
+		other_obj = &Objects[Ships[shipnum].objnum];
 		ai_evade_object( objp, other_obj);
 		break;

 	case AI_GOAL_STAY_STILL:
-		// NOTE: goal clearing moved above this enclosing switch block
 		// for now, ignore any other parameters!!!!
+		// clear out the object's goals.  Seems to me that if a ship is staying still for a purpose
+		// then we need to clear everything out since there is not a real way to get rid of this goal
+		// clearing out goals is okay here since we are now what mode to set this AI object to.
+		ai_clear_ship_goals( aip );
 		ai_stay_still( objp, NULL );
 		break;

 	case AI_GOAL_PLAY_DEAD:
+		// if a ship is playing dead, MWA says that it shouldn't try to do anything else.
+		// clearing out goals is okay here since we are now what mode to set this AI object to.
+		ai_clear_ship_goals( aip );
+		aip->mode = AIM_PLAY_DEAD;
+		aip->submode = -1;
+		aip->submode_start_time = Missiontime;
+		break;
+
 	case AI_GOAL_PLAY_DEAD_PERSISTENT:
-		// NOTE: goal clearing moved above this enclosing switch block
+		// same as above, but we don't clear out ship goals
 		aip->mode = AIM_PLAY_DEAD;
 		aip->submode = -1;
 		aip->submode_start_time = Missiontime;
 		break;

 	case AI_GOAL_FORM_ON_WING:
-		// NOTE: goal clearing moved above this enclosing switch block
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		// get the ship first, since we're going to wipe it out next
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert( shipnum >= 0 );
+		other_obj = &Objects[Ships[shipnum].objnum];
+		// for form on wing, we need to clear out all goals for this ship, and then call the form
+		// on wing AI code
+		// clearing out goals is okay here since we are now what mode to set this AI object to.
+		ai_clear_ship_goals( aip );
 		ai_form_on_wing( objp, other_obj );
 		break;

@@ -2792,8 +2580,9 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	case AI_GOAL_STAY_NEAR_SHIP:
 	case AI_GOAL_FLY_TO_SHIP:
 	{
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert( shipnum >= 0 );
+		other_obj = &Objects[Ships[shipnum].objnum];
 		float dist = current_goal->float_data;	//	How far away to stay from ship.  Should be set in SEXP?
 		int additional_data = current_goal->int_data;	// Whether to target a particular point as if escorting
 		ai_do_stay_near(objp, other_obj, dist, additional_data);
@@ -2808,8 +2597,9 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		break;

 	case AI_GOAL_REARM_REPAIR:
-		Assert(current_goal_target_ship && current_goal_target_ship->has_objp());                        // shouldn't get here if this is false!!!!
-		other_obj = current_goal_target_ship->objp();
+		shipnum = ship_name_lookup( current_goal->target_name );
+		Assert( shipnum >= 0 );
+		other_obj = &Objects[Ships[shipnum].objnum];
 		ai_rearm_repair( objp, current_goal->docker.index, other_obj, current_goal->dockee.index );
 		break;
 		
@@ -47,9 +47,9 @@ enum class ai_goal_type
 enum ai_goal_mode : uint8_t
 {
 	AI_GOAL_NONE = 0,
-	AI_GOAL_SCHROEDINGER,		// used for FRED when multiple ships are selected with different orders
+	AI_GOAL_PLACEHOLDER_1,

-	AI_GOAL_CHASE,
+	AI_GOAL_CHASE,              // per the original #define list, AI_GOAL_CHASE started at 2 (1<<1)
 	AI_GOAL_DOCK,               // used for undocking as well
 	AI_GOAL_WAYPOINTS,
 	AI_GOAL_WAYPOINTS_ONCE,
@@ -80,8 +80,7 @@ enum ai_goal_mode : uint8_t
 	AI_GOAL_FLY_TO_SHIP,
 	AI_GOAL_IGNORE_NEW,
 	AI_GOAL_CHASE_SHIP_CLASS,
-	AI_GOAL_CHASE_SHIP_TYPE,
-	AI_GOAL_PLAY_DEAD_PERSISTENT, // Disables subsystem rotation/translation among other things but there is a carveout for that in the lab in ship_move_subsystems() and ai_process_subobjects()
+	AI_GOAL_PLAY_DEAD_PERSISTENT,
 	AI_GOAL_LUA,
 	AI_GOAL_DISARM_SHIP_TACTICAL,
 	AI_GOAL_DISABLE_SHIP_TACTICAL,
@@ -104,11 +103,7 @@ inline bool ai_goal_is_disable_or_disarm(ai_goal_mode ai_mode)
 }
 inline bool ai_goal_is_specific_chase(ai_goal_mode ai_mode)
 {
-	return ai_mode == AI_GOAL_CHASE || ai_mode == AI_GOAL_CHASE_WING || ai_mode == AI_GOAL_CHASE_SHIP_CLASS || ai_mode == AI_GOAL_CHASE_SHIP_TYPE;
-}
-inline bool ai_goal_is_standing_chase(ai_goal_mode ai_mode)
-{
-	return ai_mode == AI_GOAL_CHASE_ANY;
+	return ai_mode == AI_GOAL_CHASE || ai_mode == AI_GOAL_CHASE_WING || ai_mode == AI_GOAL_CHASE_SHIP_CLASS;
 }

 enum class ai_achievability { ACHIEVABLE, NOT_ACHIEVABLE, NOT_KNOWN, SATISFIED };
@@ -157,8 +152,6 @@ typedef struct ai_goal {

 extern void ai_goal_reset(ai_goal *aigp, bool adding_goal = false, ai_goal_mode ai_mode = AI_GOAL_NONE, int ai_submode = -1, ai_goal_type type = ai_goal_type::INVALID);

-// Reset all path points. Used in the ship lab. Missions clean up path points with the garbage collector in garbage_collect_path_points()
-extern void reset_ai_path_points();

 typedef flag_def_list_templated<ai_goal_mode> ai_goal_list;

@@ -183,7 +176,7 @@ extern void ai_process_mission_orders( int objnum, ai_info *aip );
 extern int ai_goal_num(ai_goal *goals);

 // adds goals to ships/wing through sexpressions
-extern void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, const char *shipname, ai_info *aip, int int_data, float float_data, int docker_index = -1, int dockee_index = -1);
+extern void ai_add_ship_goal_scripting(ai_goal_mode mode, int submode, int priority, const char *shipname, ai_info *aip, int int_data, float float_data);
 extern void ai_add_ship_goal_sexp(int sexp, ai_goal_type type, ai_info *aip);
 extern void ai_add_wing_goal_sexp(int sexp, ai_goal_type type, wing *wingp);
 extern void ai_add_goal_sub_sexp(int sexp, ai_goal_type type, ai_info *aip, ai_goal *aigp, const char *actor_name);
@@ -192,8 +185,8 @@ extern int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more )
 extern void ai_remove_wing_goal_sexp( int sexp, wing *wingp );

 // adds goals to ships/sings through player orders
-extern void ai_add_ship_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char* shipname, ai_info* aip, int int_data = 0, float float_data = 0.0f, const ai_lua_parameters& lua_target = { object_ship_wing_point_team(), luacpp::LuaValueList{} });
-extern void ai_add_wing_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char* shipname, int wingnum, int int_data = 0, float float_data = 0.0f, const ai_lua_parameters& lua_target = { object_ship_wing_point_team(), luacpp::LuaValueList{} });
+extern void ai_add_ship_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char* shipname, ai_info* aip, const ai_lua_parameters& lua_target = { object_ship_wing_point_team(), luacpp::LuaValueList{} });
+extern void ai_add_wing_goal_player(ai_goal_type type, ai_goal_mode mode, int submode, const char* shipname, int wingnum, const ai_lua_parameters& lua_target = { object_ship_wing_point_team(), luacpp::LuaValueList{} });

 extern void ai_remove_ship_goal( ai_info *aip, int index );
 extern void ai_clear_ship_goals( ai_info *aip );
@@ -350,18 +350,6 @@ const weapon_info *get_turret_weapon_wip(const ship_weapon *swp, int weapon_num)
 		return &Weapon_info[wi_index];
 }

-// similar to the above, since "weapon_num" is a bank index over multiple banks
-static std::pair<int, int> get_turret_weapon_bank(int weapon_num)
-{
-	int pbank = -1;
-	int sbank = -1;
-	if (weapon_num >= MAX_SHIP_PRIMARY_BANKS)
-		sbank = weapon_num - MAX_SHIP_PRIMARY_BANKS;
-	else
-		pbank = weapon_num;
-	return { pbank, sbank };
-}
-
 int get_turret_weapon_next_fire_stamp(const ship_weapon *swp, int weapon_num)
 {
 	Assert(weapon_num < MAX_SHIP_WEAPONS);
@@ -491,12 +479,6 @@ int valid_turret_enemy(object *objp, object *turret_parent)
 			return 0;
 		}

-		// Mines are only targetable within their configured detection range
-		if (wip->is_mine()) {
-			if (vm_vec_dist(&objp->pos, &turret_parent->pos) > wip->mine_targetable_range)
-				return 0;
-		}
-
 		return 1;
 	}

@@ -1107,12 +1089,9 @@ int find_turret_enemy(const ship_subsys *turret_subsys, int objnum, const vec3d
 		int target_objnum = aip->target_objnum;

 		if (Objects[target_objnum].signature == aip->target_signature) {
-			// The parent's target can be a weapon or an asteroid, so make sure it's a ship before indexing Ships[]
-			ship* target_shipp = (Objects[target_objnum].type == OBJ_SHIP) ? &Ships[Objects[target_objnum].instance] : nullptr;
-			if (target_shipp && iff_matches_mask(target_shipp->team, enemy_team_mask)) {
-				if (!(Objects[target_objnum].flags[Object::Object_Flags::Protected])) { // check this flag as well
-					// nprintf(("AI", "Frame %i: Object %i resuming goal of object %i\n", AI_FrameCount, objnum,
-					// target_objnum));
+			if (iff_matches_mask(Ships[Objects[target_objnum].instance].team, enemy_team_mask)) {
+				if ( !(Objects[target_objnum].flags[Object::Object_Flags::Protected]) ) {		// check this flag as well
+					// nprintf(("AI", "Frame %i: Object %i resuming goal of object %i\n", AI_FrameCount, objnum, target_objnum));
 					return target_objnum;
 				}
 			}
@@ -1580,9 +1559,7 @@ void turret_set_next_fire_timestamp(int weapon_num, const weapon_info *wip, ship
 	float burst_shots_mult = wip->weapon_launch_curves.get_output(weapon_info::WeaponLaunchCurveOutputs::BURST_SHOTS_MULT, launch_curve_data);
 	int burst_shots = MAX(fl2i(i2fl(base_burst_shots) * burst_shots_mult) - 1, 0);

-	bool burst = burst_shots > turret->weapons.burst_counter[weapon_num];
-
-	if (burst) {
+	if (burst_shots > turret->weapons.burst_counter[weapon_num]) {
 		wait *= wip->burst_delay;
 		wait *= wip->weapon_launch_curves.get_output(weapon_info::WeaponLaunchCurveOutputs::BURST_DELAY_MULT, launch_curve_data);
 		turret->weapons.burst_counter[weapon_num]++;
@@ -1682,7 +1659,7 @@ void turret_set_next_fire_timestamp(int weapon_num, const weapon_info *wip, ship
 		wait *= frand_range(0.9f, 1.1f);
 	}

-	if(turret->rof_scaler != 1.0f && !(burst && turret->system_info->flags[Model::Subsystem_Flags::Burst_ignores_RoF_Mult]))
+	if(turret->rof_scaler != 1.0f)
 		wait /= get_adjusted_turret_rof(turret);

 	(*fs_dest) = timestamp((int)wait);
@@ -1741,7 +1718,6 @@ bool turret_fire_weapon(int weapon_num,
 	auto wip = get_turret_weapon_wip(&turret->weapons, weapon_num);
 	if (!wip)
 		return false;
-	auto [turret_pbank, turret_sbank] = get_turret_weapon_bank(weapon_num);

 	bool in_lab = (gameseq_get_state() == GS_STATE_LAB);

@@ -1768,7 +1744,7 @@ bool turret_fire_weapon(int weapon_num,

 	parent_aip = &Ai_info[Ships[Objects[parent_objnum].instance].ai_index];
 	parent_ship = &Ships[Objects[parent_objnum].instance];
-	int turret_weapon_class = WEAPON_INFO_INDEX(wip);
+	int turret_weapon_class = weapon_info_get_index(wip);

 #ifndef NDEBUG
 	// moved here from check_ok_to_fire
@@ -1852,7 +1828,6 @@ bool turret_fire_weapon(int weapon_num,
 				else
 					fire_info.target_subsys = nullptr;
 				fire_info.turret = turret;
-				fire_info.bank = turret_pbank;
 				fire_info.burst_seed = old_burst_seed;
 				fire_info.fire_method = BFM_TURRET_FIRED;
 				fire_info.per_burst_rotation = swp->per_burst_rot;
@@ -1865,6 +1840,7 @@ bool turret_fire_weapon(int weapon_num,
 					fire_info.target_pos1 = turret->last_aim_enemy_pos;
 				}

+
 				// fire a beam weapon
 				weapon_objnum = beam_fire(&fire_info);

@@ -1890,53 +1866,113 @@ bool turret_fire_weapon(int weapon_num,
 		}
 		// don't fire swam, but set up swarm info instead
 		else if ((wip->wi_flags[Weapon::Info_Flags::Swarm]) || (wip->wi_flags[Weapon::Info_Flags::Corkscrew])) {
-			// swarm and corkscrew are not restricted to missiles, so check whichever bank is actually firing
-			if (!in_lab && (turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo])) {
-				bool has_ammo = (turret_pbank >= 0)
-					? swp->primary_bank_ammo[turret_pbank] > 0
-					: ship_secondary_has_ammo(swp, turret_sbank);
-				if (!has_ammo)
-					return false;
+			if (swp->current_secondary_bank < 0) {
+				swp->current_secondary_bank = 0;
 			}
+			int bank_to_fire = swp->current_secondary_bank;
+			if (!in_lab && (turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo]) && !ship_secondary_has_ammo(swp, bank_to_fire)) {
+				if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns])) {
+					swp->current_secondary_bank++;
+					if (swp->current_secondary_bank >= swp->num_secondary_banks) {
+						swp->current_secondary_bank = 0;
+					}
+					return false;
+				} else {
+					return false;
+				}
+			} else {
+				turret_swarm_set_up_info(parent_objnum, turret, wip, turret->turret_next_fire_pos, in_lab);

-			turret_swarm_set_up_info(parent_objnum, turret, wip, turret->turret_next_fire_pos, turret_pbank, turret_sbank, in_lab);
-			turret->flags.set(Ship::Subsystem_Flags::Has_fired);	//set fired flag for scripting -nike
-			return true;
+				turret->flags.set(Ship::Subsystem_Flags::Has_fired);	//set fired flag for scripting -nike
+				return true;
+			}
 		}
 		// now do anything else
 		else {
 			float shots_mult = wip->weapon_launch_curves.get_output(weapon_info::WeaponLaunchCurveOutputs::SHOTS_MULT, launch_curve_data);
 			int shots = fl2i(i2fl(wip->shots) * shots_mult);
-
-			// note that wip is reassigned to the created weapon's class inside the loop, so any
-			// property of the bank's own weapon must be read before we get there
-			bool no_ammo_needed = (turret_sbank >= 0) && Weapon_info[swp->secondary_bank_weapons[turret_sbank]].wi_flags[Weapon::Info_Flags::SecondaryNoAmmo];
 			for (int i = 0; i < shots; i++) {
 				if (!in_lab && turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo]) {
-					if (turret_pbank >= 0) {
+					int bank_to_fire, num_slots = turret->system_info->turret_num_firing_points;
+					if (wip->subtype == WP_LASER) {
 						int points;
+						if (swp->num_primary_banks <= 0) {
+							return false;
+						}
+
+						if (swp->current_primary_bank < 0){
+							swp->current_primary_bank = 0;
+							return false;
+						}
+
+						int	num_primary_banks = swp->num_primary_banks;
+
+						Assert(num_primary_banks > 0);
+						if (num_primary_banks < 1){
+							return false;
+						}
+
+						bank_to_fire = swp->current_primary_bank;
+
 						if (turret->system_info->flags[Model::Subsystem_Flags::Turret_salvo]) {
-							points = turret->system_info->turret_num_firing_points;
+							points = num_slots;
 						} else {
 							points = 1;
 						}

-						if (swp->primary_bank_ammo[turret_pbank] >= points) {
-							swp->primary_bank_ammo[turret_pbank] -= points;
-						} else if ((swp->primary_bank_ammo[turret_pbank] >= 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
+						if (swp->primary_bank_ammo[bank_to_fire] >= points) {
+							swp->primary_bank_ammo[bank_to_fire] -= points;
+						} else if ((swp->primary_bank_ammo[bank_to_fire] >= 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
 							// default behavior allowed ammo to be negative
-							swp->primary_bank_ammo[turret_pbank] -= points;
+							swp->primary_bank_ammo[bank_to_fire] -= points;
+						} else if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns]) && (swp->primary_bank_ammo[bank_to_fire] < 0)) {
+							swp->current_primary_bank++;
+							if (swp->current_primary_bank >= swp->num_primary_banks) {
+								swp->current_primary_bank = 0;
+							}
+							return false;
 						} else {
 							return false;
 						}
 					}
-					else if (turret_sbank >= 0) {
-						if (!no_ammo_needed) {
-							if (swp->secondary_bank_ammo[turret_sbank] > 0) {
-								swp->secondary_bank_ammo[turret_sbank]--;
-							} else if ((swp->secondary_bank_ammo[turret_sbank] == 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
+					else if (wip->subtype == WP_MISSILE) {
+						if (swp->num_secondary_banks <= 0) {
+							return false;
+						}
+
+						if (swp->current_secondary_bank < 0){
+							swp->current_secondary_bank = 0;
+							return false;
+						}
+
+						bank_to_fire = swp->current_secondary_bank;
+
+						int start_slot, end_slot;
+
+						start_slot = swp->secondary_next_slot[bank_to_fire];
+						end_slot = start_slot;
+
+						for (int j = start_slot; j <= end_slot; j++) {
+							swp->secondary_next_slot[bank_to_fire]++;
+
+							if (Weapon_info[swp->secondary_bank_weapons[bank_to_fire]].wi_flags[Weapon::Info_Flags::SecondaryNoAmmo])
+								continue;
+
+							if (swp->secondary_next_slot[bank_to_fire] > (num_slots - 1)){
+								swp->secondary_next_slot[bank_to_fire] = 0;
+							}
+
+							if (swp->secondary_bank_ammo[bank_to_fire] > 0) {
+								swp->secondary_bank_ammo[bank_to_fire]--;
+							} else if ((swp->secondary_bank_ammo[bank_to_fire] == 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
 								// default behavior allowed ammo to be negative
-								swp->secondary_bank_ammo[turret_sbank]--;
+								swp->secondary_bank_ammo[bank_to_fire]--;
+							} else if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns]) && (swp->secondary_bank_ammo[bank_to_fire] < 0)) {
+								swp->current_secondary_bank++;
+								if (swp->current_secondary_bank >= swp->num_secondary_banks) {
+									swp->current_secondary_bank = 0;
+								}
+								return false;
 							} else {
 								return false;
 							}
@@ -1951,7 +1987,7 @@ bool turret_fire_weapon(int weapon_num,
 				// so we need to get the position info separately for each shot
 				ship_get_global_turret_gun_info(&Objects[parent_objnum], turret, &firing_pos_buf, false, nullptr, true, nullptr);

-				weapon_objnum = weapon_create(firing_pos, &firing_orient, turret_weapon_class, parent_objnum, -1, true, false, swp, turret_pbank, turret_sbank, launch_curve_data);
+				weapon_objnum = weapon_create(firing_pos, &firing_orient, turret_weapon_class, parent_objnum, -1, true, false, 0.0f, turret, launch_curve_data);
 				weapon_set_tracking_info(weapon_objnum, parent_objnum, turret->turret_enemy_objnum, 1, turret->targeted_subsys);		
 			
 				//nprintf(("AI", "Turret_time_enemy_in_range = %7.3f\n", ss->turret_time_enemy_in_range));		
@@ -2002,11 +2038,14 @@ bool turret_fire_weapon(int weapon_num,
 						}
 						//spawn particle effect
 						auto particleSource = particle::ParticleManager::get()->createSource(wip->muzzle_effect);
-						particleSource->setHost(std::make_unique<EffectHostTurret>(&Objects[parent_ship->objnum], turret->system_info->turret_gun_sobj, turret->turret_next_fire_pos, false));
+						particleSource->setHost(make_unique<EffectHostTurret>(&Objects[parent_ship->objnum], turret->system_info->turret_gun_sobj, turret->turret_next_fire_pos));
 						particleSource->setTriggerRadius(objp->radius * radius_mult);
 						particleSource->setTriggerVelocity(vm_vec_mag_quick(&objp->phys_info.vel));
 						particleSource->finishCreation();
 					}
+					else if (wip->muzzle_flash >= 0) {
+						mflash_create(firing_pos, firing_vec, &Objects[parent_ship->objnum].phys_info, wip->muzzle_flash);
+					}

 					// in multiplayer (and the master), then send a turret fired packet.
 					if ( MULTIPLAYER_MASTER && (weapon_objnum != -1) ) {
@@ -2015,9 +2054,9 @@ bool turret_fire_weapon(int weapon_num,
 						subsys_index = ship_get_subsys_index(turret);
 						Assert( subsys_index != -1 );
 						if(wip->wi_flags[Weapon::Info_Flags::Flak]){			
-							send_flak_fired_packet( parent_objnum, subsys_index, weapon_objnum, flak_range, launch_curve_data.distance_to_target, launch_curve_data.target_radius, launch_curve_data.target_forward_speed );
+							send_flak_fired_packet( parent_objnum, subsys_index, weapon_objnum, flak_range, launch_curve_data.distance_to_target, launch_curve_data.target_radius );
 						} else {
-							send_turret_fired_packet( parent_objnum, subsys_index, weapon_objnum, launch_curve_data.distance_to_target, launch_curve_data.target_radius, launch_curve_data.target_forward_speed );
+							send_turret_fired_packet( parent_objnum, subsys_index, weapon_objnum, launch_curve_data.distance_to_target, launch_curve_data.target_radius );
 						}
 					}

@@ -2091,11 +2130,10 @@ void turret_swarm_fire_from_turret(turret_swarm_info *tsi)
 		tsi->turret->system_info->turret_num_firing_points,
 		0.f,
 		0.f,
-		0.f,
 	};

 	// create weapon and homing info
-	weapon_objnum = weapon_create(&turret_pos, &firing_orient, tsi->weapon_class, tsi->parent_objnum, -1, true, false, &tsi->turret->weapons, tsi->swp_pbank, tsi->swp_sbank, launch_curve_data);
+	weapon_objnum = weapon_create(&turret_pos, &firing_orient, tsi->weapon_class, tsi->parent_objnum, -1, true, false, 0.0f, tsi->turret, launch_curve_data);
 	weapon_set_tracking_info(weapon_objnum, tsi->parent_objnum, tsi->target_objnum, 1, tsi->target_subsys);

 	// do other cool stuff if weapon is created.
@@ -2124,10 +2162,13 @@ void turret_swarm_fire_from_turret(turret_swarm_info *tsi)
 		if (Weapon_info[tsi->weapon_class].muzzle_effect.isValid()) {
 			//spawn particle effect
 			auto particleSource = particle::ParticleManager::get()->createSource(Weapon_info[tsi->weapon_class].muzzle_effect);
-			particleSource->setHost(std::make_unique<EffectHostTurret>(&Objects[tsi->parent_objnum], tsi->turret->system_info->turret_gun_sobj, tsi->turret->turret_next_fire_pos - 1, false));
+			particleSource->setHost(make_unique<EffectHostTurret>(&Objects[tsi->parent_objnum], tsi->turret->system_info->turret_gun_sobj, tsi->turret->turret_next_fire_pos - 1));
 			particleSource->setTriggerRadius(Objects[weapon_objnum].radius);
 			particleSource->finishCreation();
 		}
+		else if (Weapon_info[tsi->weapon_class].muzzle_flash >= 0) {
+			mflash_create(&turret_pos, &turret_fvec, &Objects[tsi->parent_objnum].phys_info, Weapon_info[tsi->weapon_class].muzzle_flash);
+		}

 		// maybe sound
 		if ( Weapon_info[tsi->weapon_class].launch_snd.isValid() ) {
@@ -2143,7 +2184,7 @@ void turret_swarm_fire_from_turret(turret_swarm_info *tsi)

 			subsys_index = ship_get_subsys_index(tsi->turret);
 			Assert( subsys_index != -1 );
-			send_turret_fired_packet( tsi->parent_objnum, subsys_index, weapon_objnum, 0.f, 0.f, 0.f);
+			send_turret_fired_packet( tsi->parent_objnum, subsys_index, weapon_objnum, 0.f, 0.f);
 		}
 	}
 }
@@ -2316,11 +2357,9 @@ void ai_turret_execute_behavior(const ship *shipp, ship_subsys *ss)
 	float turret_barrel_length = -1.0f;

 	float target_radius = 0.f;
-	float target_forward_speed = 0.f;

 	if (lep != nullptr) {
 		target_radius = lep->radius;
-		target_forward_speed = lep->phys_info.fspeed;
 	}

 	// grab the data for the launch curve inputs
@@ -2328,7 +2367,6 @@ void ai_turret_execute_behavior(const ship *shipp, ship_subsys *ss)
 			ss->system_info->turret_num_firing_points,
 			base_dist_to_enemy,
 			target_radius,
-			target_forward_speed,
 	};

 	//WMC - go through all valid weapons. Fire spawns if there are any.
@@ -142,15 +142,11 @@ int unpack_pixel(anim_instance *ai, ubyte *data, ubyte pix, int aabitmap, int bp
 			bit_16 = (ushort)pix;
 			break;
 		case 8:
-			// 8-bit-per-pixel HUD gauge ANI aabitmaps use the palette index directly as an alpha value —
-			// the actual RGB colors stored in the palette are completely ignored. The valid range is [0, 15]:
-			//   [0]:    fully transparent (alpha 0)
-			//   [1-14]: black-to-white gradient (alpha = index * 18)
-			//   [15]:   special HUD background (alpha 18, matching index 1, for a dark transparent tint)
-			//   [>15]:  clamped to fully opaque (alpha 255)
-			// Because only the index value matters, the palette in the source file must be ordered so that
-			// index 0 is the transparent end and index 14 is the opaque end. A reversed palette causes the
-			// gauge to render as a solid white square (see GitHub issue #4148).
+			// 8 bit-per-pixel aa bitmaps are a bit special since they only use a palette index value in the range [0, 15]. These 
+			// palette indexes must be remapped to alpha values between [0, 255] which is what graphics code expects. Palette 
+			// range [0, 14] is a gradient from black to white, and palette index 15 is a special color which indicates the background
+			// area of a HUD gauge. Retail code uses the final alpha value for index 1 for this special index to give gauges a dark
+			// transparent background.
 			if (pix > 15) {
 				bit_8 = 255;
 			}
@@ -244,15 +240,11 @@ int unpack_pixel_count(anim_instance *ai, ubyte *data, ubyte pix, int count = 0,
 			bit_16 = (ushort)pix;
 			break;
 		case 8 :
-			// 8-bit-per-pixel HUD gauge ANI aabitmaps use the palette index directly as an alpha value —
-			// the actual RGB colors stored in the palette are completely ignored. The valid range is [0, 15]:
-			//   [0]:    fully transparent (alpha 0)
-			//   [1-14]: black-to-white gradient (alpha = index * 18)
-			//   [15]:   special HUD background (alpha 18, matching index 1, for a dark transparent tint)
-			//   [>15]:  clamped to fully opaque (alpha 255)
-			// Because only the index value matters, the palette in the source file must be ordered so that
-			// index 0 is the transparent end and index 14 is the opaque end. A reversed palette causes the
-			// gauge to render as a solid white square (see GitHub issue #4148).
+			// 8 bit-per-pixel aa bitmaps are a bit special since they only use a palette index value in the range [0, 15]. These 
+			// palette indexes must be remapped to alpha values between [0, 255] which is what graphics code expects. Palette 
+			// range [0, 14] is a gradient from black to white, and palette index 15 is a special color which indicates the background
+			// area of a HUD gauge. Retail code uses the final alpha value for index 1 for this special index to give gauges a dark
+			// transparent background.
 			if (pix > 15) {
 				bit_8 = 255;
 			}
@@ -32,9 +32,8 @@
 #include "object/objcollide.h"
 #include "object/object.h"
 #include "parse/parselo.h"
-#include "particle/ParticleEffect.h"
 #include "scripting/global_hooks.h"
-#include "particle/hosts/EffectHostVector.h"
+#include "particle/particle.h"
 #include "render/3d.h"
 #include "ship/ship.h"
 #include "ship/shipfx.h"
@@ -64,7 +63,8 @@ asteroid			Asteroids[MAX_ASTEROIDS];
 asteroid_field	Asteroid_field;


-static particle::ParticleEffectHandle 		Asteroid_impact_explosion_ani;
+static int		Asteroid_impact_explosion_ani;
+static float	Asteroid_impact_explosion_radius;
 char	Asteroid_icon_closeup_model[NAME_LENGTH];
 vec3d	Asteroid_icon_closeup_position;
 float	Asteroid_icon_closeup_zoom;	
@@ -648,30 +648,24 @@ void asteroid_create_all()
 	int max_asteroids = Asteroid_field.num_initial_asteroids; // * (1.0f - 0.1f*(MAX_DETAIL_VALUE-Detail.asteroid_density)));

 	int num_debris_types = 0;
-	int num_valid = 0;	// count of valid (non-(-1)) entries written into shipDebrisOddsTable

 	// get number of debris types
 	if (Asteroid_field.debris_genre == DG_DEBRIS) {
 		num_debris_types = static_cast<int>(Asteroid_field.field_debris_type.size());

-		// Calculate the odds table; skip invalid entries (field_debris_type[idx] == -1 means
-		// missionparse invalidated the entry because the type no longer exists in Asteroid_info)
+		// Calculate the odds table
 		for (idx=0; idx<num_debris_types; idx++) {
-			if (Asteroid_field.field_debris_type[idx] == -1)
-				continue;
 			float debris_weight = Asteroid_info[Asteroid_field.field_debris_type[idx]].spawn_weight;
-			shipDebrisOddsTable[num_valid].random_threshold = max_weighted_range + debris_weight;
-			shipDebrisOddsTable[num_valid].debris_type = Asteroid_field.field_debris_type[idx];
+			shipDebrisOddsTable[idx].random_threshold = max_weighted_range + debris_weight;
+			shipDebrisOddsTable[idx].debris_type = Asteroid_field.field_debris_type[idx];
 			max_weighted_range += debris_weight;
-			num_valid++;
 		}
 	}

 	// Load Asteroid/debris models
 	if (Asteroid_field.debris_genre == DG_DEBRIS) {
 		for (idx=0; idx<num_debris_types; idx++) {
-			if (Asteroid_field.field_debris_type[idx] != -1)
-				asteroid_load(Asteroid_field.field_debris_type[idx], 0);
+			asteroid_load(Asteroid_field.field_debris_type[idx], 0);
 		}
 	} else {
 		for (const auto& subtype : Asteroid_field.field_asteroid_type) {
@@ -696,7 +690,7 @@ void asteroid_create_all()

 			float rand_choice = frand() * max_weighted_range;

-			for (idx = 0; idx < num_valid; idx++) {
+			for (idx = 0; idx < static_cast<int>(Asteroid_field.field_debris_type.size()); idx++) {
 				// for ship debris, choose type according to odds table
 				if (rand_choice < shipDebrisOddsTable[idx].random_threshold) {
 					asteroid_create(&Asteroid_field, shipDebrisOddsTable[idx].debris_type, 0);
@@ -830,7 +824,18 @@ void asteroid_create_debris_field(int num_asteroids, int asteroid_speed, SCP_vec
 */
 void asteroid_level_init()
 {
-	Asteroid_field = {};
+	Asteroid_field.num_initial_asteroids = 0;  // disable asteroid field by default.
+	Asteroid_field.speed = 0.0f;
+	vm_vec_make(&Asteroid_field.min_bound, -1000.0f, -1000.0f, -1000.0f);
+	vm_vec_make(&Asteroid_field.max_bound, 1000.0f, 1000.0f, 1000.0f);
+	vm_vec_make(&Asteroid_field.inner_min_bound, -500.0f, -500.0f, -500.0f);
+	vm_vec_make(&Asteroid_field.inner_max_bound, 500.0f, 500.0f, 500.0f);
+	Asteroid_field.has_inner_bound = false;
+	Asteroid_field.field_type = FT_ACTIVE;
+	Asteroid_field.debris_genre = DG_ASTEROID;
+	Asteroid_field.field_debris_type.clear();
+	Asteroid_field.field_asteroid_type.clear();
+	Asteroid_field.target_names.clear();

 	if (!Fred_running)
 	{
@@ -1083,10 +1088,8 @@ void asteroid_delete( object * obj )

 	asp = &Asteroids[num];

-	if (asp->model_instance_num >= 0) {
+	if (asp->model_instance_num >= 0)
 		model_delete_instance(asp->model_instance_num);
-		asp->model_instance_num = -1;
-	}

 	if (asp->target_objnum >= 0) {
 		for (asteroid_target& target : Asteroid_targets) {
@@ -1323,9 +1326,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 				model_get_moving_submodel_list(submodel_vector, heavy_obj);

 				// turn off all moving submodels, collide against only 1 at a time.
-				mc.collision_checked.assign(pm->n_models, 0);
+				// turn off collision detection for all moving submodels
 				for (auto submodel: submodel_vector) {
-					mc.collision_checked[submodel] = true;
+					pmi->submodel[submodel].collision_checked = true;
 				}

 				// Only check single submodel now, since children of moving submodels are handled as moving as well
@@ -1333,8 +1336,10 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos

 				// check each submodel in turn
 				for (auto submodel: submodel_vector) {
+					auto smi = &pmi->submodel[submodel];
+
 					// turn on just one submodel for collision test
-					mc.collision_checked[submodel] = false;
+					smi->collision_checked = false;

 					// find the start and end positions of the sphere in submodel RF
 					model_instance_global_to_local_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos, true);
@@ -1366,12 +1371,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 						}
 					}
 					// Don't look at this submodel again
-					mc.collision_checked[submodel] = true;
+					smi->collision_checked = true;
 				}

-				// Clear collision_checked before base model pass so it auto-inits fresh
-				mc.collision_checked.clear();
-
 			}

 			// Now complete base model collision checks that do not take into account rotating submodels.
@@ -1439,9 +1441,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		// everything above was calculated relative to the heavy's position
 		vec3d actual_world_hit_pos = mc.hit_point_world + heavy_obj->pos;
 		if ((shipp->is_arriving()) && (shipp->warpin_effect != nullptr))
-			warp_effect = shipp->warpin_effect.get();
+			warp_effect = shipp->warpin_effect;
 		else if ((shipp->flags[Ship::Ship_Flags::Depart_warp]) && (shipp->warpout_effect != nullptr))
-			warp_effect = shipp->warpout_effect.get();
+			warp_effect = shipp->warpout_effect;

 		if (warp_effect != nullptr && point_is_clipped_by_warp(&actual_world_hit_pos, warp_effect))
 			mc_ret_val = 0;
@@ -1616,13 +1618,8 @@ static float asteroid_create_explosion(object *objp)
 	}

 	fireball_scale_multiplier = asteroid_get_fireball_scale_multiplier(objp->instance);
-	auto fireball_radius = objp->radius * fireball_scale_multiplier;
-
-	if (Zero_radius_explosions_skip_fireballs && fl_near_zero(fireball_radius))
-		fireball_objnum = -1;
-	else
-		fireball_objnum = fireball_create( &objp->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(objp), fireball_radius, false, &objp->phys_info.vel );

+	fireball_objnum = fireball_create( &objp->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(objp), objp->radius*fireball_scale_multiplier, false, &objp->phys_info.vel );
 	if ( fireball_objnum > -1 )	{
 		explosion_life = fireball_lifeleft(&Objects[fireball_objnum]);
 	} else {
@@ -1693,7 +1690,7 @@ static void asteroid_do_area_effect(object *asteroid_objp)
 		if ( weapon_area_calc_damage(ship_objp, &asteroid_objp->pos, asip->inner_rad, asip->outer_rad, asip->blast, asip->damage, &blast, &damage, asip->outer_rad) == -1 )
 			continue;

-		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage, asip->damage_type_idx, DamageSource::Explosion);
+		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage, asip->damage_type_idx);
 		weapon_area_apply_blast(nullptr, ship_objp, &asteroid_objp->pos, blast, false);
 	}	// end for
 }
@@ -1708,57 +1705,37 @@ static void asteroid_do_area_effect(object *asteroid_objp)
 */
 void asteroid_hit( object * pasteroid_obj, object * other_obj, vec3d * hitpos, float damage, vec3d* force )
 {
-	asteroid	*asp = &Asteroids[pasteroid_obj->instance];
-	asteroid_info *asip = &Asteroid_info[Asteroids[pasteroid_obj->instance].asteroid_type];
-	
+	float		explosion_life;
+	asteroid	*asp;
+
+	asp = &Asteroids[pasteroid_obj->instance];
+
 	if (pasteroid_obj->flags[Object::Object_Flags::Should_be_dead]){
 		return;
 	}
-	
+
 	if ( MULTIPLAYER_MASTER ){
 		send_asteroid_hit( pasteroid_obj, other_obj, hitpos, damage, force );
 	}
-	
+
 	if (hitpos && force && The_mission.ai_profile->flags[AI::Profile_Flags::Whackable_asteroids]) {
 		vec3d rel_hit_pos = *hitpos - pasteroid_obj->pos;
 		physics_calculate_and_apply_whack(force, &rel_hit_pos, &pasteroid_obj->phys_info, &pasteroid_obj->orient, &pasteroid_obj->phys_info.I_body_inv);
 		pasteroid_obj->phys_info.desired_vel = pasteroid_obj->phys_info.vel;
 	}
-	
+
 	pasteroid_obj->hull_strength -= damage;
-	
+
 	if (pasteroid_obj->hull_strength < 0.0f) {
 		if ( !asp->final_death_time.isValid() ) {
 			int play_loud_collision = 0;
-			
-			float explosion_life = 1.f;
-			int breakup_timestamp;
-			
-			Assertion(!asip->end_particles.isValid() || asip->breakup_delay.has_value(), "Asteroid %s has end particles but no breakup delay. Parsing should not have allowed this!", asip->name);

-			if (asip->end_particles.isValid()) {
-				auto source = particle::ParticleManager::get()->createSource(asip->end_particles);
-
-				// Use the position since the asteroid is going to be invalid soon
-				auto host = std::make_unique<EffectHostVector>(pasteroid_obj->pos, pasteroid_obj->orient, pasteroid_obj->phys_info.vel);
-				host->setRadius(pasteroid_obj->radius);
-				source->setHost(std::move(host));
-				source->setNormal(pasteroid_obj->orient.vec.uvec);
-				source->finishCreation();
-			} else {
-				explosion_life = asteroid_create_explosion(pasteroid_obj);
-			}
-
-			if (asip->breakup_delay.has_value()) {
-				breakup_timestamp = fl2i(*asip->breakup_delay * MILLISECONDS_PER_SECOND);
-			} else {
-				breakup_timestamp = fl2i((explosion_life * MILLISECONDS_PER_SECOND) / 5.f);
-			}
+			explosion_life = asteroid_create_explosion(pasteroid_obj);

 			asteroid_explode_sound(pasteroid_obj, asp->asteroid_type, play_loud_collision);
 			asteroid_do_area_effect(pasteroid_obj);

-			asp->final_death_time = _timestamp( breakup_timestamp );	// Wait till 20% of vclip time before breaking the asteroid up, or use the specified delay
+			asp->final_death_time = _timestamp( fl2i(explosion_life*MILLISECONDS_PER_SECOND)/5 );	// Wait till 30% of vclip time before breaking the asteroid up.
 			if ( hitpos ) {
 				asp->death_hit_pos = *hitpos;
 			} else {
@@ -1774,10 +1751,8 @@ void asteroid_hit( object * pasteroid_obj, object * other_obj, vec3d * hitpos, f
 			weapon_info *wip;
 			wip = &Weapon_info[Weapons[other_obj->instance].weapon_info_index];
 			// If the weapon didn't play any impact animation, play custom asteroid impact animation
-			if (!wip->impact_weapon_expl_effect.isValid() && Asteroid_impact_explosion_ani.isValid()) {
-				auto source = particle::ParticleManager::get()->createSource(Asteroid_impact_explosion_ani);
-				source->setHost(std::make_unique<EffectHostVector>(*hitpos, vmd_identity_matrix, vmd_zero_vector));
-				source->finishCreation();
+			if (!wip->impact_weapon_expl_effect.isValid()) {
+				particle::create( hitpos, &vmd_zero_vector, 0.0f, Asteroid_impact_explosion_radius, Asteroid_impact_explosion_ani );
 			}
 		}
 	}
@@ -2234,7 +2209,7 @@ static void asteroid_parse_section()
 			}
 			return;
 		}
-		asteroid_list.push_back(std::move(asteroid_t));
+		asteroid_list.push_back(asteroid_t);
 		asteroid_p = &asteroid_list[asteroid_list.size() - 1];

 	}
@@ -2332,13 +2307,13 @@ static void asteroid_parse_section()
 					thisType.type_name.c_str(),
 					asteroid_p->name);
 			} else {
-				asteroid_p->subtypes.push_back(std::move(thisType));
+				asteroid_p->subtypes.push_back(thisType);
 			}
 		}
 	}

 	if (optional_string("$Detail distance:")) {
-		asteroid_p->num_detail_levels = sz2i(stuff_int_list(asteroid_p->detail_distance, MAX_ASTEROID_DETAIL_LEVELS, ParseLookupType::RAW_INTEGER_TYPE));
+		asteroid_p->num_detail_levels = (int)stuff_int_list(asteroid_p->detail_distance, MAX_ASTEROID_DETAIL_LEVELS, RAW_INTEGER_TYPE);
 	}

 	if (optional_string("$Max Speed:")) {
@@ -2355,25 +2330,13 @@ static void asteroid_parse_section()
 		asteroid_p->damage_type_idx_sav = damage_type_add(buf);
 		asteroid_p->damage_type_idx = asteroid_p->damage_type_idx_sav;
 	}
-
-	if (optional_string("$Explosion Effect:")) {
-		asteroid_p->end_particles = particle::util::parseEffect(asteroid_p->name);
-	} else {
-		if(optional_string("$Explosion Animations:")){
-			stuff_fireball_index_list(asteroid_p->explosion_bitmap_anims, asteroid_p->name);
-		}
-		
-		if (optional_string("$Explosion Radius Mult:")) {
-				stuff_float(&asteroid_p->fireball_radius_multiplier);
-		}
+	
+	if(optional_string("$Explosion Animations:")){
+		stuff_fireball_index_list(asteroid_p->explosion_bitmap_anims, asteroid_p->name);
 	}

-	if (optional_string("$Breakup Delay:")) {
-		stuff_float(&asteroid_p->breakup_delay.emplace());
-	}
-
-	if (asteroid_p->end_particles.isValid() && !asteroid_p->breakup_delay.has_value()) {
-		error_display(0, "Asteroid %s has an explosion effect but no breakup delay!", asteroid_p->name);
+	if (optional_string("$Explosion Radius Mult:")) {
+		stuff_float(&asteroid_p->fireball_radius_multiplier);
 	}

 	if (optional_string("$Expl inner rad:")){
@@ -2498,52 +2461,18 @@ static void asteroid_parse_tbl(const char* filename)

 		required_string("#End");

-		if (optional_string("$Impact Explosion Effect:")) {
-			Asteroid_impact_explosion_ani = particle::util::parseEffect();
+		if (optional_string("$Impact Explosion:")) {
+			char impact_ani_file[MAX_FILENAME_LEN];
+			stuff_string(impact_ani_file, F_NAME, MAX_FILENAME_LEN);
+
+			if (VALID_FNAME(impact_ani_file)) {
+				int num_frames;
+				Asteroid_impact_explosion_ani = bm_load_animation(impact_ani_file, &num_frames, nullptr, nullptr, nullptr, true);
+			}
 		}
-		else {
-			char impact_ani_file[MAX_FILENAME_LEN] = {0};
-			float Asteroid_impact_explosion_radius = 0.0f;
-			int num_frames;

-			if (optional_string("$Impact Explosion:")) {
-				stuff_string(impact_ani_file, F_NAME, MAX_FILENAME_LEN);
-			}
-			if (optional_string("$Impact Explosion Radius:")) {
-				stuff_float(&Asteroid_impact_explosion_radius);
-			}
-
-			if(VALID_FNAME(impact_ani_file)) {
-				Asteroid_impact_explosion_ani = particle::ParticleManager::get()->addEffect(particle::ParticleEffect(
-						"", //Name
-						::util::UniformFloatRange(1.f), //Particle num
-						particle::ParticleEffect::Duration::ONETIME, //Single Particle Emission
-						::util::UniformFloatRange(), //No duration
-						::util::UniformFloatRange(-1.f), //Single particle only
-						particle::ParticleEffect::ShapeDirection::ALIGNED, //Particle direction
-						::util::UniformFloatRange(), //Velocity Inherit
-						false, //Velocity Inherit absolute?
-						nullptr, //Velocity volume
-						::util::UniformFloatRange(), //Velocity volume multiplier
-						particle::ParticleEffect::VelocityScaling::NONE, //Velocity directional scaling
-						std::nullopt, //Orientation-based velocity
-						std::nullopt, //Position-based velocity
-						nullptr, //Position volume
-						particle::ParticleEffectHandle::invalid(), //Trail
-						1.f, //Chance
-						false, //Affected by detail
-						-1.f, //Culling range multiplier
-						false, //Disregard Animation Length. Must be true for everything using particle::Anim_bitmap_X
-						false, //Don't reverse animation
-						false, //parent local
-						false, //ignore velocity inherit if parented
-						false, //position velocity inherit absolute?
-						std::nullopt, //Local velocity offset
-						std::nullopt, //Local offset
-						::util::UniformFloatRange(-1.f), //Lifetime
-						::util::UniformFloatRange(Asteroid_impact_explosion_radius), //Radius
-						bm_load_animation(impact_ani_file, &num_frames, nullptr, nullptr, nullptr, true))); //Bitmap
-			}
+		if (optional_string("$Impact Explosion Radius:")) {
+			stuff_float(&Asteroid_impact_explosion_radius);
 		}

 		if (optional_string("$Briefing Icon Closeup Model:")) {
@@ -2578,21 +2507,24 @@ int get_asteroid_index(const char* asteroid_name)
 	return -1;
 }

-// Returns the list of unique asteroid subtype names.
-// List is cached after the first call since Asteroid_info cannot change during an engine instance.
-const SCP_vector<SCP_string>& get_list_valid_asteroid_subtypes()
+// For FRED. Gets a list of unique asteroid subtype names
+SCP_vector<SCP_string> get_list_valid_asteroid_subtypes()
 {
-	static SCP_vector<SCP_string> list;
+	SCP_vector<SCP_string> list;

-	if (list.empty()) {
-		for (const auto& this_asteroid : Asteroid_info) {
-			if (this_asteroid.type != ASTEROID_TYPE_DEBRIS) {
-				for (const auto& subtype : this_asteroid.subtypes) {
-					// Only add unique names
-					if (std::find(list.begin(), list.end(), subtype.type_name) == list.end()) {
-						list.push_back(subtype.type_name);
+	for (const auto& this_asteroid : Asteroid_info) {
+		if (this_asteroid.type != ASTEROID_TYPE_DEBRIS) {
+			for (const auto& subtype : this_asteroid.subtypes) {
+				bool exists = false;
+				for (const auto& entry : list) {
+					if (subtype.type_name == entry) {
+						exists = true;
 					}
 				}
+
+				if (!exists) {
+					list.push_back(subtype.type_name);
+				}
 			}
 		}
 	}
@@ -2600,7 +2532,6 @@ const SCP_vector<SCP_string>& get_list_valid_asteroid_subtypes()
 	return list;
 }

-
 static void verify_asteroid_splits() 
 {
 	
@@ -2621,7 +2552,7 @@ static void verify_asteroid_splits()
 		}

 		// Replace splits with only valid splits
-		Asteroid_info[i].split_info = std::move(splits_t);
+		Asteroid_info[i].split_info = splits_t;
 	}
 }

@@ -2649,11 +2580,6 @@ static void verify_asteroid_list()
 		if (found)
 			continue;

-		if (asteroid_list.empty()) {
-			mprintf(("%s asteroid not found and no fallback available in asteroid_list.\n", asteroid_size[i].c_str()));
-			continue;
-		}
-
 		//Left this as a log print instead of a Warning because of retail-Mjn
 		mprintf(("%s asteroid not found. Using asteroid %s\n", asteroid_size[i].c_str(), asteroid_list[0].name));
 		asteroid_list[0].type = i;
@@ -2696,7 +2622,8 @@ static void verify_asteroid_list()
 */
 void asteroid_init()
 {
-	Asteroid_impact_explosion_ani = particle::ParticleEffectHandle::invalid();
+	Asteroid_impact_explosion_ani = -1;
+	Asteroid_impact_explosion_radius = 20.0;							// retail value
 	Asteroid_icon_closeup_model[0] = '\0';
 	vm_vec_make(&Asteroid_icon_closeup_position, 0.0f, 0.0f, -334.0f);	// magic numbers from retail
 	Asteroid_icon_closeup_zoom = 0.5f;									// magic number from retail
@@ -2708,10 +2635,8 @@ void asteroid_init()
 	parse_modular_table("*-ast.tbm", asteroid_parse_tbl);

 	//No asteroids defined. Bail!
-	if (asteroid_list.empty()) {
-		mprintf(("No asteroids defined in asteroid.tbl or any modular tables. Asteroid fields will not function.\n"));
+	if (asteroid_list.empty())
 		return;
-	}

 	// now verify the asteroids were found and put them in the correct order
 	verify_asteroid_list();
@@ -2719,11 +2644,8 @@ void asteroid_init()
 	// now that Asteroid_info is filled in we can verify the asteroid splits and set their indecies
 	verify_asteroid_splits();

-	if (!Asteroid_impact_explosion_ani.isValid()) {
-		// this will always be missing on a standalone
-		if ( !Is_standalone ) {
-			Error(LOCATION, "Missing valid asteroid impact explosion definition in asteroid.tbl!");
-		}
+	if (Asteroid_impact_explosion_ani == -1) {
+		Error(LOCATION, "Missing valid asteroid impact explosion definition in asteroid.tbl!");
 	}

 	if (Asteroid_icon_closeup_model[0] == '\0')
@@ -16,8 +16,6 @@
 #include "globalincs/pstypes.h"
 #include "object/object_flags.h"
 #include "io/timer.h"
-#include "particle/ParticleSource.h"
-#include "math/vecmat.h"

 class object;
 class polymodel;
@@ -81,9 +79,7 @@ public:
 	float		initial_asteroid_strength;						// starting strength of asteroid
 	SCP_vector< asteroid_split_info > split_info;
 	SCP_vector<int> explosion_bitmap_anims;
-	float fireball_radius_multiplier;						// the model radius is multiplied by this to determine the fireball size
-	particle::ParticleEffectHandle end_particles;
-	std::optional<float> breakup_delay;
+	float		fireball_radius_multiplier;						// the model radius is multiplied by this to determine the fireball size
 	SCP_string	display_name;									// only used for hud targeting display and for debris
 	float		spawn_weight;									// debris only, relative proportion to spawn compared to other types in its asteroid field
 	float		gravity_const;									// multiplier for mission gravity
@@ -94,7 +90,7 @@ public:
 		  rotational_vel_multiplier(1), damage_type_idx(0),
 		  damage_type_idx_sav( -1 ), inner_rad( 0 ), outer_rad( 0 ),
 		  damage( 0 ), blast( 0 ), initial_asteroid_strength( 0 ),
-		  fireball_radius_multiplier( -1 ), end_particles( particle::ParticleEffectHandle::invalid() ), breakup_delay( std::nullopt ), spawn_weight( 1 ), gravity_const( 0 )
+		  fireball_radius_multiplier( -1 ), spawn_weight( 1 ), gravity_const( 0 )
 	{
 		name[ 0 ] = 0;
 		display_name = "";
@@ -134,7 +130,7 @@ typedef enum {
 	FT_PASSIVE
 } field_type_t;

-struct asteroid_field {
+typedef	struct asteroid_field {
 	vec3d	min_bound;					// Minimum range of field.
 	vec3d	max_bound;					// Maximum range of field.
 	float	bound_rad;
@@ -151,24 +147,7 @@ struct asteroid_field {
 	bool            enhanced_visibility_checks;     // if true then range checks are overridden for spawning and wrapping asteroids in the field

 	SCP_vector<SCP_string> target_names;	// default retail behavior is to just throw at the first big ship in the field
-
-	asteroid_field()
-	{
-		num_initial_asteroids = 0; // disable the field by default
-		speed = 0.0f;
-		vm_vec_make(&min_bound, -1000.0f, -1000.0f, -1000.0f);
-		vm_vec_make(&max_bound, 1000.0f, 1000.0f, 1000.0f);
-		vm_vec_make(&inner_min_bound, -500.0f, -500.0f, -500.0f);
-		vm_vec_make(&inner_max_bound, 500.0f, 500.0f, 500.0f);
-		has_inner_bound = false;
-		field_type = FT_ACTIVE;
-		debris_genre = DG_ASTEROID;
-		enhanced_visibility_checks = false;
-		bound_rad = 0.0f;
-		vel = ZERO_VECTOR;
-		// the vectors default-construct to empty
-	}
-};
+} asteroid_field;

 extern SCP_vector< asteroid_info > Asteroid_info;
 extern asteroid Asteroids[MAX_ASTEROIDS];
@@ -200,8 +179,7 @@ void	asteroid_show_brackets();
 void	asteroid_target_closest_danger();
 void asteroid_add_target(object* objp);
 int get_asteroid_index(const char* asteroid_name);
-const SCP_vector<SCP_string>& get_list_valid_asteroid_subtypes();
-int get_asteroid_subtype_index_by_name(const SCP_string& name, int asteroid_idx);
+SCP_vector<SCP_string> get_list_valid_asteroid_subtypes();

 // extern for the lab
 void asteroid_load(int asteroid_info_index, int asteroid_subtype);
@@ -70,7 +70,7 @@ struct bitmap_entry {
 	// Stuff to keep track of usage
 	ubyte preloaded;        //!< If set, then this was loaded from the lst file
 	int   preload_count;    //!< how many times this gets used in game, for unlocking
-	uint  used_flags;       //!< What flags it was accessed thru
+	ushort used_flags;       //!< What flags it was accessed thru
 	int   load_count;

 	bitmap bm;              //!< Bitmap info
@@ -93,15 +93,14 @@ struct bitmap_slot {
 };

 // image specific lock functions
-void bm_lock_ani( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_dds( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_png( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_apng( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_jpg( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_pcx( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_tga( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
-void bm_lock_user( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags, bool convert = true );
-void bm_lock_ktx1(int handle, bitmap_slot* bs, bitmap* bmp, int bpp, uint flags);
+void bm_lock_ani( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_dds( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_png( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_apng( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_jpg( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_pcx( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_tga( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
+void bm_lock_user( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags, bool convert = true );

 const size_t BM_BLOCK_SIZE = 4096;

@@ -13,7 +13,6 @@
 #define WIN32_LEAN_AND_MEAN
 #define BMPMAN_INTERNAL

-#include "globalincs/pstypes.h"
 #include "anim/animplay.h"
 #include "anim/packunpack.h"
 #include "bmpman/bm_internal.h"
@@ -33,7 +32,6 @@
 #include "tgautils/tgautils.h"
 #include "tracing/Monitor.h"
 #include "tracing/tracing.h"
-#include "ktxutils/ktxutils.h"

 #include <cctype>
 #include <climits>
@@ -61,8 +59,8 @@ size_t bm_texture_ram = 0;
 int Bm_paging = 0;

 // Extension type lists
-const BM_TYPE bm_type_list[] = { BM_TYPE_DDS, BM_TYPE_TGA, BM_TYPE_PNG, BM_TYPE_JPG, BM_TYPE_PCX, BM_TYPE_KTX };
-const char* bm_ext_list[] = { ".dds", ".tga", ".png", ".jpg", ".pcx", ".ktx" };
+const BM_TYPE bm_type_list[] = { BM_TYPE_DDS, BM_TYPE_TGA, BM_TYPE_PNG, BM_TYPE_JPG, BM_TYPE_PCX };
+const char *bm_ext_list[] = { ".dds", ".tga", ".png", ".jpg", ".pcx" };
 const int BM_NUM_TYPES = sizeof(bm_type_list) / sizeof(bm_type_list[0]);

 const BM_TYPE bm_ani_type_list[] = { BM_TYPE_EFF, BM_TYPE_ANI, BM_TYPE_PNG };
@@ -84,12 +82,7 @@ static bool bm_inited = false;
 static uint Bm_next_signature = 0x1234;
 static int Bm_low_mem = 0;

-struct bm_lookup_cache_entry {
-	ubyte* data;
-	int width;
-	int height;
-};
-SCP_map<int, bm_lookup_cache_entry> bm_lookup_cache;
+SCP_map<int,ubyte*> bm_lookup_cache;

 /**
 * How much RAM bmpman can use for textures.
@@ -150,31 +143,30 @@ bitmap_slot* bm_get_slot(int handle, bool separate_ani_frames) {
 // Declaration of private functions and templates(declared as static type func(type param);)

 bitmap_lookup::bitmap_lookup(int bitmap_num):
-	Bitmap_data(nullptr),
-	Width(0),
-	Height(0),
-	Num_channels(3)
+	Bitmap_data(NULL)
 {
 	if ( !bm_is_valid(bitmap_num) ) return;

+	Num_channels = 3;
+
 	if ( bm_has_alpha_channel(bitmap_num) ) {
 		Num_channels = 4;
 	}

+	bitmap_entry *be = bm_get_entry(bitmap_num);
+	
+	Width = be->bm.w;
+	Height = be->bm.h;
+
+
 	auto cache_search = bm_lookup_cache.find(bitmap_num);
 	if (cache_search == bm_lookup_cache.end()) {
-		// The texture in graphics memory may be smaller than the bitmap itself, e.g. when mipmap levels
-		// are culled at lower texture detail settings, so the readback reports the dimensions of the
-		// data it actually returns.
-		Bitmap_data = gr_get_bitmap_from_texture(bitmap_num, &Width, &Height);
+		Bitmap_data = (ubyte*)vm_malloc(Width * Height * Num_channels * sizeof(ubyte));

-		if (Bitmap_data != nullptr) {
-			bm_lookup_cache.insert({bitmap_num, {Bitmap_data, Width, Height}});
-		}
+		gr_get_bitmap_from_texture((void*)Bitmap_data, bitmap_num);
+		bm_lookup_cache.insert({bitmap_num, Bitmap_data});
 	} else {
-		Bitmap_data = cache_search->second.data;
-		Width = cache_search->second.width;
-		Height = cache_search->second.height;
+		Bitmap_data = cache_search->second;
 	}
 }

@@ -197,11 +189,6 @@ float bitmap_lookup::get_channel_alpha(float u, float v)
 {
 	Assert( Bitmap_data != NULL );

-	// without an alpha channel there is nothing to look up, and indexing channel 3 would read out of bounds
-	if ( Num_channels < 4 ) {
-		return 1.0f;
-	}
-
 	int x = fl2i(map_texture_address(u) * (Width-1));
 	int y = fl2i(map_texture_address(v) * (Height-1));

@@ -210,7 +197,7 @@ float bitmap_lookup::get_channel_alpha(float u, float v)

 void clear_bm_lookup_cache() {
 	for(auto &iter: bm_lookup_cache) {
-		vm_free(iter.second.data);
+		free(iter.second);
 	}
 	bm_lookup_cache.clear();
 }
@@ -218,7 +205,7 @@ void clear_bm_lookup_cache() {
 /**
 * Converts the bitmap referenced by bmp to the type specified by flags
 */
-static void bm_convert_format(bitmap *bmp, uint flags);
+static void bm_convert_format(bitmap *bmp, ushort flags);

 /**
 * Frees a bitmap's data if it can
@@ -611,8 +598,8 @@ int bm_create_3d(int bpp, int w, int h, int d, void* data) {
 		return -1;

 	// make sure that we have valid data
-	Assertion(data != nullptr, "No valid data received for 3D Bitmap creation!");
 	if (data == nullptr) {
+		UNREACHABLE("No valid data received for 3D Bitmap creation!");
 		return -1;
 	}

@@ -652,7 +639,7 @@ int bm_create_3d(int bpp, int w, int h, int d, void* data) {
 	return n;
 }

-void bm_convert_format(bitmap *bmp, uint flags) {
+void bm_convert_format(bitmap *bmp, ushort flags) {
 	int idx;

 	// no transparency for 24 bpp images
@@ -914,7 +901,7 @@ void bm_get_frame_usage(int *ntotal, int *nnew) {
 #endif
 }

-int bm_get_info(int handle, int *w, int * h, uint* flags, int *nframes, int *fps) {
+int bm_get_info(int handle, int *w, int * h, ushort* flags, int *nframes, int *fps) {
 	bitmap * bmp;

 	if (!bm_inited) return -1;
@@ -1036,13 +1023,6 @@ void bm_init() {
 	bm_inited = true;
 }

-bool bm_is_cubemap(int handle)
-{
-	const BM_TYPE type = bm_get_entry(handle)->comp_type;
-	return type == BM_TYPE_CUBEMAP_DDS || type == BM_TYPE_CUBEMAP_DXT1 || type == BM_TYPE_CUBEMAP_DXT3 ||
-		   type == BM_TYPE_CUBEMAP_DXT5;
-}
-
 int bm_is_compressed(int num) {
 	auto entry = bm_get_entry(num);
 	BM_TYPE type = BM_TYPE_NONE;
@@ -1075,24 +1055,6 @@ int bm_is_compressed(int num) {
 	case BM_TYPE_CUBEMAP_DXT5:
 		return DDS_CUBEMAP_DXT5;

-	case BM_TYPE_ETC2_RGB:
-		return KTX_ETC2_RGB;
-
-	case BM_TYPE_ETC2_SRGB:
-		return KTX_ETC2_SRGB;
-
-	case BM_TYPE_ETC2_RGBA_EAC:
-		return KTX_ETC2_RGBA_EAC;
-
-	case BM_TYPE_ETC2_SRGBA_EAC:
-		return KTX_ETC2_SRGBA_EAC;
-
-	case BM_TYPE_ETC2_RGBA1:
-		return KTX_ETC2_RGB_A1;
-
-	case BM_TYPE_ETC2_SRGBA1:
-		return KTX_ETC2_SRGB_A1;
-
 	default:
 		return 0;
 	}
@@ -1186,16 +1148,6 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int
 			return -1;
 		}
 	}
-	// its a KTX file
-	else if (type == BM_TYPE_KTX) {
-		int ktx_ct;
-		int ktx_error = ktx1_read_header(filename, img_cfp, w, h, bpp, &ktx_ct, mm_lvl, size);
-		if (ktx_error != KTX1_ERROR_NONE) {
-			mprintf(("ktx: could not open '%s'\n", filename));
-			return -1;
-		}
-		*c_type = (BM_TYPE)ktx_ct;
-	}
 	// if its a tga file
 	else if (type == BM_TYPE_TGA) {
 		int tga_error = targa_read_header(filename, img_cfp, w, h, bpp, NULL);
@@ -1229,7 +1181,7 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int
 		}
 	}
 	else {
-		UNREACHABLE("Unknown file type %d specified! This is probably a coding error.", type);
+		UNREACHABLE("Unknown file type specified! This is probably a coding error.");

 		return -1;
 	}
@@ -1409,8 +1361,6 @@ bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int
 		c_type = BM_TYPE_JPG;
 	} else if (!stricmp(NOX("pcx"), ext)) {
 		c_type = BM_TYPE_PCX;
-	} else if (!stricmp(NOX("ktx"), ext)) {
-		c_type = BM_TYPE_KTX;
 	} else {
 		mprintf(("BMPMAN: Unknown file type in EFF parse!\n"));
 		return false;
@@ -1440,7 +1390,7 @@ bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int
 /**
 * Lock an image files data into memory
 */
-static int bm_load_image_data(int handle, int bpp, uint flags, bool nodebug)
+static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
 {
 	BM_TYPE c_type = BM_TYPE_NONE;
 	int true_bpp;
@@ -1532,10 +1482,6 @@ static int bm_load_image_data(int handle, int bpp, uint flags, bool nodebug)
 			bm_lock_user(handle, bs, bmp, true_bpp, flags, false);
 			break;

-		case BM_TYPE_KTX:
-			bm_lock_ktx1(handle, bs, bmp, true_bpp, flags);
-			break;
-
 		default:
 			Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", c_type);
 			return -1;
@@ -1995,7 +1941,7 @@ int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **
 	return -1;
 }

-bitmap * bm_lock(int handle, int bpp, uint flags, bool nodebug) {
+bitmap * bm_lock(int handle, int bpp, ushort flags, bool nodebug) {
 	bitmap			*bmp;

 	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");
@@ -2092,7 +2038,7 @@ bitmap * bm_lock(int handle, int bpp, uint flags, bool nodebug) {
 	return bmp;
 }

-void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, uint flags) {
+void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, ushort flags) {
 	anim				*the_anim;
 	anim_instance	*the_anim_instance;
 	bitmap			*bm;
@@ -2218,7 +2164,7 @@ void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, uint
 }


-void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*flags*/) {
+void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort /*flags*/) {
 	auto be = &bs->entry;
 	int first_frame = be->info.ani.first_frame;
 	auto first_entry = bm_get_entry(first_frame);
@@ -2268,7 +2214,7 @@ void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*
 }


-void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*flags*/) {
+void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /*flags*/) {
 	ubyte *data = NULL;
 	int error;
 	ubyte dds_bpp = 0;
@@ -2332,7 +2278,7 @@ void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*f
 #endif
 }

-void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*flags*/) {
+void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort /*flags*/) {
 	ubyte *data = NULL;
 	int d_size = 0;
 	int jpg_error = JPEG_ERROR_INVALID;
@@ -2379,7 +2325,7 @@ void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*flags
 #endif
 }

-void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags) {
+void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags) {
 	ubyte *data;
 	int pcx_error;
 	char filename[MAX_FILENAME_LEN];
@@ -2424,7 +2370,7 @@ void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags)
 	bm_convert_format(bmp, flags);
 }

-void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*flags*/) {
+void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /*flags*/) {
 	ubyte *data = NULL;
 	//assume 32 bit - libpng should expand everything
 	int d_size;
@@ -2469,7 +2415,7 @@ void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*f
 #endif
 }

-void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags) {
+void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags) {
 	ubyte *data = NULL;
 	int byte_size;
 	char filename[MAX_FILENAME_LEN];
@@ -2528,7 +2474,7 @@ void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags)
 	bm_convert_format(bmp, flags);
 }

-void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags, bool convert) {
+void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags, bool convert) {
 	auto be = &bs->entry;

 	// Unload any existing data
@@ -2821,21 +2767,6 @@ void bm_page_in_texture(int bitmapnum, int nframes) {
 			frame_entry->used_flags = BMP_TEX_CUBEMAP;
 			continue;

-		case BM_TYPE_ETC2_RGB:
-		case BM_TYPE_ETC2_SRGB:
-			frame_entry->used_flags = BMP_TEX_ETC2_RGB8;
-			continue;
-
-		case BM_TYPE_ETC2_RGBA1:
-		case BM_TYPE_ETC2_SRGBA1:
-			frame_entry->used_flags = BMP_TEX_ETC2_RGBA1;
-			continue;
-
-		case BM_TYPE_ETC2_RGBA_EAC:
-		case BM_TYPE_ETC2_SRGBA_EAC:
-			frame_entry->used_flags = BMP_TEX_ETC2_RGBA8;
-			continue;
-
 		default:
 			continue;
 		}
@@ -2881,21 +2812,6 @@ void bm_page_in_xparent_texture(int bitmapnum, int nframes) {
 			entry->used_flags = BMP_TEX_CUBEMAP;
 			continue;

-		case BM_TYPE_ETC2_RGB:
-		case BM_TYPE_ETC2_SRGB:
-			entry->used_flags = BMP_TEX_ETC2_RGB8;
-			continue;
-
-		case BM_TYPE_ETC2_RGBA1:
-		case BM_TYPE_ETC2_SRGBA1:
-			entry->used_flags = BMP_TEX_ETC2_RGBA1;
-			continue;
-
-		case BM_TYPE_ETC2_RGBA_EAC:
-		case BM_TYPE_ETC2_SRGBA_EAC:
-			entry->used_flags = BMP_TEX_ETC2_RGBA8;
-			continue;
-
 		default:
 			continue;
 		}
@@ -3481,67 +3397,38 @@ bool bm_validate_filename(const SCP_string& file, bool single_frame, bool animat
 	}
 	return false;
 }
-
-SDL_Surface* bm_to_sdl_surface(int handle)
-{
+SDL_Surface* bm_to_sdl_surface(int handle) {
 	Assertion(bm_is_valid(handle), "%d is no valid bitmap handle!", handle);

+	int w;
+	int h;
+
+	bm_get_info(handle, &w, &h, nullptr, nullptr);
+	Uint32 rmask, gmask, bmask, amask;
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+	rmask = 0x0000ff00;
+		gmask = 0x00ff0000;
+		bmask = 0xff000000;
+		amask = 0x000000ff;
+#else
+	rmask = 0x00ff0000;
+	gmask = 0x0000ff00;
+	bmask = 0x000000ff;
+	amask = 0xff000000;
+#endif
+
+	SDL_Surface* bitmapSurface = SDL_CreateRGBSurface(0, w, h, 32, rmask, gmask, bmask, amask);
+	if (SDL_LockSurface(bitmapSurface) < 0) {
+		return nullptr;
+	}
 	bitmap* bmp = bm_lock(handle, 32, BMP_TEX_XPARENT);

-	auto bitmapSurface = SDL_CreateSurface(bmp->w, bmp->h, SDL_PIXELFORMAT_BGRA32);
-
-	if (bitmapSurface) {
-		memcpy(bitmapSurface->pixels, reinterpret_cast<void *>(bmp->data),
-			   bmp->w * bmp->h * (bmp->bpp >> 3));
-	}
+	memcpy(bitmapSurface->pixels, reinterpret_cast<void*>(bmp->data), static_cast<size_t>(w * h * 4));

 	bm_unlock(handle);
-	bm_unload(handle);
+	SDL_UnlockSurface(bitmapSurface);

 	return bitmapSurface;

 }
-
-// copied bm_lock_dds and adjusted for ktx. missing BIG_ENDIAN
-void bm_lock_ktx1(int handle, bitmap_slot* bs, bitmap* bmp, int bpp, uint flags)
-{
-	(void)bpp;
-	(void)flags;
-	ubyte* data = nullptr;
-	ubyte ktx_bpp = 0;
-	int ktx_error = KTX1_ERROR_NONE;
-	char filename[MAX_FILENAME_LEN];
-
-	auto be = &bs->entry;
-
-	bm_free_data(bs);
-
-	Assert(be->mem_taken > 0);
-	Assert(&be->bm == bmp);
-
-	data = (ubyte*)bm_malloc(handle, be->mem_taken);
-	if (!data)
-		return;
-	memset(data, 0, be->mem_taken);
-
-	// make sure we are using the correct filename in the case of an EFF.
-	// this will populate filename[] whether it's EFF or not
-	EFF_FILENAME_CHECK;
-
-	ktx_error = ktx1_read_bitmap(filename, data, &ktx_bpp);
-
-	if (ktx_error != KTX1_ERROR_NONE) 
-	{
-		mprintf(("KTX: read_bitmap error=%d file='%s'\n", ktx_error, filename));
-		bm_free_data(bs);
-		return;
-	}
-
-	bmp->bpp = ktx_bpp;
-	bmp->data = (ptr_u)data;
-	bmp->flags = 0;
-
-#ifdef BMPMAN_NDEBUG
-	Assert(be->data_size > 0);
-#endif
-}
@@ -34,7 +34,6 @@

 // Flag positions for bitmap.flags
 // ***** NOTE:  bitmap.flags is an 8-bit value, no more BMP_TEX_* flags can be added unless the type is changed!! ******
-// Update: bitmap.flags type changed to 16-bit
 #define	BMP_AABITMAP        (1<<0)      //!< antialiased bitmap
 #define	BMP_TEX_XPARENT     (1<<1)      //!< transparent texture
 #define	BMP_TEX_OTHER       (1<<2)      //!< so we can identify all "normal" textures
@@ -44,14 +43,9 @@
 #define BMP_TEX_BC7			(1<<6)		//!< BC7  compressed 8r8g8b8a (32bit)
 #define BMP_TEX_CUBEMAP     (1<<7)      //!< a texture made for cubic environment map
 #define BMP_MASK_BITMAP     (1<<8)      //!< a bitmap that will be used for masking mouse interaction. Typically not used in render operations
-#define BMP_TEX_ETC2_RGB8	(1 << 9)	//!< ETC2 RGB compressed	(24bit, no alpha)
-#define BMP_TEX_ETC2_RGBA1	(1 << 10)	//!< ETC2 RGBA1 compressed	(24bit, 1 alpha)
-#define BMP_TEX_ETC2_RGBA8	(1 << 11)	//!< ETC2 RGBA8 compressed	(32bit, 8 alpha)
-

 // Combined flags
-#define BMP_TEX_COMP		( BMP_TEX_DXT1 | BMP_TEX_DXT3 | BMP_TEX_DXT5 | BMP_TEX_BC7 | BMP_TEX_ETC2_RGB8 |\
-							  BMP_TEX_ETC2_RGBA1 | BMP_TEX_ETC2_RGBA8 )		//!< Compressed textures
+#define BMP_TEX_COMP        ( BMP_TEX_DXT1 | BMP_TEX_DXT3 | BMP_TEX_DXT5 | BMP_TEX_BC7 )  //!< Compressed textures
 #define BMP_TEX_NONCOMP     ( BMP_TEX_XPARENT | BMP_TEX_OTHER )             //!< Non-compressed textures
 #define	BMP_TEX_ANY         ( BMP_TEX_COMP | BMP_TEX_NONCOMP )              //!< Any texture

@@ -87,15 +81,7 @@ enum BM_TYPE
 	BM_TYPE_CUBEMAP_DXT3,   //!< 32-bit cubemap        (compressed cubemap surface)
 	BM_TYPE_CUBEMAP_DXT5,    //!< 32-bit cubemap        (compressed cubemap surface)

-	BM_TYPE_3D,				//!< 3D in-memory
-
-	BM_TYPE_KTX,			//!< generic identifier for KTX1
-	BM_TYPE_ETC2_RGB,		//!< 24 bit, no alpha
-	BM_TYPE_ETC2_SRGB,      //!< 24 bit, no alpha, signed
-	BM_TYPE_ETC2_RGBA1,		//!< 24 bit, 1 bit alpha
-	BM_TYPE_ETC2_SRGBA1,    //!< 24 bit, 1 bit alpha, signed
-	BM_TYPE_ETC2_RGBA_EAC,	//!< 32 bit, 8 bit alpha
-	BM_TYPE_ETC2_SRGBA_EAC  //!< 32 bit, 8 bit alpha, signed
+	BM_TYPE_3D				//!< 3D in-memory
 };

 /**
@@ -110,7 +96,7 @@ struct bitmap
 	short	rowsize;    //!< What you need to add to go to next row
 	int	bpp;        //!< Requested bitdepth of each pixel. ( 7, 8, 15, 16, 24, 32)
 	int	true_bpp;   //!< The image's actual bitdepth
-	uint	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
+	ushort	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
 	ptr_u	data;       //!< Pointer to data, or maybe offset into VRAM.
 	ubyte *palette;     /**< @brief   Pointer to this bitmap's palette (if it has one).
 	                     *   @details If BMP_NO_PALETTE_MAP flag is cleared, this palette just points to the screen palette. (gr_palette)
@@ -149,7 +135,6 @@ void bm_close();
 #define BMP_FLAG_RENDER_TARGET_DYNAMIC		(1<<1)
 #define BMP_FLAG_CUBEMAP					(1<<2)
 #define BMP_FLAG_RENDER_TARGET_MIPMAP		(1<<3)
-#define BMP_FLAG_RENDER_TARGET_DEPTH_ATTACHMENT	(1<<4)

 /**
 * @brief Allocates memory for the given handle.
@@ -359,7 +344,7 @@ int bm_load_either(const char *filename, int *nframes = NULL, int *fps = NULL, i
 * @returns A pointer to the bitmap that's valid until bm_unlock is called if successful, or
 * @returns NULL if unsuccessful
 */
-bitmap* bm_lock(int handle, int bpp, uint flags, bool nodebug = false);
+bitmap* bm_lock(int handle, int bpp, ushort flags, bool nodebug = false);

 /**
 * @brief Returns the image type of the given bitmap handle
@@ -402,7 +387,7 @@ int bm_is_valid(int handle);
 * @returns The handle to the first frame on success, or
 * @returns -1 on failure
 */
-int bm_get_info(int handle, int *w = nullptr, int * h = nullptr, uint* flags = nullptr, int *nframes = nullptr, int *fps = nullptr);
+int bm_get_info(int handle, int *w = nullptr, int * h = nullptr, ushort* flags = nullptr, int *nframes = nullptr, int *fps = nullptr);

 /**
 * @brief Gets 3D info on the bitmap indexed by handle.
@@ -594,14 +579,6 @@ void bm_get_components(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
 */
 int bm_is_compressed(int handle);

-/**
- * @brief Returns true if the bitmap indexed by handle was loaded from a cubemap image file
- *
- * @note Render targets return false, even cubemap ones, and so do BC7 (DX10) DDS cubemaps, whose cube flag the DDS
- * loader does not keep
- */
-bool bm_is_cubemap(int handle);
-
 /**
 * @brief Gets the correct TCACHE_TYPE for compressed graphics (uncompressed are assumed TCACHE_TYPE_NORMAL)
 */
@@ -56,10 +56,6 @@ APPLY_TO_FOV_T(-, sub)

 // Used to set the default value for in-game options
 static float fov_default = DEFAULT_FOV;
-static float cockpit_fov_default = DEFAULT_FOV;
-static bool cockpit_fov_toggle_default = false;
-
-bool Use_cockpit_fov = false;

 static SCP_string fov_display(float val)
 {
@@ -77,22 +73,6 @@ static void parse_fov_func()
 	fov_default = value;
 }

-static void parse_cockpit_fov_func()
-{
-	float value;
-	stuff_float(&value);
-	CLAMP(value, 0.436332f, 1.5708f);
-	cockpit_fov_default = value;
-}
-
-static void parse_cockpit_fov_toggle_func()
-{
-	bool value;
-	stuff_boolean(&value);
-	cockpit_fov_toggle_default = value;
-}
-
-// coverity[GLOBAL_INIT_ORDER] -- safe; OptionBuilder::finish() uses Meyers singleton
 auto FovOption = options::OptionBuilder<float>("Graphics.FOV",
 					 std::pair<const char*, int>{"Field Of View", 1703},
 					 std::pair<const char*, int>{"The vertical field of view", 1704})
@@ -109,42 +89,41 @@ auto FovOption = options::OptionBuilder<float>("Graphics.FOV",
 					 .parser(parse_fov_func)
 					 .finish();

-// coverity[GLOBAL_INIT_ORDER] -- safe; OptionBuilder::finish() uses Meyers singleton
+bool Use_cockpit_fov = false;
+
+auto CockpitFOVToggleOption = options::OptionBuilder<bool>("Graphics.CockpitFOVToggle",
+					 std::pair<const char*, int>{"Cockpit FOV Toggle", 1838},
+					 std::pair<const char*, int>{"Whether or not to use a different FOV for cockpit rendering from normal rendering", 1839})
+					 .category(std::make_pair("Graphics", 1825))
+					 .default_val(false)
+					 .change_listener([](bool val, bool) {
+					      if (!val) {
+					           COCKPIT_ZOOM_DEFAULT = VIEWER_ZOOM_DEFAULT;
+					      }
+					      return true; // This option will always persist so we never return false
+					 })
+					 .level(options::ExpertLevel::Advanced)
+					 .bind_to(&Use_cockpit_fov)
+					 .importance(61)
+					 .finish();
+
 auto CockpitFovOption = options::OptionBuilder<float>("Graphics.CockpitFOV",
 					 std::pair<const char*, int>{"Cockpit Field Of View", 1840},
 					 std::pair<const char*, int>{"The vertical field of view for cockpit rendering. Only works if cockpits are active and cockpit FOV toggle is turned on.", 1841})
 					 .category(std::make_pair("Graphics", 1825))
 					 .range(0.436332f, 1.5708f)
 					 .change_listener([](const float& val, bool) {
-					      // Graphics.CockpitFOVToggle has its own listener that re-applies this value, so the
-					      // result is the same whichever of the two options the manager happens to load first.
-					      COCKPIT_ZOOM_DEFAULT = Use_cockpit_fov ? fov_t(val) : VIEWER_ZOOM_DEFAULT;
+					      if (Use_cockpit_fov){
+					           COCKPIT_ZOOM_DEFAULT = val;
+						  } else {
+							  COCKPIT_ZOOM_DEFAULT = VIEWER_ZOOM_DEFAULT;
+						  }
 					      return true;
 					 })
 					 .display(fov_display)
-					 .default_func([]() { return cockpit_fov_default; })
+					 .default_val(fov_default)
 					 .level(options::ExpertLevel::Advanced)
 					 .importance(62)
-					 .parser(parse_cockpit_fov_func)
-					 .finish();
-
-// coverity[GLOBAL_INIT_ORDER] -- safe; OptionBuilder::finish() uses Meyers singleton
-auto CockpitFOVToggleOption = options::OptionBuilder<bool>("Graphics.CockpitFOVToggle",
-					 std::pair<const char*, int>{"Cockpit FOV Toggle", 1838},
-					 std::pair<const char*, int>{"Whether or not to use a different FOV for cockpit rendering from normal rendering", 1839})
-					 .category(std::make_pair("Graphics", 1825))
-					 .default_func([]() {return cockpit_fov_toggle_default;})
-					 // This does the work of bind_to(&Use_cockpit_fov) and then re-applies Graphics.CockpitFOV,
-					 // because that option's listener needs Use_cockpit_fov to already hold its final value.
-					 // Doing it here makes the pair of options independent of the order the manager loads them in.
-					 .change_listener([](bool val, bool) {
-					      Use_cockpit_fov = val;
-					      COCKPIT_ZOOM_DEFAULT = val ? fov_t(CockpitFovOption->getValue()) : VIEWER_ZOOM_DEFAULT;
-					      return true; // This option will always persist so we never return false
-					 })
-					 .level(options::ExpertLevel::Advanced)
-					 .importance(61)
-					 .parser(parse_cockpit_fov_toggle_func)
 					 .finish();

 //*************************CLASS: camera*************************
@@ -753,7 +732,6 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 		text_buf = in_text;
 		sexp_replace_variable_names_with_values(text_buf);
 		sexp_container_replace_refs_with_values(text_buf);
-		// (message_translate_tokens is called when the subtitle is queued, so does not need to be called here)
 		in_text = text_buf.c_str();
 	}

@@ -1316,9 +1294,6 @@ float cam_get_bbox_dist(const object* viewer_obj, float preferred_distance, cons
 		return preferred_distance;
 	
 	polymodel* pm = object_get_model(viewer_obj);
-	if (pm == nullptr)
-		return preferred_distance;
-
 	vec3d adjusted_bbox;
 	const vec3d* cam_vec = &cam_orient->vec.fvec;

@@ -1,609 +0,0 @@
-#include "freespace.h"
-
-#include "actions/Action.h"
-#include "camera/camera.h"
-#include "camera/photomode.h"
-#include "controlconfig/controlsconfig.h"
-#include "debugconsole/console.h"
-#include "globalincs/alphacolors.h"
-#include "graphics/2d.h"
-#include "graphics/font.h"
-#include "hud/hud.h"
-#include "io/keycontrol.h"
-#include "localization/localize.h"
-#include "mission/missionmessage.h"
-#include "object/object.h"
-#include "parse/parselo.h"
-#include "playerman/player.h"
-#include "render/3d.h"
-#include "scripting/global_hooks.h"
-#include "sound/audiostr.h"
-
-bool Photo_mode_active = false;
-camid Photo_mode_id;
-fix Photo_mode_saved_time_compression = F1_0;
-bool Photo_mode_saved_lock_state = false;
-bool Photo_mode_screenshot_queued_this_frame = false;
-bool Photo_mode_allowed = true;
-bool Photo_mode_audio_paused = false;
-
-const float Photo_mode_turn_rate = PI_2; // radians/sec
-constexpr float Photo_mode_move_speed = 90.0f;
-constexpr float Photo_mode_boost_multiplier = 6.0f;
-constexpr float Photo_mode_time_compression = 0.01f;
-
-struct photo_mode_post_effect_state {
-	SCP_string name;
-	float intensity = 0.0f;
-	vec3d rgb = vmd_zero_vector;
-	int effect_idx = -1; // index into Post_processing_manager->getPostEffects()
-};
-
-enum class photo_mode_param_type {
-	INT_RANGE,  // adjustable integer value with min/max
-	BOOL_TOGGLE // on/off toggle
-};
-
-enum class photo_mode_param_role {
-	NONE,
-	GRID_OVERLAY, // bool toggle that enables the rule of thirds grid
-	POST_EFFECT   // drives a post processing effect by name
-};
-
-struct photo_mode_param {
-	const char*           label;    // display name
-	int                   xstr_id;  // XSTR localization ID
-	photo_mode_param_type type;
-	photo_mode_param_role role;
-
-	// For POST_EFFECT role: post processing effect name, range, and values
-	const char* effect_name;   // post processing effect to control (nullptr if role != POST_EFFECT)
-	int         effect_idx;    // index into Post_processing_manager->getPostEffects() (-1 if unresolved)
-	int         min_val;
-	int         max_val;
-	int         value;
-	int         saved_value;
-
-	// For BOOL_TOGGLE
-	bool        bool_value;
-};
-
-// Parameter definitions
-SCP_vector<photo_mode_param> Photo_mode_params = {
-	{"Grid",       1906, photo_mode_param_type::BOOL_TOGGLE, photo_mode_param_role::GRID_OVERLAY, nullptr,      -1, 0, 0,   0,   0,   false},
-	{"Saturation", 1903, photo_mode_param_type::INT_RANGE,   photo_mode_param_role::POST_EFFECT,  "saturation", -1, 0, 200, 100, 100, false},
-	{"Brightness", 1904, photo_mode_param_type::INT_RANGE,   photo_mode_param_role::POST_EFFECT,  "brightness", -1, 0, 200, 100, 100, false},
-	{"Contrast",   1905, photo_mode_param_type::INT_RANGE,   photo_mode_param_role::POST_EFFECT,  "contrast",   -1, 0, 200, 100, 100, false},
-};
-
-SCP_vector<photo_mode_post_effect_state> Photo_mode_saved_post_effects;
-int Photo_mode_selected_parameter = 0;
-int Photo_mode_panel_width = 0;
-int Photo_mode_panel_padding_w = 0;
-
-void photo_mode_capture_post_effect_state()
-{
-	Photo_mode_saved_post_effects.clear();
-
-	if (graphics::Post_processing_manager == nullptr) {
-		return;
-	}
-
-	const auto& post_effects = graphics::Post_processing_manager->getPostEffects();
-	Photo_mode_saved_post_effects.reserve(post_effects.size());
-
-	for (int i = 0; i < static_cast<int>(post_effects.size()); ++i) {
-		const auto& effect = post_effects[i];
-		photo_mode_post_effect_state state;
-		state.name = effect.name;
-		state.intensity = effect.intensity;
-		state.rgb = effect.rgb;
-		state.effect_idx = i;
-		Photo_mode_saved_post_effects.push_back(state);
-	}
-
-	// Resolve effect indices for each param.
-	// Done once here rather than on every frame or every key press.
-	for (auto& param : Photo_mode_params) {
-		if (param.role != photo_mode_param_role::POST_EFFECT) {
-			param.effect_idx = -1;
-			continue;
-		}
-		param.effect_idx = -1;
-		for (int j = 0; j < static_cast<int>(post_effects.size()); ++j) {
-			if (!stricmp(post_effects[j].name.c_str(), param.effect_name)) {
-				param.effect_idx = j;
-				break;
-			}
-		}
-	}
-}
-
-void photo_mode_apply_saved_post_effect_state(bool clear_saved_state)
-{
-	if (graphics::Post_processing_manager == nullptr) {
-		if (clear_saved_state) {
-			Photo_mode_saved_post_effects.clear();
-		}
-		return;
-	}
-
-	const auto& post_effects = graphics::Post_processing_manager->getPostEffects();
-	for (const auto& saved_state : Photo_mode_saved_post_effects) {
-		if (saved_state.effect_idx < 0 || saved_state.effect_idx >= static_cast<int>(post_effects.size())) {
-			continue;
-		}
-		const auto& effect = post_effects[saved_state.effect_idx];
-		const int value = static_cast<int>(std::lround((saved_state.intensity - effect.add) * effect.div));
-		gr_post_process_set_effect(saved_state.name.c_str(), value, &saved_state.rgb);
-	}
-
-	if (clear_saved_state) {
-		Photo_mode_saved_post_effects.clear();
-	}
-}
-
-int photo_mode_get_saved_post_effect_value(int effect_idx)
-{
-	int value = 100;
-
-	if (effect_idx < 0 || graphics::Post_processing_manager == nullptr) {
-		return value;
-	}
-
-	const auto& post_effects = graphics::Post_processing_manager->getPostEffects();
-	if (effect_idx >= static_cast<int>(post_effects.size())) {
-		return value;
-	}
-
-	for (const auto& saved_state : Photo_mode_saved_post_effects) {
-		if (saved_state.effect_idx != effect_idx) {
-			continue;
-		}
-		const auto& effect = post_effects[effect_idx];
-		value = static_cast<int>(std::lround((saved_state.intensity - effect.add) * effect.div));
-		break;
-	}
-
-	return value;
-}
-
-void photo_mode_sync_parameter_values_from_saved_state()
-{
-	for (auto& param : Photo_mode_params) {
-		if (param.role == photo_mode_param_role::POST_EFFECT) {
-			param.saved_value = photo_mode_get_saved_post_effect_value(param.effect_idx);
-			param.value = param.saved_value;
-		} else if (param.type == photo_mode_param_type::BOOL_TOGGLE) {
-			param.bool_value = false;
-		}
-	}
-
-	Photo_mode_selected_parameter = 0;
-}
-
-void photo_mode_apply_parameter_values()
-{
-	for (const auto& param : Photo_mode_params) {
-		if (param.role == photo_mode_param_role::POST_EFFECT) {
-			gr_post_process_set_effect(param.effect_name, param.value, nullptr);
-		}
-	}
-}
-
-SCP_string format_photo_mode_keybind(int action)
-{
-	auto primary = Control_config[action].first.textify();
-	auto secondary = Control_config[action].second.textify();
-
-	if (primary.empty() && secondary.empty()) {
-		return XSTR("Unbound", 1907);
-	}
-	if (primary.empty()) {
-		return secondary;
-	}
-	if (secondary.empty()) {
-		return primary;
-	}
-
-	return primary + " / " + secondary;
-}
-
-void photo_mode_compute_hud_layout()
-{
-	const auto old_font = font::get_current_fontnum();
-	font::set_font(font::FONT1);
-
-	int max_text_width = 0;
-	char buf[512];
-	auto measure = [&](const char* text) {
-		int w = 0;
-		gr_get_string_size(&w, nullptr, text);
-		if (w > max_text_width) max_text_width = w;
-	};
-
-	// Find the longest string
-	measure(XSTR("Photo Mode", 1892));
-	measure(XSTR("Controls", 1893));
-	measure(XSTR("Status", 1900));
-	measure(XSTR("Effects", 1914));
-	snprintf(buf, sizeof(buf), XSTR("Toggle: %s", 1894),             format_photo_mode_keybind(TOGGLE_PHOTO_MODE).c_str());
-	measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Previous Filter: %s", 1895),    format_photo_mode_keybind(PHOTO_MODE_FILTER_PREV).c_str());
-	measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Next Filter: %s", 1896),        format_photo_mode_keybind(PHOTO_MODE_FILTER_NEXT).c_str());
-	measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Reset Filters: %s", 1897),      format_photo_mode_keybind(PHOTO_MODE_FILTER_RESET).c_str());
-	measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Decrease Parameter: %s", 1898), format_photo_mode_keybind(PHOTO_MODE_PARAM_DECREASE).c_str());
-	measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Increase Parameter: %s", 1899), format_photo_mode_keybind(PHOTO_MODE_PARAM_INCREASE).c_str());
-	measure(buf);
-
-	// Use worst case placeholder values for the dynamic status strings so the
-	// panel width stays stable as these change during a session.
-	snprintf(buf, sizeof(buf), XSTR("Time Compression: %.2fx", 1901), 64.0f);                          measure(buf);
-	snprintf(buf, sizeof(buf), XSTR("Cam Pos: X %.1f  Y %.1f  Z %.1f", 1902), -99999.9f, -99999.9f, -99999.9f); measure(buf);
-
-	for (const auto& param : Photo_mode_params) {
-		if (param.type == photo_mode_param_type::INT_RANGE) {
-			snprintf(buf, sizeof(buf), "%s: %d", XSTR(param.label, param.xstr_id), param.max_val);
-		} else {
-			snprintf(buf, sizeof(buf), "%s: %s", XSTR(param.label, param.xstr_id), XSTR("Off", 1286));
-		}
-		measure(buf);
-	}
-
-	font::set_font(old_font);
-
-	Photo_mode_panel_padding_w = max_text_width / 10;
-	Photo_mode_panel_width     = max_text_width + Photo_mode_panel_padding_w * 2;
-}
-
-void photo_mode_set_active(bool active)
-{
-	if (active == Photo_mode_active) {
-		return;
-	}
-
-	if (active) {
-		if (!Photo_mode_allowed) {
-			return;
-		}
-
-		if ((Game_mode & GM_MULTIPLAYER) != 0 || Player_obj == nullptr || !(Game_mode & GM_IN_MISSION)) {
-			return;
-		}
-
-		if (Time_compression_locked) {
-			return;
-		}
-
-		if (Player_obj->type != OBJ_SHIP) {
-			return;
-		}
-
-		Photo_mode_saved_time_compression = Game_time_compression;
-		Photo_mode_saved_lock_state = Time_compression_locked;
-
-		Photo_mode_id = cam_create("Photo Mode", &Eye_position, &Eye_matrix);
-		if (!Photo_mode_id.isValid() || !cam_set_camera(Photo_mode_id)) {
-			cam_delete(Photo_mode_id);
-			Photo_mode_id = camid();
-			return;
-		}
-
-		set_time_compression(Photo_mode_time_compression, 0.0f);
-		lock_time_compression(true);
-
-		photo_mode_capture_post_effect_state();
-		photo_mode_sync_parameter_values_from_saved_state();
-		photo_mode_apply_parameter_values();
-		photo_mode_compute_hud_layout();
-
-		audiostream_pause_all();
-		message_pause_all();
-		Photo_mode_audio_paused = true;
-
-		Photo_mode_active = true;
-		mprintf(("Photo Mode enabled.\n"));
-
-		if (scripting::hooks::OnPhotoModeStarted->isActive()) {
-			scripting::hooks::OnPhotoModeStarted->run();
-		}
-		return;
-	}
-
-	cam_reset_camera();
-	cam_delete(Photo_mode_id);
-	Photo_mode_id = camid();
-
-	set_time_compression(f2fl(Photo_mode_saved_time_compression), 0.0f);
-	lock_time_compression(Photo_mode_saved_lock_state);
-
-	if (Photo_mode_audio_paused) {
-		audiostream_unpause_all();
-		message_resume_all();
-		Photo_mode_audio_paused = false;
-	}
-
-	photo_mode_apply_saved_post_effect_state(true);
-	for (auto& param : Photo_mode_params) {
-		if (param.type == photo_mode_param_type::INT_RANGE) {
-			param.value = 100;
-			param.saved_value = 100;
-		} else if (param.type == photo_mode_param_type::BOOL_TOGGLE) {
-			param.bool_value = false;
-		}
-	}
-	Photo_mode_selected_parameter = 0;
-
-	Photo_mode_active = false;
-	mprintf(("Photo Mode disabled.\n"));
-
-	if (scripting::hooks::OnPhotoModeEnded->isActive()) {
-		scripting::hooks::OnPhotoModeEnded->run();
-	}
-}
-
-void photo_mode_do_frame(float frame_time)
-{
-	if (!Photo_mode_active || !Photo_mode_id.isValid()) {
-		return;
-	}
-
-	if (!Photo_mode_allowed) {
-		photo_mode_set_active(false);
-		return;
-	}
-
-	auto photo_mode = Photo_mode_id.getCamera();
-	if (photo_mode == nullptr) {
-		photo_mode_set_active(false);
-		return;
-	}
-
-	vec3d cam_pos = vmd_zero_vector;
-	matrix cam_orient = vmd_identity_matrix;
-	photo_mode->get_info(&cam_pos, &cam_orient);
-
-	angles delta_angles{};
-	float pitch = check_control_timef(PITCH_FORWARD) - check_control_timef(PITCH_BACK);
-	float heading = check_control_timef(YAW_RIGHT) - check_control_timef(YAW_LEFT);
-	float bank = check_control_timef(BANK_LEFT) - check_control_timef(BANK_RIGHT);
-
-	int axis[Action::NUM_VALUES] = {0};
-	control_get_axes_readings(axis, flRealframetime);
-	pitch += -f2fl(axis[Action::PITCH]);
-	heading += f2fl(axis[Action::HEADING]);
-	bank -= f2fl(axis[Action::BANK]);
-
-	CLAMP(pitch, -1.0f, 1.0f);
-	CLAMP(heading, -1.0f, 1.0f);
-	CLAMP(bank, -1.0f, 1.0f);
-
-	delta_angles.p = pitch * Photo_mode_turn_rate * frame_time;
-	delta_angles.h = heading * Photo_mode_turn_rate * frame_time;
-	delta_angles.b = bank * Photo_mode_turn_rate * frame_time;
-
-	matrix delta_orient = vmd_identity_matrix;
-	vm_angles_2_matrix(&delta_orient, &delta_angles);
-	vm_matrix_x_matrix(&cam_orient, &cam_orient, &delta_orient);
-	vm_fix_matrix(&cam_orient);
-
-	float speed = Photo_mode_move_speed;
-	if (check_control(AFTERBURNER)) {
-		speed *= Photo_mode_boost_multiplier;
-	}
-
-	float forward = check_control_timef(FORWARD_THRUST) - check_control_timef(REVERSE_THRUST);
-	float right = check_control_timef(RIGHT_SLIDE_THRUST) - check_control_timef(LEFT_SLIDE_THRUST);
-	float up = check_control_timef(UP_SLIDE_THRUST) - check_control_timef(DOWN_SLIDE_THRUST);
-
-	CLAMP(forward, -1.0f, 1.0f);
-	CLAMP(right, -1.0f, 1.0f);
-	CLAMP(up, -1.0f, 1.0f);
-
-	vm_vec_scale_add2(&cam_pos, &cam_orient.vec.fvec, forward * speed * frame_time);
-	vm_vec_scale_add2(&cam_pos, &cam_orient.vec.rvec, right * speed * frame_time);
-	vm_vec_scale_add2(&cam_pos, &cam_orient.vec.uvec, up * speed * frame_time);
-
-	photo_mode->set_rotation(&cam_orient);
-	photo_mode->set_position(&cam_pos);
-}
-
-void photo_mode_maybe_render_hud()
-{
-	if (!Photo_mode_active || Photo_mode_screenshot_queued_this_frame || gr_is_screenshot_requested()) {
-		return;
-	}
-
-	if (!Photo_mode_allowed) {
-		photo_mode_set_active(false);
-		return;
-	}
-
-	auto photo_mode = Photo_mode_id.getCamera();
-	if (photo_mode == nullptr) {
-		return;
-	}
-
-	vec3d cam_pos = vmd_zero_vector;
-	matrix cam_orient = vmd_identity_matrix;
-	photo_mode->get_info(&cam_pos, &cam_orient);
-
-	const auto toggle_keybind = format_photo_mode_keybind(TOGGLE_PHOTO_MODE);
-	const auto prev_filter_keybind = format_photo_mode_keybind(PHOTO_MODE_FILTER_PREV);
-	const auto next_filter_keybind = format_photo_mode_keybind(PHOTO_MODE_FILTER_NEXT);
-	const auto reset_filter_keybind = format_photo_mode_keybind(PHOTO_MODE_FILTER_RESET);
-	const auto decrease_param_keybind = format_photo_mode_keybind(PHOTO_MODE_PARAM_DECREASE);
-	const auto increase_param_keybind = format_photo_mode_keybind(PHOTO_MODE_PARAM_INCREASE);
-	gr_set_color_fast(&Color_silver);
-	const auto old_font = font::get_current_fontnum();
-	font::set_font(font::FONT1);
-	const int line_height     = gr_get_font_height();
-	const int num_param_lines = static_cast<int>(Photo_mode_params.size());
-	const int panel_padding_h = line_height / 2;
-	const int panel_padding_w = Photo_mode_panel_padding_w;
-	const int panel_width     = Photo_mode_panel_width;
-	const int panel_height    = panel_padding_h * 2 + line_height * (15 + num_param_lines);
-	const int panel_x = gr_screen.center_offset_x + (gr_screen.center_w / 4);
-	const int panel_y = gr_screen.center_offset_y + gr_screen.center_h - panel_height - (gr_screen.center_h / 6);
-
-	gr_line(panel_x, panel_y, panel_x + panel_width, panel_y, GR_RESIZE_NONE);
-	gr_line(panel_x, panel_y + panel_height, panel_x + panel_width, panel_y + panel_height, GR_RESIZE_NONE);
-	gr_line(panel_x, panel_y, panel_x, panel_y + panel_height, GR_RESIZE_NONE);
-	gr_line(panel_x + panel_width, panel_y, panel_x + panel_width, panel_y + panel_height, GR_RESIZE_NONE);
-	gr_line(panel_x,
-		panel_y + line_height + panel_padding_h + 1,
-		panel_x + panel_width,
-		panel_y + line_height + panel_padding_h + 1,
-		GR_RESIZE_NONE);
-
-	bool grid_enabled = false;
-	for (const auto& param : Photo_mode_params) {
-		if (param.role == photo_mode_param_role::GRID_OVERLAY) {
-			grid_enabled = param.bool_value;
-			break;
-		}
-	}
-
-	if (grid_enabled) {
-		const int x1 = gr_screen.center_offset_x + gr_screen.center_w / 3;
-		const int x2 = gr_screen.center_offset_x + (gr_screen.center_w * 2) / 3;
-		const int y1 = gr_screen.center_offset_y + gr_screen.center_h / 3;
-		const int y2 = gr_screen.center_offset_y + (gr_screen.center_h * 2) / 3;
-		gr_line(x1, gr_screen.center_offset_y, x1, gr_screen.center_offset_y + gr_screen.center_h, GR_RESIZE_NONE);
-		gr_line(x2, gr_screen.center_offset_y, x2, gr_screen.center_offset_y + gr_screen.center_h, GR_RESIZE_NONE);
-		gr_line(gr_screen.center_offset_x, y1, gr_screen.center_offset_x + gr_screen.center_w, y1, GR_RESIZE_NONE);
-		gr_line(gr_screen.center_offset_x, y2, gr_screen.center_offset_x + gr_screen.center_w, y2, GR_RESIZE_NONE);
-	}
-
-	int line = panel_y + panel_padding_h;
-	const int text_x = panel_x + panel_padding_w;
-	gr_printf_no_resize(text_x, line, "%s", XSTR("Photo Mode", 1892));
-	line += line_height;
-	line += line_height;
-	gr_printf_no_resize(text_x, line, "%s", XSTR("Controls", 1893));
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Toggle: %s", 1894), toggle_keybind.c_str());
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Previous Filter: %s", 1895), prev_filter_keybind.c_str());
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Next Filter: %s", 1896), next_filter_keybind.c_str());
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Reset Filters: %s", 1897), reset_filter_keybind.c_str());
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Decrease Parameter: %s", 1898), decrease_param_keybind.c_str());
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Increase Parameter: %s", 1899), increase_param_keybind.c_str());
-	line += line_height;
-	line += line_height;
-	gr_printf_no_resize(text_x, line, "%s", XSTR("Status", 1900));
-	line += line_height;
-	gr_printf_no_resize(text_x, line, XSTR("Time Compression: %.2fx", 1901), f2fl(Game_time_compression));
-	line += line_height;
-	gr_printf_no_resize(text_x,
-		line,
-		XSTR("Cam Pos: X %.1f  Y %.1f  Z %.1f", 1902),
-		cam_pos.xyz.x,
-		cam_pos.xyz.y,
-		cam_pos.xyz.z);
-	line += line_height;
-	line += line_height;
-	gr_set_color_fast(&Color_silver);
-	gr_printf_no_resize(text_x, line, "%s", XSTR("Effects", 1914));
-	line += line_height;
-	for (int i = 0; i < static_cast<int>(Photo_mode_params.size()); ++i) {
-		const auto& param = Photo_mode_params[i];
-		gr_set_color_fast(Photo_mode_selected_parameter == i ? &Color_bright_white : &Color_silver);
-
-		if (param.type == photo_mode_param_type::INT_RANGE) {
-			gr_printf_no_resize(text_x, line, "%s: %d", XSTR(param.label, param.xstr_id), param.value);
-		} else if (param.type == photo_mode_param_type::BOOL_TOGGLE) {
-			gr_printf_no_resize(text_x, line, "%s: %s", XSTR(param.label, param.xstr_id),
-				param.bool_value ? XSTR("On", 1285) : XSTR("Off", 1286));
-		}
-
-		line += line_height;
-	}
-
-	font::set_font(old_font);
-}
-
-void photo_mode_clear_screenshot_queued_flag()
-{
-	Photo_mode_screenshot_queued_this_frame = false;
-}
-
-void photo_mode_set_screenshot_queued_flag()
-{
-	Photo_mode_screenshot_queued_this_frame = true;
-}
-
-void game_toggle_photo_mode()
-{
-	photo_mode_set_active(!Photo_mode_active);
-}
-
-void game_set_photo_mode_allowed(bool allowed)
-{
-	Photo_mode_allowed = allowed && ((Game_mode & GM_MULTIPLAYER) == 0);
-
-	if (!Photo_mode_allowed && Photo_mode_active) {
-		photo_mode_set_active(false);
-	}
-}
-
-bool game_get_photo_mode_allowed()
-{
-	return Photo_mode_allowed && ((Game_mode & GM_MULTIPLAYER) == 0);
-}
-
-bool game_is_photo_mode_active()
-{
-	return Photo_mode_active;
-}
-
-void game_cycle_photo_mode_filter(int direction)
-{
-	if (!Photo_mode_active) {
-		return;
-	}
-
-	Photo_mode_selected_parameter = std::clamp(Photo_mode_selected_parameter + direction, 0, static_cast<int>(Photo_mode_params.size()) - 1);
-}
-
-void game_reset_photo_mode_filters()
-{
-	if (!Photo_mode_active) {
-		return;
-	}
-
-	for (auto& param : Photo_mode_params) {
-		if (param.type == photo_mode_param_type::INT_RANGE) {
-			param.value = param.saved_value;
-		} else if (param.type == photo_mode_param_type::BOOL_TOGGLE) {
-			param.bool_value = false;
-		}
-	}
-	photo_mode_apply_parameter_values();
-}
-
-void game_adjust_photo_mode_filter_parameter(int delta)
-{
-	if (!Photo_mode_active) {
-		return;
-	}
-
-	auto& param = Photo_mode_params[Photo_mode_selected_parameter];
-
-	if (param.type == photo_mode_param_type::BOOL_TOGGLE) {
-		param.bool_value = (delta > 0);
-		return;
-	}
-
-	param.value = std::clamp(param.value + delta, param.min_val, param.max_val);
-	photo_mode_apply_parameter_values();
-}
-
@@ -1,16 +0,0 @@
-#pragma once
-
-void photo_mode_set_active(bool active);
-void photo_mode_do_frame(float frame_time);
-void photo_mode_maybe_render_hud();
-void photo_mode_clear_screenshot_queued_flag();
-void photo_mode_set_screenshot_queued_flag();
-
-// mission-level permission to allow/disallow Photo Mode
-void game_toggle_photo_mode();
-void game_set_photo_mode_allowed(bool allowed);
-bool game_get_photo_mode_allowed();
-bool game_is_photo_mode_active();
-void game_cycle_photo_mode_filter(int direction);
-void game_reset_photo_mode_filters();
-void game_adjust_photo_mode_filter_parameter(int delta);
@@ -33,7 +33,7 @@
 #include "parse/encrypt.h"
 #include "cfilesystem.h"

-#include <algorithm>
+
 #include <limits>

 char Cfile_root_dir[CFILE_ROOT_DIRECTORY_LEN] = "";
@@ -52,7 +52,7 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	// Root must be index 1!!
 	{ CF_TYPE_ROOT,					"",																			".mve .ogg",						CF_TYPE_ROOT	},
 	{ CF_TYPE_DATA,					"data",																		".cfg .txt",						CF_TYPE_ROOT	},
-	{ CF_TYPE_MAPS,					"data" DIR_SEPARATOR_STR "maps",											".pcx .ani .eff .tga .jpg .png .dds .ktx",	CF_TYPE_DATA	},
+	{ CF_TYPE_MAPS,					"data" DIR_SEPARATOR_STR "maps",											".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
 	{ CF_TYPE_TEXT,					"data" DIR_SEPARATOR_STR "text",											".txt .net",						CF_TYPE_DATA	},
 	{ CF_TYPE_MODELS,				"data" DIR_SEPARATOR_STR "models",											".pof",								CF_TYPE_DATA	},
 	{ CF_TYPE_TABLES,				"data" DIR_SEPARATOR_STR "tables",											".tbl .tbm .lua",						CF_TYPE_DATA	},
@@ -66,26 +66,26 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ CF_TYPE_VOICE_TRAINING,		"data" DIR_SEPARATOR_STR "voice" DIR_SEPARATOR_STR "training",				".wav .ogg",						CF_TYPE_VOICE	},
 	{ CF_TYPE_MUSIC,				"data" DIR_SEPARATOR_STR "music",											".wav .ogg",						CF_TYPE_DATA	},
 	{ CF_TYPE_MOVIES,				"data" DIR_SEPARATOR_STR "movies",											".mve .msb .ogg .mp4 .srt .webm .png",CF_TYPE_DATA	},
-	{ CF_TYPE_INTERFACE,			"data" DIR_SEPARATOR_STR "interface",										".pcx .ani .dds .tga .eff .png .jpg .rml .rcss .ktx",	CF_TYPE_DATA	},
+	{ CF_TYPE_INTERFACE,			"data" DIR_SEPARATOR_STR "interface",										".pcx .ani .dds .tga .eff .png .jpg .rml .rcss",	CF_TYPE_DATA	},
 	{ CF_TYPE_FONT,					"data" DIR_SEPARATOR_STR "fonts",											".vf .ttf .otf",						CF_TYPE_DATA	},
-	{ CF_TYPE_EFFECTS,				"data" DIR_SEPARATOR_STR "effects",											".ani .eff .pcx .neb .tga .jpg .png .dds .ktx .sdr .vert .frag .glsl",	CF_TYPE_DATA	},
-	{ CF_TYPE_HUD,					"data" DIR_SEPARATOR_STR "hud",												".pcx .ani .eff .tga .jpg .png .dds .ktx",	CF_TYPE_DATA	},
+	{ CF_TYPE_EFFECTS,				"data" DIR_SEPARATOR_STR "effects",											".ani .eff .pcx .neb .tga .jpg .png .dds .sdr",	CF_TYPE_DATA	},
+	{ CF_TYPE_HUD,					"data" DIR_SEPARATOR_STR "hud",												".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
 	{ CF_TYPE_PLAYERS,				"data" DIR_SEPARATOR_STR "players",											".hcf", /* DON'T add pilot files here!! */	CF_TYPE_DATA	},
-	{ CF_TYPE_PLAYER_IMAGES,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "images",				".pcx .png .dds .ktx",						CF_TYPE_PLAYERS	},
-	{ CF_TYPE_SQUAD_IMAGES,			"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "squads",				".pcx .png .dds .ktx",						CF_TYPE_PLAYERS	},
+	{ CF_TYPE_PLAYER_IMAGES,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "images",				".pcx .png .dds",						CF_TYPE_PLAYERS	},
+	{ CF_TYPE_SQUAD_IMAGES,			"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "squads",				".pcx .png .dds",						CF_TYPE_PLAYERS	},
 	{ CF_TYPE_SINGLE_PLAYERS,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "single",				".pl2 .cs2 .plr .csg .css .json",	CF_TYPE_PLAYERS	},
 	{ CF_TYPE_MULTI_PLAYERS,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "multi",				".plr .json",						CF_TYPE_PLAYERS	},
 	{ CF_TYPE_PLAYER_BINDS,			"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "presets",				".json",							CF_TYPE_PLAYERS	},
 	{ CF_TYPE_CACHE,				"data" DIR_SEPARATOR_STR "cache",											".clr .tmp .bx",					CF_TYPE_DATA	}, 	//clr=cached color
-	{ CF_TYPE_MULTI_CACHE,			"data" DIR_SEPARATOR_STR "multidata",										".pcx .png .jpg .dds .fs2 .txt .ktx",		CF_TYPE_DATA	},
+	{ CF_TYPE_MULTI_CACHE,			"data" DIR_SEPARATOR_STR "multidata",										".pcx .png .jpg .dds .fs2 .txt",		CF_TYPE_DATA	},
 	{ CF_TYPE_MISSIONS,				"data" DIR_SEPARATOR_STR "missions",										".fs2 .fc2 .ntl .ssv",				CF_TYPE_DATA	},
 	{ CF_TYPE_CONFIG,				"data" DIR_SEPARATOR_STR "config",											".cfg .tbl .tbm .xml .csv",			CF_TYPE_DATA	},
 	{ CF_TYPE_DEMOS,				"data" DIR_SEPARATOR_STR "demos",											".fsd",								CF_TYPE_DATA	},
-	{ CF_TYPE_CBANIMS,				"data" DIR_SEPARATOR_STR "cbanims",											".pcx .ani .eff .tga .jpg .png .dds .ktx",	CF_TYPE_DATA	},
-	{ CF_TYPE_INTEL_ANIMS,			"data" DIR_SEPARATOR_STR "intelanims",										".pcx .ani .eff .tga .jpg .png .dds .ktx",	CF_TYPE_DATA	},
+	{ CF_TYPE_CBANIMS,				"data" DIR_SEPARATOR_STR "cbanims",											".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
+	{ CF_TYPE_INTEL_ANIMS,			"data" DIR_SEPARATOR_STR "intelanims",										".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
 	{ CF_TYPE_SCRIPTS,				"data" DIR_SEPARATOR_STR "scripts",											".lua .lc .fnl",						CF_TYPE_DATA	},
 	{ CF_TYPE_FICTION,				"data" DIR_SEPARATOR_STR "fiction",											".txt",								CF_TYPE_DATA	}, 
-	{ CF_TYPE_FREDDOCS,				"data" DIR_SEPARATOR_STR "freddocs",										".html .css .png .jpg",	CF_TYPE_DATA	}
+	{ CF_TYPE_FREDDOCS,				"data" DIR_SEPARATOR_STR "freddocs",										".html",							CF_TYPE_DATA	}
 };
 // clang-format on

@@ -185,13 +185,7 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)

 	char buf[CFILE_ROOT_DIRECTORY_LEN];

-	#ifndef __ANDROID__
-		strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1);
-	#else
-		(void)exe_dir;
-		strncpy(buf, os_android_get_working_folder_path().c_str(), CFILE_ROOT_DIRECTORY_LEN - 1);
-	#endif
-
+	strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1);
 	buf[CFILE_ROOT_DIRECTORY_LEN - 1] = '\0';

 	// are we in a root directory?		
@@ -837,7 +831,7 @@ static int cfget_cfile_block()
 	mprintf(("Out of cfile blocks! Currently opened files:\n"));
 	dump_opened_files();

-	Warning(LOCATION, "There are no more free cfile blocks. This means that there are too many files opened by FSO.\n"
+	UNREACHABLE("There are no more free cfile blocks. This means that there are too many files opened by FSO.\n"
 		"This is probably caused by a programming or scripting error where a file does not get closed."); // out of free cfile blocks
 	return -1;			
 }
@@ -908,7 +902,7 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 		cfp->source_file = source;
 		cfp->line_num = line;
 		
-		auto pos = ftell(fp);
+		int pos = ftell(fp);
 		if(pos == -1L)
 			pos = 0;
 		cf_init_lowlevel_read_code(cfp,0,filelength(fileno(fp)), 0 );
@@ -1110,98 +1104,28 @@ void cfread_string(char *buf, int n, CFILE *file)
 	} while (c != 0 );
 }

-namespace {
-struct string_len_header {
-	int len = 0;
-	int stored = 0;
-	int start = 0;
-	bool length_cut = false;
-};
-
-// a past-the-end length is clamped like any cfread, but a negative one has nothing to clamp to, so inside a
-// limited section it throws and the loader skips the rest of the section
-string_len_header read_string_len_header(CFILE* file)
+void cfread_string_len(char *buf, int buffer_size, CFILE *file)
 {
-	string_len_header h;
-	if (!cf_is_valid(file)) {
-		return h;
+	int len;
+	len = cfread_int(file);
+	Assertion( (len <= buffer_size), "String cannot fit in buffer, len: %i, buffer: %i", len, buffer_size);
+	if (len) {
+		cfread(buf, len, 1, file);
+		Assertion(len != buffer_size || buf[len - 1] == 0, "Unterminated string does not fit in buffer");
 	}
-	int before = cftell(file);
-	h.length_cut = cfread(&h.len, sizeof(h.len), 1, file) != 1;
-	h.start = cftell(file);
-	if (h.length_cut) {
-		// a clean end of file reads as an empty string without a warning, as cfread_int does
-		h.length_cut = (h.start != before) || (cfeof(file) == 0);
-		return h;
-	}
-	h.len = INTEL_INT(h.len);
-	if ((h.len < 0) && (file->max_read_len != 0)) {
-		throw cfile::max_read_length("Attempted to read a string of negative length " + std::to_string(h.len));
-	}
-	h.stored = static_cast<int>(cf_check_read_size(file, static_cast<size_t>(std::max(h.len, 0))));
-	return h;
-}

-// reads count of the stored characters and leaves the file just past the whole string; false if the read failed
-bool read_string_len_body(const string_len_header& h, char* dest, int count, CFILE* file)
-{
-	bool ok = (count <= 0) || (cfread(dest, count, 1, file) == 1);
-	if (!ok || (h.stored > count)) {
-		cfseek(file, h.start + h.stored, CF_SEEK_SET);
-	}
-	return ok;
-}
-
-// warned last, so the file position is right even if a debug build stops here
-void warn_string_len(const string_len_header& h, bool read_ok, bool cut, int buffer_size, CFILE* file)
-{
-	if (h.length_cut) {
-		Warning(LOCATION, "cfread_string_len: cut-off string length field in %s", cf_get_filename(file));
-	} else if (!read_ok) {
-		Warning(LOCATION,
-			"cfread_string_len: could not read a string of %d characters in %s",
-			h.stored,
-			cf_get_filename(file));
-	} else if (h.len != h.stored) {
-		Warning(LOCATION, "cfread_string_len: corrupt string length %d in %s", h.len, cf_get_filename(file));
-	} else if (cut) {
-		Warning(LOCATION,
-			"cfread_string_len: a string of %d bytes was cut to fit a buffer of %d in %s",
-			h.len,
-			buffer_size,
-			cf_get_filename(file));
-	}
-}
-} // namespace
-
-void cfread_string_len(char* buf, int buffer_size, CFILE* file)
-{
-	Assertion(buffer_size > 0, "cfread_string_len needs room for at least the terminator, buffer: %i", buffer_size);
-	string_len_header h = read_string_len_header(file);
-	if (buffer_size <= 0) {
-		bool read_ok = read_string_len_body(h, buf, 0, file);
-		warn_string_len(h, read_ok, h.stored > 0, buffer_size, file);
-		return;
-	}
-	int count = std::min(h.stored, buffer_size);
-	bool read_ok = read_string_len_body(h, buf, count, file);
-	int kept = read_ok ? count : 0;
-	bool cut = (kept == buffer_size) && (memchr(buf, 0, buffer_size) == nullptr);
-	buf[std::min(kept, buffer_size - 1)] = 0;
-	warn_string_len(h, read_ok, cut, buffer_size, file);
+	buf[MIN(len, buffer_size - 1)] = 0;
 }

 SCP_string cfread_string_len(CFILE *file)
 {
-	string_len_header h = read_string_len_header(file);
+	int len = cfread_int(file);

 	SCP_string str;
-	str.resize(h.stored);
-	bool read_ok = read_string_len_body(h, str.data(), h.stored, file);
-	if (!read_ok) {
-		str.clear();
-	}
-	warn_string_len(h, read_ok, false, 0, file);
+	str.resize(len);
+
+	if (len)
+		cfread(&str[0], len, 1, file);

 	return str;
 }
@@ -320,26 +320,20 @@ void cfread_string(char *buf,int n, CFILE *file);
 /**
 * @brief Read a fixed length string that is not null-terminated, with the length stored in file.
 *
- * Keeps at most buffer_size - 1 characters and leaves the file just past the whole string, unless it throws.
- *
+ * If it is not null-terminated, the length of the string *must* be less than the size of the buffer (to make room for one)
+ * 
 * @param buf Pre-allocated array to store string
 * @param buffer_size Size of pre-allocated array
 * @param file File to read from
 *
 * @note Appends NULL character to string (buf)
- * @note Bad data gets a warning; at a clean end of file, or with an invalid file, the string is empty and nothing is
- * warned. Inside a limited section (cf_set_max_read_len), a negative length, or a read that still passes the limit
- * once clamped to the end of the file, throws cfile::max_read_length.
 */
 void cfread_string_len(char *buf,int buffer_size, CFILE *file);

 /**
 * @brief Read a string from the file where the length is stored in the file
- *
 * @param file The file to read the string from
 * @return The string that was read
- *
- * @note Warns and throws like the char* overload, except that nothing is cut.
 */
 SCP_string cfread_string_len(CFILE *file);

@@ -193,8 +193,21 @@ int cfseek( CFILE *cfile, int offset, int where )
 }


-size_t cf_check_read_size(CFILE* cfile, size_t size)
+// cfread() reads from a file
+//
+// returns:   returns the number of full elements read
+//            
+//
+int cfread(void *buf, int elsize, int nelem, CFILE *cfile)
 {
+	if(!cf_is_valid(cfile))
+		return 0;
+
+	size_t size = elsize*nelem;
+
+	if(buf == NULL || size <= 0)
+		return 0;
+
 	if ( (cfile->raw_position+size) > cfile->size ) {
 		Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
 		size = cfile->size - cfile->raw_position;
@@ -213,29 +226,6 @@ size_t cf_check_read_size(CFILE* cfile, size_t size)
 		}
 	}

-	return size;
-}
-
-// cfread() reads from a file
-//
-// returns:   returns the number of full elements read
-//            
-//
-int cfread(void *buf, int elsize, int nelem, CFILE *cfile)
-{
-	if(!cf_is_valid(cfile))
-		return 0;
-
-	size_t size = elsize*nelem;
-
-	if(buf == nullptr || size <= 0)
-		return 0;
-
-	size = cf_check_read_size(cfile, size);
-	if (size < 1) {
-		return 0;
-	}
-
 	size_t bytes_read;
 	if (cfile->data != nullptr) {
 		// This is a file from memory
@@ -62,9 +62,4 @@ void cf_check_compression(CFILE* cfile);
 // Used to clear compression info data and free dynamic memory used by compression
 void cf_clear_compression_info(CFILE* cfile);

-// Clamps a read of size bytes to the end of the file and returns the clamped size, or 0 at the end of the file
-// without checking the limit; throws cfile::max_read_length if the clamped read would pass the file's read limit
-// (cf_set_max_read_len).
-size_t cf_check_read_size(CFILE* cfile, size_t size);
-
 #endif
@@ -143,7 +143,7 @@ void lz41_load_offsets(CFILE* cf)
 	int* offsets_ptr = cf->compression_info.offsets;

 	/* Seek to the first offset position, remember to consider the trailing ints */
-	fso_fseek(cf, static_cast<int>( ( sizeof(int) * cf->compression_info.num_offsets ) * -1 ) - (sizeof(int)*3 ), SEEK_END);
+	fso_fseek(cf, ( ( sizeof(int) * cf->compression_info.num_offsets ) * -1 ) - (sizeof(int)*3 ), SEEK_END);
 	for (block = 0; block < cf->compression_info.num_offsets; ++block)
 	{
 		auto bytes_read = fread(offsets_ptr++, sizeof(int), 1, cf->fp);
@@ -532,7 +532,7 @@ void cf_build_pack_list( cf_root *root )
 			s_root.roottype = CF_ROOTTYPE_PACK;
 			s_root.cf_type = i;

-			temp_roots_sort.push_back(std::move(s_root));
+			temp_roots_sort.push_back(s_root);
 		}
 	}

@@ -1083,7 +1083,7 @@ void cf_search_root_pack(int root_index)
 						file.pathtype = path_type;
 						file.offset = find.offset;

-						files.push_back(std::move(file));
+						files.push_back(file);

 						//mprintf(( "Found pack file '%s'\n", find.filename ));
 					}
@@ -1356,7 +1356,7 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, uint32_t
 				fclose(fp);

 				res.offset = 0;
-				res.full_name = std::move(longname);
+				res.full_name = longname;
 				res.name_ext = filespec;

 				return res;
@@ -1549,8 +1549,8 @@ CFileLocationExt cf_find_file_location_ext(const char *filename, const int ext_n
 				fclose(fp);

 				res.offset = 0;
-				res.full_name = std::move(longname);
-				res.name_ext = std::move(filespec_ext);
+				res.full_name = longname;
+				res.name_ext = filespec_ext;

 				return res;
 			}
@@ -2437,9 +2437,7 @@ int cf_create_default_path_string(SCP_string& path, int pathtype, const char* fi
 		}

 		if (!root) {
-			if (filename == nullptr) {
-				return 0;
-			}
+			Assert( filename != NULL );
 			path.assign(filename);
 			return 1;
 		}
@@ -2482,7 +2480,7 @@ void cfile_spew_pack_file_crcs()
 	my_time = time(NULL);

 	memset( datetime, 0, sizeof(datetime) );
-	snprintf(datetime, sizeof(datetime), "%s", ctime(&my_time));
+	snprintf(datetime, sizeof(datetime)-1, "%s", ctime(&my_time));
 	// ctime() adds a newline char, so we have to strip it off
 	datetime[strlen(datetime)-1] = '\0';

@@ -135,7 +135,7 @@ void parse_cheat_table(const char* filename) {
 			}
 			
 			if (shipSpawn) {
-				std::unique_ptr<CustomCheat> shipCheat(new SpawnShipCheat(code, std::move(msg), requireCheats, std::move(shipClass), std::move(shipName)));
+				std::unique_ptr<CustomCheat> shipCheat(new SpawnShipCheat(code, msg, requireCheats, shipClass, shipName));

 				if(customCheats.count(code) == 1) {
 					Warning(LOCATION, "A cheat for code '%s' already exists. It will be replaced.", code.c_str());
@@ -144,7 +144,7 @@ void parse_cheat_table(const char* filename) {
 					customCheats.emplace(code, std::move(shipCheat));
 				}
 			} else {
-				std::unique_ptr<CustomCheat> cheat(new CustomCheat(code, std::move(msg), requireCheats));
+				std::unique_ptr<CustomCheat> cheat(new CustomCheat(code, msg, requireCheats));

 				if(customCheats.count(code) == 1) {
 					Warning(LOCATION, "A cheat for code '%s' already exists. It will be replaced.", code.c_str());
@@ -35,7 +35,7 @@ class SpawnShipCheat : public CustomCheat {
 	SCP_string shipName;
 	public:

-	SpawnShipCheat(SCP_string cheat_code, SCP_string cheat_msg,  bool require_cheats_enabled, SCP_string class_name, SCP_string ship_name) : CustomCheat(std::move(cheat_code), std::move(cheat_msg), require_cheats_enabled),
+	SpawnShipCheat(SCP_string cheat_code, SCP_string cheat_msg,  bool require_cheats_enabled, SCP_string class_name, SCP_string ship_name) : CustomCheat(cheat_code, cheat_msg, require_cheats_enabled),
 		shipClassName(std::move(class_name)),
 		shipName(std::move(ship_name)) { }

@@ -15,7 +15,6 @@
 #include "globalincs/pstypes.h"
 #include "globalincs/systemvars.h"
 #include "globalincs/version.h"
-#include "graphics/2d.h"
 #include "graphics/openxr.h"
 #include "graphics/shadows.h"
 #include "hud/hudconfig.h"
@@ -75,7 +74,6 @@ const char *cmdline_arg_types[] =
 enum class flag_output_type {
 	Binary,
 	Json_V1,
-	Json_V2,
 };

 // variables
@@ -358,7 +356,6 @@ cmdline_parm fb_explosions_arg("-fb_explosions", NULL, AT_NONE);
 cmdline_parm fb_thrusters_arg("-fb_thrusters", NULL, AT_NONE);
 cmdline_parm shadow_quality_arg("-shadow_quality", NULL, AT_INT);
 cmdline_parm enable_shadows_arg("-enable_shadows", NULL, AT_NONE);
-cmdline_parm rt_shadows_arg("-rt_shadows", nullptr, AT_NONE);
 cmdline_parm no_deferred_lighting_arg("-no_deferred", NULL, AT_NONE);	// Cmdline_no_deferred
 cmdline_parm deferred_lighting_cockpit_arg("-deferred_cockpit", nullptr, AT_NONE);
 cmdline_parm anisotropy_level_arg("-anisotropic_filter", NULL, AT_INT);
@@ -516,7 +513,6 @@ cmdline_parm deprecated_res_arg("-res", "Deprecated, resolution, formatted like
 cmdline_parm render_res_arg("-render_res", "Resolution, formatted like 1600x900", AT_STRING);
 cmdline_parm window_res_arg("-window_res", "Window resolution, formatted like 1600x900.", AT_STRING);
 cmdline_parm center_res_arg("-center_res", "Resolution of center monitor, formatted like 1600x900", AT_STRING);
-cmdline_parm hdr_nits_arg("-hdr", "Forces HDR output on, overriding the in-game HDR setting. Optionally takes paper white and peak luminance in nits, formatted like 400,1500, overriding the in-game HDR nits settings.", AT_STRING);
 cmdline_parm verify_vps_arg("-verify_vps", NULL, AT_NONE);	// Cmdline_verify_vps  -- spew VP crcs to vp_crcs.txt
 cmdline_parm parse_cmdline_only(PARSE_COMMAND_LINE_STRING, "Ignore any cmdline_fso.cfg files", AT_NONE);
 cmdline_parm reparse_mainhall_arg("-reparse_mainhall", NULL, AT_NONE); //Cmdline_reparse_mainhall
@@ -531,7 +527,6 @@ cmdline_parm show_video_info("-show_video_info", NULL, AT_NONE); //Cmdline_show_
 cmdline_parm frame_profile_arg("-profile_frame_time", NULL, AT_NONE); //Cmdline_frame_profile
 cmdline_parm debug_window_arg("-debug_window", NULL, AT_NONE);	// Cmdline_debug_window
 cmdline_parm graphics_debug_output_arg("-gr_debug", nullptr, AT_NONE); // Cmdline_graphics_debug_output
-cmdline_parm gr_sync_validation_arg("-gr_sync_validation", nullptr, AT_NONE); // Cmdline_gr_sync_validation (implies -gr_debug)
 cmdline_parm log_to_stdout_arg("-stdout_log", nullptr, AT_NONE); // Cmdline_log_to_stdout
 cmdline_parm slow_frames_ok_arg("-slow_frames_ok", nullptr, AT_NONE);	// Cmdline_slow_frames_ok
 cmdline_parm fixed_seed_rand("-seed", nullptr, AT_INT);	// Cmdline_rng_seed,Cmdline_reuse_rng_seed;
@@ -539,8 +534,6 @@ cmdline_parm luadev_arg("-luadev", "Make lua errors non-fatal", AT_NONE);	// Cmd
 cmdline_parm override_arg("-override_data", "Enable override directory", AT_NONE);	// Cmdline_override_data
 cmdline_parm imgui_debug_arg("-imgui_debug", nullptr, AT_NONE);
 cmdline_parm vulkan("-vulkan", nullptr, AT_NONE);
-cmdline_parm opengl("-opengl", nullptr, AT_NONE);
-cmdline_parm multithreading("-threads", nullptr, AT_INT);

 char *Cmdline_start_mission = NULL;
 int Cmdline_dis_collisions = 0;
@@ -556,12 +549,7 @@ int Cmdline_show_pos = 0;
 int Cmdline_show_stats = 0;
 int Cmdline_save_render_targets = 0;
 bool Cmdline_window = false;
-#ifdef __ANDROID__
-// Default to borderless in the legacy window-mode path as well.
-bool Cmdline_fullscreen_window = true;
-#else
 bool Cmdline_fullscreen_window = false;
-#endif
 std::optional<std::pair<uint16_t, uint16_t>>Cmdline_window_res = std::nullopt;
 char *Cmdline_res = 0;
 char *Cmdline_center_res = 0;
@@ -578,14 +566,12 @@ bool Cmdline_frame_profile = false;
 bool Cmdline_show_video_info = false;
 bool Cmdline_debug_window = false;
 bool Cmdline_graphics_debug_output = false;
-bool Cmdline_gr_sync_validation = false;
 bool Cmdline_log_to_stdout = false;
 bool Cmdline_slow_frames_ok = false;
 bool Cmdline_lua_devmode = false;
 bool Cmdline_override_data = false;
 bool Cmdline_show_imgui_debug = false;
-GraphicsAPI Cmdline_graphics_api = GraphicsAPI::Default;
-int Cmdline_multithreading = 1;
+bool Cmdline_vulkan = false;

 // Other
 cmdline_parm get_flags_arg(GET_FLAGS_STRING, "Output the launcher flags file", AT_STRING);
@@ -1334,7 +1320,7 @@ static void handle_unix_modlist(char **modlist, size_t *len)

 	for (char *cur_mod = strtok(*modlist, ","); cur_mod != NULL; cur_mod = strtok(NULL, ",")) {
 		SCP_string path = get_real_mod_path(cur_mod);
-		mod_paths.push_back(std::move(path));
+		mod_paths.push_back(path);
 	}

 	// create new char[] to replace modlist
@@ -1364,58 +1350,51 @@ static void handle_unix_modlist(char **modlist, size_t *len)

 // external entry point into this modules

-static void json_add_version(json_t* root) {
-	auto version_obj = json_object();
-
-	json_object_set_new(version_obj, "full", json_string(FS_VERSION_FULL));
-	json_object_set_new(version_obj, "major", json_integer(FS_VERSION_MAJOR));
-	json_object_set_new(version_obj, "minor", json_integer(FS_VERSION_MINOR));
-	json_object_set_new(version_obj, "build", json_integer(FS_VERSION_BUILD));
-
-	json_object_set_new(version_obj, "has_revision", json_boolean(FS_VERSION_HAS_REVIS));
-	json_object_set_new(version_obj, "revision", json_integer(FS_VERSION_REVIS));
-	json_object_set_new(version_obj, "revision_str", json_string(FS_VERSION_REVIS_STR));
-
-	json_object_set_new(root, "version", version_obj);
-}
-
-static void json_add_easy_flags(json_t* root) {
-	auto easy_array = json_array();
-
-	for (auto& easy_flag : easy_flags) {
-		json_array_append_new(easy_array, json_string(easy_flag.name));
-	}
-
-	json_object_set_new(root, "easy_flags", easy_array);
-}
-
-static void json_add_flags(json_t* root) {
-	auto flags_array = json_array();
-
-	for (auto& flag : exe_params) {
-		auto flag_obj = json_object();
-
-		json_object_set_new(flag_obj, "name", json_string(flag.name));
-		json_object_set_new(flag_obj, "description", json_string(flag.desc));
-		json_object_set_new(flag_obj, "fso_only", json_boolean(flag.fso_only));
-		json_object_set_new(flag_obj, "on_flags", json_integer(flag.on_flags));
-		json_object_set_new(flag_obj, "off_flags", json_integer(flag.off_flags));
-		json_object_set_new(flag_obj, "type", json_string(flag.type));
-		json_object_set_new(flag_obj, "web_url", json_string(flag.web_url));
-
-		json_array_append_new(flags_array, flag_obj);
-	}
-
-	json_object_set_new(root, "flags", flags_array);
-}
-
 static json_t* json_get_v1() {
 	auto root = json_object();

-	json_add_version(root);
-	json_add_easy_flags(root);
-	json_add_flags(root);
+	{
+		auto version_obj = json_object();

+		json_object_set_new(version_obj, "full", json_string(FS_VERSION_FULL));
+		json_object_set_new(version_obj, "major", json_integer(FS_VERSION_MAJOR));
+		json_object_set_new(version_obj, "minor", json_integer(FS_VERSION_MINOR));
+		json_object_set_new(version_obj, "build", json_integer(FS_VERSION_BUILD));
+
+		json_object_set_new(version_obj, "has_revision", json_boolean(FS_VERSION_HAS_REVIS));
+		json_object_set_new(version_obj, "revision", json_integer(FS_VERSION_REVIS));
+		json_object_set_new(version_obj, "revision_str", json_string(FS_VERSION_REVIS_STR));
+
+		json_object_set_new(root, "version", version_obj);
+	}
+	{
+		auto easy_array = json_array();
+
+		for (auto& easy_flag : easy_flags) {
+			json_array_append_new(easy_array, json_string(easy_flag.name));
+		}
+
+		json_object_set_new(root, "easy_flags", easy_array);
+	}
+	{
+		auto flags_array = json_array();
+
+		for (auto& flag : exe_params) {
+			auto flag_obj = json_object();
+
+			json_object_set_new(flag_obj, "name", json_string(flag.name));
+			json_object_set_new(flag_obj, "description", json_string(flag.desc));
+			json_object_set_new(flag_obj, "fso_only", json_boolean(flag.fso_only));
+			json_object_set_new(flag_obj, "on_flags", json_integer(flag.on_flags));
+			json_object_set_new(flag_obj, "off_flags", json_integer(flag.off_flags));
+			json_object_set_new(flag_obj, "type", json_string(flag.type));
+			json_object_set_new(flag_obj, "web_url", json_string(flag.web_url));
+
+			json_array_append_new(flags_array, flag_obj);
+		}
+
+		json_object_set_new(root, "flags", flags_array);
+	}
 	{
 		auto caps_array = json_array();

@@ -1433,7 +1412,7 @@ static json_t* json_get_v1() {
 		auto voices = speech_enumerate_voices();

 		for (auto& voice : voices) {
-			json_array_append_new(voices_array, json_string(voice.second.c_str()));
+			json_array_append_new(voices_array, json_string(voice.c_str()));
 		}

 		json_object_set_new(root, "voices", voices_array);
@@ -1526,19 +1505,6 @@ static json_t* json_get_v1() {
 	return root;
 }

-// json_v2 reports version, supported flags, and the preferences path for launchers,
-// without querying graphics, audio, or joystick devices.
-static json_t* json_get_v2() {
-	auto root = json_object();
-
-	json_add_version(root);
-	json_add_easy_flags(root);
-	json_add_flags(root);
-	json_object_set_new(root, "pref_path", json_string(os_get_config_path().c_str()));
-
-	return root;
-}
-
 static void write_flags_file() {
 	FILE *fp = fopen("flags.lch","w");

@@ -1596,8 +1562,6 @@ static flag_output_type get_flags_output_type() {
 		return flag_output_type::Binary;
 	} else if (type == "json_v1") {
 		return flag_output_type::Json_V1;
-	} else if (type == "json_v2") {
-		return flag_output_type::Json_V2;
 	} else {
 		// This is supposed to make it easy for the launcher to recognize an unsupported type
 		printf("OUTPUT TYPE NOT SUPPORTED!\n");
@@ -1608,23 +1572,17 @@ static flag_output_type get_flags_output_type() {

 static void write_flags() {
 	auto type = get_flags_output_type();
-
-	if (type == flag_output_type::Binary) {
+	switch(type) {
+	case flag_output_type::Binary:
 		write_flags_file();
-		return;
+		break;
+	case flag_output_type::Json_V1:
+		json_t* root = json_get_v1();
+
+		json_dumpf(root, stdout, JSON_INDENT(4));
+		json_decref(root);
+		break;
 	}
-
-	json_t* root = (type == flag_output_type::Json_V1) ? json_get_v1() : json_get_v2();
-
-#ifdef __ANDROID__
-	char* dumped = json_dumps(root, JSON_INDENT(4));
-	os_android_set_flags_string(dumped ? dumped : "");
-	free(dumped);
-#else
-	json_dumpf(root, stdout, JSON_INDENT(4));
-#endif
-
-	json_decref(root);
 }

 bool SetCmdlineParams()
@@ -1815,45 +1773,38 @@ bool SetCmdlineParams()
 	}

 	// d3d windowed
-	// We need to set both the raw global (for the legacy !Using_in_game_options path) and the
-	// Option<T> override (for the modern path) since either backend may be the one actually consulted.
 	if(window_arg.found()) {
-		options::OptionsManager::instance()->setOverride("Graphics.WindowMode",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(os::ViewportState::Windowed))), "-window");
+		// We need to set both values since we don't know if we are going to use the new config system
+		//options::OptionsManager::instance()->setOverride("Graphics.WindowMode", "0");
 		Cmdline_window = true;
-		Cmdline_fullscreen_window = false;
 	}

 	if ( fullscreen_window_arg.found( ) )
 	{
-		options::OptionsManager::instance()->setOverride("Graphics.WindowMode",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(os::ViewportState::Borderless))),
-			"-fullscreen_window");
+		//options::OptionsManager::instance()->setOverride("Graphics.WindowMode", "1");
 		Cmdline_fullscreen_window = true;
 		Cmdline_window = false; /* Make sure no-one sets both */
 	}

 	if(render_res_arg.found() || deprecated_res_arg.found()){
-		const char* res_flag_name;
 		if (render_res_arg.found()) {
 			Cmdline_res = render_res_arg.str();
-			res_flag_name = "-render_res";
 		}
 		else {
 			Cmdline_res = deprecated_res_arg.str();
-			res_flag_name = "-res";
 			mprintf(("Deprecated -res argument. Use -render_res instead...\n"));
 		}

-		int width = 0;
+		/*int width = 0;
 		int height = 0;

 		if (sscanf(Cmdline_res, "%dx%d", &width, &height) == 2) {
-			options::OptionsManager::instance()->setOverride("Graphics.Resolution",
-				std::unique_ptr<json_t>(json_pack("{s:i, s:i}", "width", width, "height", height)), res_flag_name);
+			SCP_string override;
+			sprintf(override, "{\"width\":%d,\"height\":%d}", width, height);
+			options::OptionsManager::instance()->setOverride("Graphics.Resolution", override);
 		} else {
 			Warning(LOCATION, "Failed to parse -res parameter \"%s\". Must be in format \"<width>x<height>\".\n", Cmdline_res);
-		}
+		}*/
 	}
 	if(window_res_arg.found()){
 		int width = 0;
@@ -1869,24 +1820,6 @@ bool SetCmdlineParams()
 	if(center_res_arg.found()){
 		Cmdline_center_res = center_res_arg.str();
 	}
-	if (hdr_nits_arg.found()) {
-		// presence of the flag alone forces HDR output on, overriding the in-game HDR setting
-		options::OptionsManager::instance()->setOverride("Graphics.HDR",
-			std::unique_ptr<json_t>(json_true()), "-hdr");
-
-		if (hdr_nits_arg.has_param()) {
-			float paperwhite_nits = 0.0f, peak_nits = 0.0f;
-			if (sscanf(hdr_nits_arg.str(), "%f,%f", &paperwhite_nits, &peak_nits) == 2 && paperwhite_nits > 0.0f && peak_nits > 0.0f) {
-				// json_real keeps these JSON reals; json_unpack's "f" format rejects a bare integer like "400"
-				options::OptionsManager::instance()->setOverride("Graphics.HDRPaperWhite",
-					std::unique_ptr<json_t>(json_real(paperwhite_nits)), "-hdr");
-				options::OptionsManager::instance()->setOverride("Graphics.HDRPeakLuminance",
-					std::unique_ptr<json_t>(json_real(peak_nits)), "-hdr");
-			} else {
-				Warning(LOCATION, "Failed to parse -hdr parameter \"%s\". Must be in format \"<paperwhite_nits>,<peak_nits>\".\n", hdr_nits_arg.str());
-			}
-		}
-	}
 	if(almission_arg.found()){//DTP for autoload mission // developer oritentated
 		Cmdline_almission = almission_arg.str();
 		Cmdline_use_last_pilot = 1;
@@ -1979,20 +1912,17 @@ bool SetCmdlineParams()

 	if ( fov_arg.found() ) {
 		auto val = fov_arg.get_float();
-		if (val <= 0.1f) {
-			val = DEFAULT_FOV;
+		if (val > 0.1) {
+			VIEWER_ZOOM_DEFAULT = val;
+		} else {
+			VIEWER_ZOOM_DEFAULT = DEFAULT_FOV;
 		}
-		VIEWER_ZOOM_DEFAULT = val;
-		options::OptionsManager::instance()->setOverride("Graphics.FOV",
-			std::unique_ptr<json_t>(json_real(val)), "-fov");
 	}

 	if ( fov_cockpit_arg.found() ) {
 		auto val = fov_cockpit_arg.get_float();
-		if (val > 0.1f) {
+		if (val > 0.1) {
 			COCKPIT_ZOOM_DEFAULT = val;
-			options::OptionsManager::instance()->setOverride("Graphics.CockpitFOV",
-				std::unique_ptr<json_t>(json_real(val)), "-fov_cockpit");
 		}
 		else {
 			COCKPIT_ZOOM_DEFAULT = VIEWER_ZOOM_DEFAULT;
@@ -2015,18 +1945,13 @@ bool SetCmdlineParams()

 		Cmdline_fullscreen_window = false;
 		Cmdline_window = true; /* Make sure no-one sets both */
-		// These replace the removeWindowModeOption()/removeVSyncOption() calls that used to hide these two
-		// options in VR. An override keeps them visible but disabled in the options menu, with the tooltip
-		// naming -vr as the reason, which tells the player more than the control simply not being there.
-		options::OptionsManager::instance()->setOverride("Graphics.WindowMode",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(os::ViewportState::Windowed))), "-vr");
+		removeWindowModeOption();

 		// Turn off VSync, since we definitely don't want to be capped by the main monitor
 		// the OpenXR runtime should have a buffered wait which will behave, effectively,
 		// as a VSync to VR goggle driver
 		Gr_enable_vsync = false;
-		options::OptionsManager::instance()->setOverride("Graphics.VSync",
-			std::unique_ptr<json_t>(json_false()), "-vr");
+		removeVSyncOption();

 		openxr_prepare();
 	}
@@ -2081,8 +2006,6 @@ bool SetCmdlineParams()
 	if(no_vsync_arg.found() )
 	{
 		Gr_enable_vsync = false;
-		options::OptionsManager::instance()->setOverride("Graphics.VSync",
-			std::unique_ptr<json_t>(json_false()), "-no_vsync");
 	}

 	if ( normal_arg.found() ) {
@@ -2116,15 +2039,11 @@ bool SetCmdlineParams()
 			case 5: 
 				Gr_aa_mode = AntiAliasMode::SMAA_High;
 				break;
-			case 6:
+			case 6: 
 				Gr_aa_mode = AntiAliasMode::SMAA_Ultra;
 				break;
 			}
 		}
-
-		options::OptionsManager::instance()->setOverride("Graphics.AAMode",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(Gr_aa_mode))),
-			post_process_aa_preset_arg.found() ? "-aa_preset" : "-aa");
 	}

 	if (msaa_enabled_arg.found()) {
@@ -2140,9 +2059,6 @@ bool SetCmdlineParams()
 			Cmdline_msaa_enabled = 0;
 			break;
 		}
-
-		options::OptionsManager::instance()->setOverride("Graphics.MSAASamples",
-			std::unique_ptr<json_t>(json_integer(Cmdline_msaa_enabled)), "-msaa");
 	}

 	if ( glow_arg.found() )
@@ -2268,8 +2184,6 @@ bool SetCmdlineParams()
 	if ( softparticles_arg.found() )
 	{
 		Cmdline_softparticles = 1;
-		options::OptionsManager::instance()->setOverride("Graphics.SoftParticles",
-			std::unique_ptr<json_t>(json_true()), "-soft_particles");
 	}

 	if ( fb_explosions_arg.found() )
@@ -2277,31 +2191,14 @@ bool SetCmdlineParams()
 		Gr_framebuffer_effects.set(FramebufferEffects::Shockwaves, true);
 	}

-    if (fb_thrusters_arg.found())
+    if (fb_thrusters_arg.found()) 
    {
 	    Gr_framebuffer_effects.set(FramebufferEffects::Thrusters, true);
    }

-	if (fb_explosions_arg.found() || fb_thrusters_arg.found()) {
-		SCP_string reason;
-		if (fb_explosions_arg.found()) {
-			reason = "-fb_explosions";
-		}
-		if (fb_thrusters_arg.found()) {
-			if (!reason.empty()) {
-				reason += " ";
-			}
-			reason += "-fb_thrusters";
-		}
-		options::OptionsManager::instance()->setOverride("Graphics.FramebufferEffects",
-			std::unique_ptr<json_t>(json_integer(static_cast<json_int_t>(Gr_framebuffer_effects.to_u64()))), reason);
-	}
-
 	if ( no_postprocess_arg.found() )
 	{
 		Gr_post_processing_enabled = false;
-		options::OptionsManager::instance()->setOverride("Graphics.PostProcessing",
-			std::unique_ptr<json_t>(json_false()), "-no_post_process");
 	}

 	if( reparse_mainhall_arg.found() )
@@ -2315,19 +2212,12 @@ bool SetCmdlineParams()
 		Shadow_quality_uses_mod_option = true;

 		Shadow_quality = ShadowQuality::Medium;
-
-		// Deliberately not calling setOverride() here: mod_table_init() (which runs after cmdline parsing but
-		// before OptionsManager::loadInitialValues()) may still adjust Shadow_quality via game_settings.tbl's
-		// "$Shadow Quality Default:" when Shadow_quality_uses_mod_option is set, and an override registered now
-		// would freeze in the Medium fallback and ignore that later adjustment. Graphics.Shadows' default_func
-		// reads Shadow_quality instead, so this value reaches the in-game options path that way, and the
-		// player keeps the ability to change it.
 	}

 	if( shadow_quality_arg.found() )
 	{
 		// set that we are not using default shadow quality level --wookieejedi
-		Shadow_quality_uses_mod_option = false;
+		Shadow_quality_uses_mod_option = false; 

 		switch (shadow_quality_arg.get_int()) {
 		case 0:
@@ -2350,47 +2240,21 @@ bool SetCmdlineParams()
 			Shadow_quality = ShadowQuality::Disabled;
 			break;
 		}
-
-		// Unlike `-enable_shadows` alone, an explicit quality level is an unambiguous hard override that
-		// nothing else (mod defaults included) should be able to silently override.
-		options::OptionsManager::instance()->setOverride("Graphics.Shadows",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(Shadow_quality))), "-shadow_quality");
-	}
-
-	if( rt_shadows_arg.found() )
-	{
-		// Equivalent to picking "Raytraced" in the Shadow Method option. Silently
-		// has no effect if the renderer/hardware doesn't support
-		// CAPABILITY_RAYTRACED_SHADOWS -- the CSM path is used either way.
-		Shadow_render_method = ShadowRenderMethod::Raytraced;
-
-		// No need to gate this on shadows_raytracing_supported(): that answer is only meaningful after
-		// gr_init(), which runs later, and shadows_remove_unsupported_options() then removes this option
-		// altogether on hardware that cannot raytrace, so the override never reaches the options menu there.
-		options::OptionsManager::instance()->setOverride("Graphics.ShadowRenderMethod",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(ShadowRenderMethod::Raytraced))), "-rt_shadows");
 	}

 	if( no_deferred_lighting_arg.found() )
 	{
 		Cmdline_no_deferred_lighting = 1;
-		options::OptionsManager::instance()->setOverride("Graphics.DeferredLighting",
-			std::unique_ptr<json_t>(json_false()), "-no_deferred");
 	}

 	if( deferred_lighting_cockpit_arg.found() )
 	{
 		Cmdline_deferred_lighting_cockpit = true;
-		options::OptionsManager::instance()->setOverride("Graphics.DeferredCockpitLighting",
-			std::unique_ptr<json_t>(json_true()), "-deferred_cockpit");
 	}

-	if (anisotropy_level_arg.found())
+	if (anisotropy_level_arg.found()) 
 	{
 		Cmdline_aniso_level = anisotropy_level_arg.get_int();
-
-		options::OptionsManager::instance()->setOverride("Graphics.Anisotropy",
-			std::unique_ptr<json_t>(json_real(static_cast<double>(Cmdline_aniso_level))), "-anisotropic_filter");
 	}

 	if (frame_profile_write_file.found())
@@ -2441,15 +2305,6 @@ bool SetCmdlineParams()
 		Cmdline_graphics_debug_output = true;
 	}

-	if (gr_sync_validation_arg.found()) {
-		// Enables the Vulkan validation layer + debug messenger + synchronization
-		// validation feature (see VulkanRenderer::initializeInstance), but NOT the
-		// engine-level graphics debug output: -gr_debug additionally feeds extra
-		// stat groups into the ImGui frame profiler overlay (see gr_get_debug_stats),
-		// which are unrelated to GPU sync validation. Keep this a pure GPU-validation switch.
-		Cmdline_gr_sync_validation = true;
-	}
-
 	if (log_to_stdout_arg.found()) {
 		Cmdline_log_to_stdout = true;
 	}
@@ -2475,14 +2330,7 @@ bool SetCmdlineParams()
 	}

 	if (vulkan.found()) {
-		Cmdline_graphics_api = GraphicsAPI::Vulkan;
-		options::OptionsManager::instance()->setOverride("Graphics.RenderAPI",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(GraphicsAPI::Vulkan))), "-vulkan");
-	}
-	else if (opengl.found()) {
-		Cmdline_graphics_api = GraphicsAPI::OpenGL;
-		options::OptionsManager::instance()->setOverride("Graphics.RenderAPI",
-			std::unique_ptr<json_t>(json_integer(static_cast<int>(GraphicsAPI::OpenGL))), "-opengl");
+		Cmdline_vulkan = true;
 	}

 	//Deprecated flags - CommanderDJ
@@ -2559,10 +2407,6 @@ bool SetCmdlineParams()
 		}
 	}

-	if (multithreading.found()) {
-		Cmdline_multithreading = abs(multithreading.get_int());
-	}
-
 	return true; 
 }

@@ -13,7 +13,6 @@
 #define FS_CMDLINE_HEADER_FILE

 #include <optional>
-#include "graphics/2d.h"

 int parse_cmdline(int argc, char *argv[]);

@@ -154,18 +153,18 @@ extern bool Cmdline_frame_profile;
 extern bool Cmdline_show_video_info;
 extern bool Cmdline_debug_window;
 extern bool Cmdline_graphics_debug_output;
-extern bool Cmdline_gr_sync_validation;
 extern bool Cmdline_log_to_stdout;
 extern bool Cmdline_slow_frames_ok;
 extern bool Cmdline_lua_devmode;
 extern bool Cmdline_override_data;
 extern bool Cmdline_show_imgui_debug;
-extern GraphicsAPI Cmdline_graphics_api;
-extern int Cmdline_multithreading;
+extern bool Cmdline_vulkan;

 enum class WeaponSpewType { NONE = 0, STANDARD, ALL };
 extern WeaponSpewType Cmdline_spew_weapon_stats;

+extern void removeVSyncOption();
+extern void removeWindowModeOption();
 extern void removeResolutionOption();
 extern void removeResolutionVROption();

@@ -25,33 +25,18 @@ const float CMEASURE_DETONATE_DISTANCE = 40.0f;

 //Used to set a countermeasure velocity after being launched from a ship as a countermeasure
 //ie not as a primary or secondary.
-void cmeasure_set_ship_launch_vel(object* objp, object* parent_objp, int arand)
+void cmeasure_set_ship_launch_vel(object *objp, object *parent_objp, int arand)
 {
-	vec3d vel;
-	vec3d rand_vec;
-	vec3d world_dir;
+	vec3d vel, rand_vec;

-	weapon* wp = &Weapons[objp->instance];
-	auto* wip = &Weapon_info[wp->weapon_info_index];
+	//Get cmeasure rear velocity in world
+	vm_vec_scale_add(&vel, &parent_objp->phys_info.vel, &parent_objp->orient.vec.fvec, -25.0f);

-	// Start with parent velocity
-	vel = parent_objp->phys_info.vel;
+	//Get random velocity vector
+	static_randvec(arand+1, &rand_vec);

-	// Normalize direction
-	vec3d local_dir = wip->cm_launch_vec;
-	if (vm_vec_mag_squared(&local_dir) > 0.0f) {
-		vm_vec_normalize(&local_dir);
-	}
-
-	// Convert from ship to world space
-	vm_vec_unrotate(&world_dir, &local_dir, &parent_objp->orient);
-
-	// Apply launch impulse
-	vm_vec_scale_add2(&vel, &world_dir, wip->cm_launch_speed);
-
-	// Add random variance
-	static_randvec(arand + 1, &rand_vec);
-	vm_vec_scale_add2(&vel, &rand_vec, wip->cm_launch_variance);
+	//Add it to the rear velocity
+	vm_vec_scale_add2(&vel, &rand_vec, 2.0f);

 	objp->phys_info.vel = vel;

@@ -59,16 +44,17 @@ void cmeasure_set_ship_launch_vel(object* objp, object* parent_objp, int arand)
 	vm_vec_zero(&objp->phys_info.rotvel);
 	vm_vec_zero(&objp->phys_info.max_vel);
 	vm_vec_zero(&objp->phys_info.max_rotvel);
-
+	
 	// blow out his reverse thrusters. Or drag, same thing.
 	objp->phys_info.rotdamp = 10000.0f;
 	objp->phys_info.side_slip_time_const = 10000.0f;

-	// Desired velocity should align with launch direction, not hardcoded backward
-	vm_vec_copy_scale(&objp->phys_info.desired_vel, &world_dir, wip->cm_launch_speed);
+	objp->phys_info.max_vel.xyz.z = -25.0f;
+	vm_vec_copy_scale(&objp->phys_info.desired_vel, &objp->orient.vec.fvec, objp->phys_info.max_vel.xyz.z );

 	// if this cmeasure has a single segment trail, let the trail know since we just changed the velocity
 	// yeah this is hacky but that's what this function gets for CHANGING the velocity on objects with a ""CONSTANT VELOCITY""
+	weapon* wp = &Weapons[objp->instance];
 	if (wp->trail_ptr && wp->trail_ptr->single_segment) {
 		wp->trail_ptr->vel[0] = objp->phys_info.vel;
 		wp->trail_ptr->vel[1] = objp->phys_info.vel;
@@ -10,7 +10,6 @@



-#include "camera/photomode.h"
 #include "cfile/cfile.h"
 #include "cmdline/cmdline.h"
 #include "controlconfig/controlsconfig.h"
@@ -621,11 +620,6 @@ void control_config_conflict_check()
 				continue;
 			}

-			// Skip conflict check between items in different conflict groups
-			if ((item_i.conflict_groups & item_j.conflict_groups) == 0) {
-				continue;
-			}
-
 			if (item_i.disabled && (item_i.has_first_conflict(item_j) || item_i.has_second_conflict(item_j))) {
 				// item_i conflicts with item_j and is disabled.  Silently clear item_i
 				item_i.clear();
@@ -739,7 +733,7 @@ void control_config_bind(int i, const CC_bind &new_bind, selItem order, bool API
 	Undo_stack stack;
 	stack.save(Control_config[i].first);
 	stack.save(Control_config[i].second);
-	Undo_controls.save_stack(std::move(stack));
+	Undo_controls.save_stack(stack);

 	CCB old(Control_config[i]);

@@ -770,7 +764,7 @@ bool control_config_remove_binding(int ctrl, selItem item, bool API_Access)

 			stack.save(Control_config[ctrl].first);
 			stack.save(Control_config[ctrl].second);
-			Undo_controls.save_stack(std::move(stack));
+			Undo_controls.save_stack(stack);

 			Control_config[ctrl].first.clear();
 			Control_config[ctrl].second.clear();
@@ -804,7 +798,7 @@ bool control_config_remove_binding(int ctrl, selItem item, bool API_Access)

 	default:
 		// Coder forgot to add a case!
-		UNREACHABLE("Unhandled selItem case: %i", static_cast<int>(item));
+		UNREACHABLE("Unhandled selItem case.");
 	}

 	if (success)
@@ -873,7 +867,7 @@ bool control_config_clear_other(int ctrl, bool API_Access)
 		return false;
 	}

-	Undo_controls.save_stack(std::move(stack));
+	Undo_controls.save_stack(stack);
 	control_config_conflict_check();

 	if (!API_Access) {
@@ -911,7 +905,7 @@ bool control_config_clear_all(bool API_Access)
 		return false;
 	}

-	Undo_controls.save_stack(std::move(stack));
+	Undo_controls.save_stack(stack);
 	control_config_conflict_check();

 	if (!API_Access) {
@@ -975,7 +969,7 @@ bool control_config_do_reset(bool cycle, bool API_Access)
 		stack.save(item.first);
 		stack.save(item.second);
 	}
-	Undo_controls.save_stack(std::move(stack));
+	Undo_controls.save_stack(stack);

 	control_config_use_preset(Control_config_presets[Defaults_cycle_pos]);

@@ -1097,7 +1091,7 @@ bool control_config_toggle_modifier(int bit, int ctrl, bool API_Access)
 	Undo_stack stack;
 	stack.save(Control_config[ctrl].first);
 	stack.save(Control_config[ctrl].second);
-	Undo_controls.save_stack(std::move(stack));
+	Undo_controls.save_stack(stack);

 	Control_config[ctrl].take(CC_bind(CID_KEYBOARD, static_cast<short>(k ^ bit)), -1);
 	control_config_conflict_check();
@@ -1304,8 +1298,7 @@ bool control_config_accept(bool API_Access)
 			cstr = popup_input(flags,
 				XSTR( "Confirm new custom preset name.\n\nThe name must not be empty or a default preset.\n\n Press [Enter] to accept, [Esc] to abort to config menu.", 1867),
 				32 - 6,
-				default_string.c_str(),
-				"-_");
+				default_string.c_str());
 			if (cstr == nullptr) {
 				// Abort
 				gamesnd_play_iface(InterfaceSounds::USER_SELECT);
@@ -1322,7 +1315,7 @@ bool control_config_accept(bool API_Access)

 			// Check if a hardcoded preset with name already exists. If so, complain to user and force retry
 			auto it = std::find_if(Control_config_presets.begin(), Control_config_presets.end(), [str](CC_preset& p) {
-				return ((p.name == str) && ((p.get_type() == Preset_t::tbl) || (p.get_type() == Preset_t::hardcode)));
+				return ((p.name == str) && ((p.type == Preset_t::tbl) || (p.type == Preset_t::hardcode)));
 			});

 			if (it != Control_config_presets.end()) {
@@ -1353,14 +1346,15 @@ bool control_config_accept(bool API_Access)
 			}

 			// Pack the current bindings into a preset, then save the file
-			CC_preset preset(std::move(str), Preset_t::pst);
+			CC_preset preset;
+			preset.name = std::move(str);
 			std::copy(Control_config.begin(), Control_config.end(), std::back_inserter(preset.bindings));
 			Control_config_presets.push_back(preset);
 			save_preset_file(preset, true);

 			// Reload the presets from file. Do this instead of just pushing the preset to the vector direct to get
 			// consistant ordering
-			Control_config_presets.erase(Control_config_presets.begin() + 1, Control_config_presets.end());
+			Control_config_presets.resize(1);
 			load_preset_files();

 			// finally, save the new preset so that changes will get saved to this preset
@@ -1777,7 +1771,7 @@ bool control_config_create_new_preset(const SCP_string& newName, bool overwrite)

 	// Check if a hardcoded preset with name already exists. If so, complain to user and force retry
 	auto it = std::find_if(Control_config_presets.begin(), Control_config_presets.end(), [newName](CC_preset& p) {
-		return (p.name == newName) && ((p.get_type() == Preset_t::tbl) || (p.get_type() == Preset_t::hardcode));
+		return (p.name == newName) && ((p.type == Preset_t::tbl) || (p.type == Preset_t::hardcode));
 	});

 	if (it != Control_config_presets.end()) {
@@ -1790,7 +1784,9 @@ bool control_config_create_new_preset(const SCP_string& newName, bool overwrite)
 	}

 	// Pack the current bindings into a preset, then save the file
-	CC_preset preset(newName, Preset_t::pst);
+	CC_preset preset;
+	preset.name = newName;
+	preset.type = Preset_t::pst;
 	std::copy(Control_config.begin(), Control_config.end(), std::back_inserter(preset.bindings));

 	// Done with the file
@@ -1802,7 +1798,7 @@ bool control_config_create_new_preset(const SCP_string& newName, bool overwrite)
 		save_preset_file(preset, true);

 		// Reload the presets from file.
-		Control_config_presets.erase(Control_config_presets.begin() + 1, Control_config_presets.end());
+		Control_config_presets.resize(1);
 		load_preset_files(newName);

 		// use the newly created preset
@@ -1810,9 +1806,10 @@ bool control_config_create_new_preset(const SCP_string& newName, bool overwrite)

 		return true;

-	} else if ((clone->name != preset.name) || (clone->get_type() != Preset_t::pst)) {
+	} else if ((clone->name != preset.name) || (clone->type != Preset_t::pst)) {
 		// Complain and ignore if the preset names or the type differs
 		return false;
+
 	}

 	return false; //should be unreachable, but just in case
@@ -1822,7 +1819,7 @@ bool control_config_clone_preset(const CC_preset& preset, const SCP_string& newN

 	// Check if a hardcoded preset with name already exists. If so, complain to user and force retry
 	auto it = std::find_if(Control_config_presets.begin(), Control_config_presets.end(), [newName](CC_preset& p) {
-		return (p.name == newName) && ((p.get_type() == Preset_t::tbl) || (p.get_type() == Preset_t::hardcode));
+		return (p.name == newName) && ((p.type == Preset_t::tbl) || (p.type == Preset_t::hardcode));
 	});

 	if (it != Control_config_presets.end()) {
@@ -1834,13 +1831,13 @@ bool control_config_clone_preset(const CC_preset& preset, const SCP_string& newN
 		return false;
 	}

-	CC_preset newPreset(newName, Preset_t::pst);
-	newPreset.bindings = preset.bindings;
+	CC_preset newPreset = preset;
+	newPreset.name = newName;

 	bool success = save_preset_file(newPreset, false);

 	// Reload the presets from file.
-	Control_config_presets.erase(Control_config_presets.begin() + 1, Control_config_presets.end());
+	Control_config_presets.resize(1);
 	load_preset_files(newName);

 	// use the newly cloned preset
@@ -2087,6 +2084,7 @@ int control_config_bind_key_on_frame(int ctrl, selItem item, bool API_Access)

 		if (!done && bind) {
 			if (!Axis_override.empty()) {
+				control_config_bind(ctrl, Axis_override, item, API_Access);
 				control_config_bind(ctrl, Axis_override, item, API_Access);
 				done = true;
 				strcpy_s(bound_string, Axis_override.textify().c_str());
@@ -2720,7 +2718,8 @@ void control_config_do_frame(float frametime)
 			strcpy_s(buf, Control_config[i].text.c_str());
 		}

-		w = font::force_fit_string(buf, 255, Conflict_wnd_coords[gr_screen.res][CONTROL_W_COORD]);
+		font::force_fit_string(buf, 255, Conflict_wnd_coords[gr_screen.res][CONTROL_W_COORD]);
+		gr_get_string_size(&w, NULL, buf);
 		gr_printf_menu(x - w / 2, y, "%s", buf);

 	} else if (*bound_string) {
@@ -2803,22 +2802,8 @@ void control_check_indicate()
 	Control_check_count = 0;
 }

-/**
- * @brief Checks if a control is being used by the player this frame by checking the bound control input bindings.
- * 
- * @param[in] id    The IoActionId of the control to check
- * @param[in] key   DO NOT USE.  Key combination acquired from game_poll(), or -1 to check against a previous poll
- * 
- * @returns 0 If the control was disabled by a mod, or
- * @returns 0 If locked by a script, or
- * @returns 0 If controls need to be ignored for multiplayer, or
- * @returns 0 If the control wasn't used, or
- * @returns 1 If the control was used
- */
 int check_control_used(int id, int key)
 {
-	// Make sure mouse_down() is only called once during any logic path, 
-	// or the mousewheel may be decayed multiple times!!
 	int mask;
 	static int last_key = 0;
 	auto & item = Control_config[id];
@@ -2838,19 +2823,12 @@ int check_control_used(int id, int key)
 	if (item.disabled || item.locked)
 		return 0;

-	// Filter actions based on conflict groups and current mode
-	{
-		int active_group = game_is_photo_mode_active() ? CONFLICT_GROUP_PHOTO_MODE : CONFLICT_GROUP_DEFAULT;
-		if (!(item.conflict_groups & active_group))
-			return 0;
-	}
-
 	short z = item.get_btn(CID_KEYBOARD);	// Get the key that's bound to this control

 	if (item.type == CC_TYPE_CONTINUOUS) {
 		
-		// this is awful, need to make a reverse lookup table to do 
-		// button -> control instead of this control -> button nonsense.
+		// this is awful, need to make a reverse lookup table to do button -> control instead of this control -> button
+		// nonsense.
 		if ((joy_down(item.first) || joy_down_count(item.first, 1)) ||
 			(joy_down(item.second) || joy_down_count(item.second, 1))) {
 			// Joy button bound to this control was pressed, control activated
@@ -2860,7 +2838,7 @@ int check_control_used(int id, int key)

 		if ((mouse_down(item.first) || mouse_down_count(item.first, 1)) ||
 			(mouse_down(item.second) || mouse_down_count(item.second, 1))) {
-			// Mouse button bound to this control was pressed, control activated
+			// Joy button bound to this control was pressed, control activated
 			control_used(id);
 			return 1;
 		}
@@ -2906,15 +2884,6 @@ int check_control_used(int id, int key)
 		return 1;
 	}

-	// special case to allow actual mouse wheel to work with trigger controls --wookieejedi
-	if (item.type == CC_TYPE_TRIGGER) {
-		if ( mouse_down(item.first, true) || mouse_down(item.second, true) ) {
-			// Mouse wheel bound to this trigger control was pressed, control activated
-			control_used(id);
-			return 1;
-		}
-	}
-
 	return 0;
 }

@@ -3116,7 +3085,7 @@ void control_get_axes_readings(int *axis_v, float frame_time)
 			case CC_TYPE_AXIS_BTN_POS:
 			default:
 				//This should never happen, especially with the above Assertion. This is required as incomplete switches on an enum generate warnings
-				UNREACHABLE("Unhandled control item type %d", static_cast<int>(item.type));
+				UNREACHABLE("Unhandled control item type");
 				break;
 			}
 		}
@@ -297,24 +297,10 @@ enum IoActionId : int {
 	JOY_ABS_THROTTLE_AXIS							= 127,
 	JOY_REL_THROTTLE_AXIS							= 128,

-	//!< @n
-	//! Communication menu controls
-	//! ----------------------------
-	COMMS_MENU_MOVE_UP,
-	COMMS_MENU_MOVE_DOWN,
-	COMMS_MENU_SELECT,
-
 	TOGGLE_HUD_SHADOWS,

 	CYCLE_PRIMARY_WEAPON_PATTERN,

-	TOGGLE_PHOTO_MODE,
-	PHOTO_MODE_FILTER_PREV,
-	PHOTO_MODE_FILTER_NEXT,
-	PHOTO_MODE_FILTER_RESET,
-	PHOTO_MODE_PARAM_DECREASE,
-	PHOTO_MODE_PARAM_INCREASE,
-
 	/*!
 	 * This must always be below the last defined item
 	 */
@@ -572,38 +558,26 @@ public:
 * A preset, a collection of bindings for use in Control_config with an associated name
 */
 class CC_preset {
-  public:
+public:
 	SCP_vector<CCB> bindings;
 	SCP_string name;
+	Preset_t type = Preset_t::hardcode;

-  private:
-	// No default value: the type is always set explicitly by the constructor
-	Preset_t type;
+public:
+	CC_preset() = default;
+	CC_preset(const CC_preset& A) = default;

-  public:
-	// No default constructor: every preset must be created with an explicit type
-	CC_preset(SCP_string preset_name, Preset_t preset_type) : name(std::move(preset_name)), type(preset_type) {}
-	CC_preset(const CC_preset&) = default;
-
-	// Preserve target's preset type during copy assignment
-	CC_preset& operator=(const CC_preset& other);
-
-	Preset_t get_type() const
-	{
-		return type;
-	}
-
-	bool is_duplicate_of(const CC_preset& other) const;
+	CC_preset& operator=(const CC_preset&);
+	/*!
+	 * Checks if the given preset is a duplicate of this one
+	 */
+	bool is_duplicate_of(CC_preset&);
 };

 /*!
 * Control configuration item type.
 * @detail Contains binding info, documentation, behavior, etc. for a single control
 */
-// Conflict group bitmasks. Bindings only conflict if their groups overlap (bitwise AND != 0).
-static const int CONFLICT_GROUP_DEFAULT    = (1 << 0);  //!< Standard gameplay bindings
-static const int CONFLICT_GROUP_PHOTO_MODE = (1 << 1);  //!< Bindings used within photo mode
-
 class CCI : public CCB {
 public:
 // Inherited from CCB
@@ -612,7 +586,6 @@ public:

 // Items Set in menu
 	char tab;               //!< what tab (category) it belongs in
-	int  conflict_groups = CONFLICT_GROUP_DEFAULT;  //!< Bitmask of conflict groups. Bindings only conflict with others sharing at least one group.
 	int  indexXSTR;         //!< what string index we should use to translate this with an XSTR 0 = None, 1= Use item index + CONTROL_CONFIG_XSTR, 2 <= use CCI::indexXSTR directly
 	SCP_string text;        //!< describes the action in the config screen

@@ -685,7 +658,7 @@ public:
 	 *   If the type is CC_TYPE_TRIGGER or CC_TYPE_CONTINOUS, the primary is assumed to be a key combo and secondary is assumed to be a joy button.
 	 *   If the type is CC_TYPE_AXIS_ABS, CC_TYPE_AXIS_REL, CC_TYPE_AXIS_BTN_POS, or CC_TYPE_AXIS_BTN_NEG, the primary is a Joy0 axis and the secondary is a Mouse axis
 	 */
-	CCI_builder& operator()(IoActionId action_id, short primary, short secondary, char tab, int indexXSTR, const char *text, CC_type type, bool disabled = false, int conflict_groups = CONFLICT_GROUP_DEFAULT);
+	CCI_builder& operator()(IoActionId action_id, short primary, short secondary, char tab, int indexXSTR, const char *text, CC_type type, bool disabled = false);

 private:
 	CCI_builder();	// Only one builder per Control Config, so a default constructor is useless
@@ -964,12 +937,8 @@ float check_control_timef(int id);
 * @brief Wrapper for check_control_used. Allows the game to ignore the key if told to do so by the ignore-key SEXP.
 *
 * @param[in] id    The IoActionId of the control to check
- * @param[in] key   DO NOT USE OUTSIDE OF THE MAIN LOOP.  Key combination acquired from game_poll(), or -1 to check against a previous poll
+ * @param[in] key   The key combo to check against the control. If -1, re-check the last key passed to this function
 *
- * @returns 0 If the control was disabled by a mod, or
- * @returns 0 If locked by a script, or
- * @returns 0 If controls need to be ignored for multiplayer, or
- * @returns 0 If a script is handling the control execution, or
 * @returns 0 If the control wasn't used, or
 * @returns 1 If the control was used
 *
Author	SHA1	Message	Date
Tyler Blount	0945dee99e	Update test-pull_request.yaml	2025-06-09 09:51:29 -07:00
Tyler Blount	9e8003bd8a	Update build-test.yaml	2025-06-09 09:50:22 -07:00
Tyler Blount	47d77aa9d5	Update build-release.yaml	2025-06-09 09:49:15 -07:00
Tyler Blount	2b49a0d780	Update nightly build to use windows 2022	2025-06-09 09:47:05 -07:00