Automated build commit

2026-11-09 04:49:39 -10:00 · 2022-08-06 23:23:14 +00:00
1959 changed files with 191558 additions and 321897 deletions
@@ -4,28 +4,20 @@ modernize-*,\
 -modernize-avoid-c-arrays,\
 -modernize-make-unique,\
 -modernize-raw-string-literal,\
-modernize-use-default-member-init,\
-modernize-use-nodiscard,\
 -modernize-use-trailing-return-type,\
 -modernize-use-using,\
 performance-*,\
-performance-no-int-to-ptr,\
 -performance-type-promotion-in-math-fn,\
 misc-*,\
-misc-include-cleaner,\
 -misc-macro-parentheses,\
 -misc-misplaced-widening-cast,\
-misc-no-recursion,\
 -misc-non-private-member-variables-in-classes,\
 -misc-static-assert,\
 -misc-unused-parameters,\
-misc-use-anonymous-namespace,\
 readability-*,\
 -readability-avoid-const-params-in-decls,\
 -readability-else-after-return,\
-readability-function-cognitive-complexity,\
 -readability-function-size,\
-readability-identifier-length,\
 -readability-identifier-naming,\
 -readability-implicit-bool-conversion,\
 -readability-inconsistent-declaration-parameter-name,\
@@ -37,13 +29,10 @@ readability-*,\
 "
 WarningsAsErrors: ''
 HeaderFilterRegex: 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$'
+AnalyzeTemporaryDtors: false
 CheckOptions:
  - key:          'misc-assert-side-effect.AssertMacros'
    value:        'assert,Assert,Assertion'
-  - key:          'misc-const-correctness.AnalyzeValues'
-    value:        'false'
-  - key:          'misc-const-correctness.TransformValues'
-    value:        'false'
  - key:          'modernize-use-emplace.ContainersWithPushBack'
    value:        'std::vector;std::deque;std::list;SCP_vector;SCP_deque;SCP_list'
  - key:          'readability-braces-around-statements.ShortStatementLines'
@@ -1,6 +1,14 @@

+cmake/ @asarium
+
 ci/ @asarium @z64555

+code/executor/ @asarium
+
+code/scpui/ @asarium
+
+code/scripting/ @asarium
+
 code/controlconfig/ @z64555

 code/model/modelanimation*.* @bmagnu
@@ -6,23 +6,32 @@ on:
      - 'nightly_*'

 env:
-  QT_VERSION: 5.12.12
+  QT_VERSION: 5.12.9

 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-71099c9
+    runs-on: ubuntu-latest
+    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        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-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
      - uses: actions/checkout@v1
        name: Checkout
        with:
@@ -30,8 +39,7 @@ jobs:
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-          ENABLE_QTFRED: OFF
+          COMPILER: gcc-5
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
@@ -51,18 +59,15 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        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-748b19d
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
    steps:
      - uses: actions/checkout@v1
        name: Checkout
@@ -70,23 +75,17 @@ jobs:
          submodules: true
          fetch-depth: '0'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v1
        with:
-          name: linux-Release-${{ matrix.arch }}
+          name: linux-Release
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        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
@@ -104,42 +103,37 @@ jobs:
        arch: [Win32, x64]
        simd: [SSE2]
    name: Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
    steps:
      - uses: actions/checkout@v1
        name: Checkout
        with:
          submodules: true
-      # - 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]
+      - name: Cache Qt
+        id: cache-qt-win
+        uses: actions/cache@v1
        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
+          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: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -150,19 +144,11 @@ jobs:
          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
+          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
+            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
+            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+            -G "Visual Studio 16 2019" -T "v142" ..
      - name: Compile
        working-directory: ./build
        env:
@@ -179,7 +165,7 @@ jobs:
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*
@@ -199,12 +185,12 @@ jobs:
          submodules: true
          fetch-depth: '0'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v1
        with:
          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
@@ -230,36 +216,30 @@ jobs:
      matrix:
        configuration: [FastDebug, Release]
        compiler: [clang]
-        arch: [x86_64, arm64]
+        arch: [x86_64]
    name: Mac
    runs-on: macos-latest
    steps:
-      # - 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.*'
+      - 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
-      - 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: |
@@ -272,7 +252,6 @@ 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
@@ -281,39 +260,21 @@ jobs:
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
          XDG_RUNTIME_DIR: /root
        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # Ref: https://github.com/actions/runner-images/issues/2619
-        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
+        working-directory: ./build
+        run: cd bin && tar -cvzf macos-build.tar *.app
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
+          name: mac-${{ matrix.configuration }}
+          path: ${{ github.workspace }}/build/bin/macos-build.tar
  mac_zip:
    name: Build Mac distribution zip
    needs: build_mac
    runs-on: ubuntu-latest
    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
    steps:
      - uses: actions/checkout@v2
        name: Checkout
@@ -322,24 +283,17 @@ jobs:
          fetch-depth: '0'
          ref: '${{ github.ref }}'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
-          name: mac-Release-${{ matrix.arch }}
+          name: mac-Release
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
-          name: mac-FastDebug-${{ matrix.arch }}
+          name: mac-FastDebug
          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
      - name: Create Distribution package
        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
      - name: Upload result package
        working-directory: ./builds
@@ -6,7 +6,7 @@ on:
      - 'release_*'

 env:
-  QT_VERSION: 5.12.12
+  QT_VERSION: 5.12.9

 jobs:
  create_release:
@@ -41,28 +41,62 @@ jobs:
        # Run this job for each configuration
        # The current config running is accesible with `matrix.configuration`
        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
    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-71099c9
+    runs-on: ubuntu-latest
+    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        uses: actions/cache@v1
+        # cache the Qt directory so we don't have to reinstall it every time
+        # cache.inputs:
+        #   path - A list of files, directories, and wildcard patterns to cache and restore. See @actions/glob for supported patterns.
+        #   key - An explicit key for restoring and saving the cache
+        #   restore-keys - An ordered list of keys to use for restoring the cache if no cache hit occurred for key
+        # cache.outputs:
+        #   cache-hit   true when an exact match was found for the key, false otherwise.
+        with:
+          path: ${{ github.workspace }}/../Qt
+          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v2
+        # installs Qt in the action workflow
+        # install-qt-action.inputs:
+        #   version     desired qt version to install
+        #   host        Host platform of Qt, default to platform used by runs-on
+        #   target      target platform of Qt, default to desktop
+        #   arch        target architecture of Qt, only used for windows or android builds
+        #   dir         root dir Qt will be installed to
+        #   install-deps    if true, auto-install dependencies on linux. Default true
+        #   modules     whitespace delimited list string of additional addon modules to install
+        #   archives    whitespace delimited list string of Qt archives to install
+        #   cached      if true, Don't download Qt but set ENVARs; use with cache.outputs.cache-hit
+        #   setup-python    Set to false to skip using setup-python to find/download a valid python version
+        #   set-env     if true, set ENVARs; default = false
+        #   aqtversion  version of aqtinstall to use; default = 2.0.0
+        #   py7zrversion    version of py7zr to use; default = 0.16.1
+        #   extra       additional arguments to pass to aqinstall
+        # ENVARS set:
+        #   Qt5_DIR / Qt6_DIR
+        #   Qt bin dir appended to PATH
+        #   QT_PLUGIN_PATH, QML2_IMPORT_PATH, PKG_CONFIG_PATH, LD_LIBRARY_PATH
+        with:
+          version: ${{ env.QT_VERSION }}
+          dir: ${{ github.workspace }}/..
+          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
      - 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: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-          ENABLE_QTFRED: OFF
+          COMPILER: gcc-5
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
@@ -82,7 +116,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@v4
+        uses: actions/upload-artifact@v2
        # 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.
@@ -93,49 +127,39 @@ jobs:
        #       0     Use default retention policy of the repo
        #       1~90  Min 1, Max 90 days to keep the artifact unless changed by repo settings page
        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-748b19d
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
    steps:
      - 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: Download Release builds
        # Grab the release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
-          name: linux-Release-${{ matrix.arch }}
+          name: linux-Release
          path: builds
      - name: Download FastDebug builds
        # Grab the debug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        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
        # Zip both builds together
        id: generate_package
        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
      - name: Upload result package
        # Stash the result to artifact filespace
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: ${{ steps.generate_package.outputs.package_name }}
          path: ${{ steps.generate_package.outputs.package_path }}
@@ -155,47 +179,41 @@ jobs:
        simd: [SSE2, AVX]
    needs: create_release
    name: Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
    steps:
      - uses: actions/checkout@v1
        # Checkout repo
        name: Checkout
        with:
          submodules: true
-          ref: '${{ github.ref }}'
-      # - 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]
+      - name: Cache Qt
+        # Cache Qt
+        id: cache-qt-win
+        uses: actions/cache@v1
        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
+          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: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -206,19 +224,11 @@ jobs:
          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
+          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
+            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
+            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+            -G "Visual Studio 16 2019" -T "v142" ..
      - name: Compile
        working-directory: ./build
        env:
@@ -235,7 +245,7 @@ jobs:
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*
@@ -257,15 +267,15 @@ jobs:
        with:
          submodules: true
          fetch-depth: '0'
-          ref: '${{ github.ref }}'
+
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds

      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
@@ -280,13 +290,13 @@ jobs:
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows

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

      - name: Upload debug package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: ${{ steps.generate_package.outputs.debug_name }}
          path: ${{ steps.generate_package.outputs.debug_path }}
@@ -300,137 +310,11 @@ jobs:
            ${{ steps.generate_package.outputs.package_path }}
            ${{ steps.generate_package.outputs.debug_path }}

-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-    name: Mac
-    needs: create_release
-    runs-on: macos-latest
-    steps:
-      # - 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: 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: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
-      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # 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@v4
-        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v4
-        with:
-          name: mac-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
-        with:
-          name: mac-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-      - name: Publish result package
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: ${{ steps.generate_package.outputs.package_path }}
-
  post_build:
    name: Post builds to Nebula and Forum
-    needs: [linux_zip, windows_zip, mac_zip]
+    needs: [linux_zip, windows_zip]
    uses: ./.github/workflows/post-build-release.yaml
    with:
      linux_result: ${{ needs.linux_zip.result }}
      windows_result: ${{ needs.windows_zip.result }}
-      mac_result: ${{ needs.mac_zip.result }}
      releaseTag: ${{ github.ref_name }}
-    secrets: inherit
@@ -0,0 +1,53 @@
+name: Publish Standalone docker image
+
+on:
+  push:
+    tags:
+    - 'nightly_*'
+    - 'release_*'
+
+jobs:
+  build_images:
+    if: github.repository == 'scp-fs2open/fs2open.github.com'
+    strategy:
+      matrix:
+        configuration: [FastDebug, Release]
+        include:
+        - configuration: FastDebug
+          tag_suffix: -debug
+        - configuration: Release
+          tag_suffix: ""
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+      name: Checkout
+      with:
+        submodules: true
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v1
+
+    - name: Docker meta
+      id: docker_meta
+      uses: crazy-max/ghaction-docker-meta@v1
+      with:
+        images: ghcr.io/scp-fs2open/standalone_server
+        tag-latest: false
+
+    - name: Login to GitHub Docker Registry
+      uses: docker/login-action@v1
+      with:
+        registry: ghcr.io
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.CR_PAT }}
+    - name: Build and push
+      id: docker_build
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./docker/standalone/Dockerfile
+        push: true
+        tags: ${{ steps.docker_meta.outputs.tags }}${{ matrix.tag_suffix }}
+        labels: ${{ steps.docker_meta.outputs.labels }}
+        build-args: |
+          build_type=${{ matrix.configuration }}
@@ -6,7 +6,7 @@ on:
      - 'test/*'

 env:
-  QT_VERSION: 5.12.12
+  QT_VERSION: 5.12.9

 jobs:
  build_linux:
@@ -15,8 +15,23 @@ jobs:
        configuration: [FastDebug, Release]
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
+    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        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-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
      - uses: actions/checkout@v1
        name: Checkout
        with:
@@ -30,8 +45,7 @@ jobs:
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-          ENABLE_QTFRED: OFF
+          COMPILER: gcc-5
        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
      - name: Compile
        working-directory: ./build
@@ -51,7 +65,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@v4
+        uses: actions/upload-artifact@v2
        with:
          name: linux-${{ matrix.configuration }}
          path: ${{ github.workspace }}/build/install/*.AppImage
@@ -68,12 +82,12 @@ jobs:
          fetch-depth: '0'
          ref: '${{ github.ref }}'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v1
        with:
          name: linux-Release
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
          name: linux-FastDebug
          path: builds
@@ -96,7 +110,7 @@ jobs:
        arch: [Win32, x64]
        simd: [SSE2]
    name: Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
    steps:
      - uses: actions/checkout@v1
        name: Checkout
@@ -108,36 +122,31 @@ jobs:
          [[ "${{ 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: 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]
+      - name: Cache Qt
+        id: cache-qt-win
+        uses: actions/cache@v1
        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
+          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: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -148,19 +157,11 @@ jobs:
          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
+          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
+            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
+            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
+            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
+            -G "Visual Studio 16 2019" -T "v142" ..
      - name: Compile
        working-directory: ./build
        env:
@@ -177,7 +178,7 @@ jobs:
        shell: bash
        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
          path: ${{ github.workspace }}/build/install/*
@@ -198,12 +199,12 @@ jobs:
          fetch-depth: '0'
          ref: '${{ github.ref }}'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v1
        with:
          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
@@ -229,36 +230,30 @@ jobs:
      matrix:
        configuration: [FastDebug, Release]
        compiler: [clang]
-        arch: [x86_64, arm64]
+        arch: [x86_64]
    name: Mac
    runs-on: macos-latest
    steps:
-      # - 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.*'
+      - 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
-      - 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: |
@@ -270,7 +265,6 @@ 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
@@ -279,39 +273,21 @@ jobs:
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
          XDG_RUNTIME_DIR: /root
        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # Ref: https://github.com/actions/runner-images/issues/2619
-        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
+        working-directory: ./build
+        run: cd bin && tar -cvzf macos-build.tar *.app
      - name: Upload build result
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
+          name: mac-${{ matrix.configuration }}
+          path: ${{ github.workspace }}/build/bin/macos-build.tar
  mac_zip:
    name: Build Mac distribution zip
    needs: build_mac
    runs-on: ubuntu-latest
    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
    steps:
      - uses: actions/checkout@v2
        name: Checkout
@@ -320,24 +296,17 @@ jobs:
          fetch-depth: '0'
          ref: '${{ github.ref }}'
      - name: Download Release builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
-          name: mac-Release-${{ matrix.arch }}
+          name: mac-Release
          path: builds
      - name: Download FastDebug builds
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v2
        with:
-          name: mac-FastDebug-${{ matrix.arch }}
+          name: mac-FastDebug
          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
      - name: Create Distribution package
        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
      - name: Upload result package
        working-directory: ./builds
@@ -6,27 +6,42 @@ on:
      - master

 env:
-  QT_VERSION: 5.12.12
+  QT_VERSION: 5.12.9

 jobs:
  build_linux:
    strategy:
      matrix:
        configuration: [Debug, Release]
-        compiler: [gcc-9, gcc-13, clang-16]
+        compiler: [gcc-5, gcc-10]
        cmake_options: [""]
        include:
          # Also include configurations that check if the code compiles without the graphics backends
          - configuration: Debug
-            compiler: gcc-13
+            compiler: gcc-10
            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
          - configuration: Release
-            compiler: gcc-13
+            compiler: gcc-10
            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-71099c9
+    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        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-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
      - uses: actions/checkout@v1
        name: Checkout
        with:
@@ -35,22 +50,13 @@ jobs:
        uses: hendrikmuhs/ccache-action@v1
        with:
          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
-      - name: Configure ccache
-        run: |
-          ccache --set-config=sloppiness=pch_defines,time_macros
-          ccache -p

      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          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: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Show CCache statistics
-        run: ccache --show-stats
@@ -10,9 +10,6 @@ on:
      windows_result: # job.result
        required: true
        type: string
-      mac_result: # job.result
-        required: true
-        type: string
      releaseTag:
        required: true
        type: string
@@ -58,15 +55,6 @@ jobs:
        env:
          LINUX_RESULT: ${{ inputs.linux_result }}
          WINDOWS_RESULT: ${{ inputs.windows_result }}
-          MAC_RESULT: ${{ inputs.mac_result }}
-          GITHUB_REPO: ${{ github.repository }} # repo this workflow was called from
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          NEBULA_USER: ${{ secrets.NEBULA_USER }}
-          NEBULA_PASSWORD: ${{ secrets.NEBULA_PASSWORD }}
-          HLP_API: ${{ secrets.HLP_API }}
-          HLP_KEY: ${{ secrets.HLP_KEY }}
-          RELEASE_TAG: ${{ inputs.releaseTag }}
        run: python ci/post/main.py release

      - name: Post Builds (Manual trigger)
@@ -75,8 +63,7 @@ jobs:
        env:
          LINUX_RESULT: success
          WINDOWS_RESULT: success
-          MAC_RESULT: success
        run: |
          echo "releaseTag= ${{ env.RELEASE_TAG }}"
          echo "repository= ${{ github.repository }}"
-          python ci/post/main.py release
+          python ci/post/main.py release
@@ -3,33 +3,42 @@ name: Check a pull request
 on: [pull_request]

 env:
-  QT_VERSION: 5.12.12
+  QT_VERSION: 5.12.9

 jobs:
  build_linux:
    strategy:
      matrix:
        configuration: [Debug, Release]
-        compiler: [gcc-9, gcc-13, clang-16]
+        compiler: [gcc-5, gcc-10, clang-9]
        cmake_options: [""]
        include:
          # Also include configurations that check if the code compiles without the graphics backends
          - configuration: Debug
-            compiler: gcc-13
+            compiler: gcc-10
            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
          - configuration: Release
-            compiler: gcc-13
+            compiler: gcc-10
            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
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-71099c9
+    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        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-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
      - uses: actions/checkout@v1
        name: Checkout
        with:
@@ -39,18 +48,12 @@ jobs:
        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
-          verbose: 1
-      - name: Configure ccache
-        run: ccache --set-config=sloppiness=pch_defines,time_macros
+
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
          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
@@ -61,8 +64,6 @@ jobs:
          CONFIGURATION: ${{ matrix.configuration }}
          XDG_RUNTIME_DIR: /root
        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Show CCache statistics
-        run: ccache --show-stats
      - name: Run Clang Tidy
        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
        if: startsWith(matrix.compiler, 'clang-')
@@ -80,7 +81,7 @@ jobs:
        compiler: [MSVC]
        arch: [Win32, x64]
    name: Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
    steps:
      - name: Prepare Environment
        run: choco install ninja
@@ -88,36 +89,31 @@ jobs:
        name: Checkout
        with:
          submodules: true
-      # - 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]
+      - name: Cache Qt
+        id: cache-qt-win
+        uses: actions/cache@v1
        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
+          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: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -129,23 +125,12 @@ jobs:
          cd build

          if [ "$COMPILER" = "MinGW" ]; then
-              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
+              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" ..
          else
-              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
+              cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+                  -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "Visual Studio 16 2019" \
+                  -DFSO_BUILD_QTFRED=ON -T "v142" -A "$ARCHITECTURE" ..
          fi
      - name: Compile
        working-directory: ./build
@@ -177,26 +162,26 @@ jobs:
      matrix:
        configuration: [Debug, Release]
        compiler: [clang]
-        arch: [x86_64, arm64]
+        arch: [x86_64]
        cmake_options: [""]
    name: Mac
    runs-on: macos-latest
    steps:
-      # - 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.*'
+      - 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:
@@ -205,21 +190,14 @@ jobs:
      - name: ccache
        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: 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
+          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
+
      - 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
@@ -228,7 +206,6 @@ jobs:
        working-directory: ./build
        env:
          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
          XDG_RUNTIME_DIR: /root
        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
      - name: Run Clang Tidy
@@ -239,4 +216,4 @@ jobs:
        if: startsWith(matrix.compiler, 'clang-')
        uses: asarium/clang-tidy-action@v1
        with:
-          fixesFile: clang-fixes.yaml
+          fixesFile: clang-fixes.yaml
@@ -1,73 +0,0 @@
-name: Weekly Coverity Scan for Freespace Open
-# adapted from code by "albert-github" on the doxygen repository
-# many thanks for figuring this out first so it could be less painful for us!
-
-#This mode is for testing
-#on: [push, pull_request]
-
-# In production, push on a specific schedule
-on:
-  schedule:
-    - 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 }}
-
-jobs:
-  build:
-    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-71099c9
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - { name: "GCC on ubuntu", os: ubuntu-latest, build_type: "Release" }
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v1
-        with:
-          submodules: recursive # `true` to checkout submodules, `recursive` to recursively checkout submodules
-
-      # pipe results of wget to a log file because it's very verbose and rarely fails
-      - name: Install Coverity
-        run: |
-          wget -o wgetlog.txt -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=${{ env.coverity_token }}&project=scp-fs2open/fs2open.github.com" -O coverity_tool.tgz
-          mkdir cov-scan
-          tar ax -f coverity_tool.tgz --strip-components=1 -C cov-scan
-
-      - name: Setup Environment
-        run: |
-          echo "$(pwd)/cov-scan/bin" >> $GITHUB_PATH
-          echo "NPROC=$(getconf _NPROCESSORS_ONLN)" >> $GITHUB_ENV
-
-      - name: Configure CMake for FSO
-        env:
-          CONFIGURATION: Release
-          COMPILER: gcc-9
-          ENABLE_QTFRED: OFF
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-
-      - name: Build FSO with Coverity Wrapper
-        working-directory: ./build
-        env:
-          CONFIGURATION: Release
-        run: cov-build --dir cov-int ninja -k 20 all
-
-      - name: Compress Results
-        working-directory: ./build
-        run: tar zcf cov-scan.tgz cov-int
-
-      #Comment this out when testing to keep from running into upload limits
-      - name: Upload to Coverity
-        run: |
-          cd build
-          curl -X POST -d token=${{ env.coverity_token }} -d email=${{ env.coverity_email }} -d file_name="'cov-scan.tgz'" -d version=${{ github.ref }} -d description="Automatic GHA scan" 'https://scan.coverity.com/projects/870/builds/init' | tee response
-          upload_url=$(jq -r '.url' response)
-          build_id=$(jq -r '.build_id' response)
-          curl -X PUT --header 'Content-Type: application/json' --upload-file cov-scan.tgz $upload_url
-          curl -X PUT -d token=${{ env.coverity_token }} https://scan.coverity.com/projects/870/builds/$build_id/enqueue
@@ -250,7 +250,6 @@ documentation/doxygen/*
 projects/*
 /.vs
 CMakeSettings.json
-CMakePresets.json

 # Weird files created by Linux
 .fuse_hidden*
@@ -1,6 +1,6 @@
 [submodule "cmake/external/rpavlik-cmake-modules"]
 	path = cmake/external/rpavlik-cmake-modules
-	url = https://github.com/rpavlik/cmake-modules.git
+	url = https://github.com/asarium/cmake-modules.git
 [submodule "lib/libRocket"]
 	path = lib/libRocket
-	url = https://github.com/scp-fs2open/libRocket.git
+	url = https://github.com/asarium/libRocket.git
@@ -0,0 +1,175 @@
+language: bash
+sudo: required
+dist: xenial
+cache:
+  directories:
+    - $HOME/cmake-3.8
+    - $HOME/.ccache
+    - $HOME/curl_cache
+addons:
+  apt:
+    packages: &global_deps
+      - ninja-build
+      - libopenal-dev
+      - libreadline6-dev
+      - libpng12-dev
+      - libjpeg62-dev
+      - liblua5.1-0-dev
+      - libjansson-dev
+      - libsdl2-dev
+      - libfreetype6-dev
+      - qt57base
+  coverity_scan:
+    project:
+      name: "scp-fs2open/fs2open.github.com"
+    notification_email: [email protected]
+    build_command:   "ci/travis/script.sh"
+    # must match TRAVIS_BRANCH check below
+    branch_pattern: coverity_scan
+env:
+  global:
+    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+    #   via the "travis encrypt" command using the project repo's public key
+    #   also note that fork's don't get access to secure keys
+    #   you have to test using a branch in the main repo
+    - secure: "C3wF967ZeliwwP1vC12EMIBOaC568n26Z/cPnwzn317ve59DWH3YSfPZVgvt08GzmaXITGGsJvPB+qxfGoKvQzYE4O1B73q81RpUe5pB3IhF+ThQ91VfQZIRJR5xEGJaLINUlHTTZGX5jxlkVO9wAcauVj/s3b8sQ3dvUZauPvk="
+    # These declarations set INDIEGAMES_USER and INDIEGAMES_PASSWORD for uploading nightly builds to the indiegames server
+    - secure: "lUuRu8XIi8MKNf1ebOfyC4iVEpPyASojJIDWXRo2bNqEF4ILAljXdkVeXeN6H5yKCHD52cxCNTtyePIG/o3p3QEuGSVud9bDS3D7LaQicLETGGrsw3l07U49gF2OKHXGopg0MzBbZUU9QmhoFTAe8t6PV9NDuEayYCheqvTqjZg="
+    - secure: "E/DHLYcPK/hBUqxBYYlUqp5sjgvIqY5A0qRHyQ4bmjsB+WB/Xx71bGCSiF7hk6lTxar1ZI1i5RAXXh9AIvNVaYAIdEOlCP+q3gvwCYuc5naZEKmkxlUCf0oEL4O9Fye93A/3VkFHuBdC1TGPYYf69m4W5r4367wWO9dPRIdWpJA="
+    # These declarations set DATACORDER_USER and DATACORDER_PASSWORD
+    - secure: "dpBH/dDN3bmU/NFlh+2v9isNx9wX0ocoRy+W+kBXRH32sosUGp26REhMqgVRpBNP5oxPBU8ic5bEogxAYWCB+0xUygBbkxAwyMPgoA34s0OXdTCY/ofw14ni8qqV2Ffy7fQJbP/jkMURyiMHx3kBTxNv3YjxKJqLnOuOMlQLpT8="
+    - secure: "tLMRBD1Ufp5iKNwlqPDVbbuczgusaXNoBJyAnPATpJq2YwlkW4j3PqP9rW5vd85+52xam2EOP20w9PoBR5J6FLdiXRu4Lf7yCEhSHFAgowVqQj8QcJpPlyXr90bM4emFGrGqpdxVwxyQ5AFhKwLuEZKsI14GYLN+UMEwpNCMing="
+deploy:
+  - provider: releases
+    api_key:
+      secure: "q619+eQTe7lv8UVphK4OIzU8Jw84KBbVkuprN2sWIubRcV3IbZr2+WahJoUMt+nyhiy3YjDYtstO2ZgkxupwnZgwGUBVIiD1c4SPuyy+HTjNMOtiVsEUHT2hf+xPAemWpTlK5HcwhMmHAOh6rt6dEj57QOg0gcmGiwD/tCbEriA="
+    skip_cleanup: true
+    file_glob: true
+    file: "/tmp/builds/*"
+    on:
+      condition: '"$RELEASE_BUILD" == true'
+      tags: true
+
+  - provider: script
+    script: bash ci/travis/ftp_deploy.sh
+    on:
+      condition: '"$NIGHTLY_BUILD" == true'
+      tags: true
+
+  - provider: script
+    skip_cleanup: true
+    script: bash ci/travis/ftp_deploy.sh
+    on:
+      condition: $TEST_BUILD = true
+      all_branches: true
+
+matrix:
+  include:
+    # note that gcc Debug MUST be 1st for Coverity
+    - os: linux
+      env: CONFIGURATION="Debug" CC=gcc-5 CXX=g++-5
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-5
+    - os: linux
+      env: CONFIGURATION="Debug" CC=gcc-9 CXX=g++-9
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - g++-9
+            - *global_deps
+    - os: linux
+      env: CONFIGURATION="Debug" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-9
+      script:
+        - ./ci/travis/script.sh
+        - ./ci/travis/clang_tidy.sh
+    - os: osx
+      env: CONFIGURATION="Debug"
+
+    - os: windows
+      env: CONFIGURATION="Debug" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
+    - os: windows
+      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
+
+    - os: linux
+      env: CONFIGURATION="Release" CC=gcc-5 CXX=g++-5
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-5
+    - os: linux
+      env: CONFIGURATION="Release" CC=gcc-9 CXX=g++-9
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - g++-9
+            - *global_deps
+    - os: linux
+      env: CONFIGURATION="Release" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-9
+      script:
+        - ./ci/travis/script.sh
+        - ./ci/travis/clang_tidy.sh
+    - os: osx
+      env: CONFIGURATION="Release"
+
+    - os: windows
+      env: CONFIGURATION="Release" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
+    - os: windows
+      env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
+  # There is a GCC compiler bug with MinGW that causes compilation failures on Windows at the moment
+  allow_failures:
+    - os: windows
+      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
+    - os: windows
+      env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
+  fast_finish: true
+
+before_install:
+  # ugly hack; if running a coverity scan abort all except the 1st build
+  # see note re gcc compiler above needing to be 1st
+  # also note that branch_pattern & the TRAVIS_BRANCH check must match
+  # unfortunately COVERITY_SCAN_BRANCH isn't defined until later in the
+  # build process
+  - if ([[ "${TRAVIS_JOB_NUMBER##*.}" != "1" ]] && [[ "${TRAVIS_BRANCH}" == "coverity_scan" ]]); then false ; fi
+  - source "./ci/travis/check_release.sh"
+  - "./ci/travis/before_install.sh"
+install:
+  - if [ "$TRAVIS_OS_NAME" = "windows" ]; then export PATH="/c/Program Files/CMake/bin":$PATH; fi
+  - "./ci/travis/install.sh"
+  - export PATH=$HOME/cmake-3.6/bin:$PATH
+before_script:
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then QT_ENV_SCRIPT=$(find /opt -name 'qt*-env.sh'); source $QT_ENV_SCRIPT; fi
+  - "./ci/travis/before_script.sh"
+script:
+  - if [ "$BUILD_DEPLOYMENT" = true ] ; then ./ci/travis/release.sh ; else ./ci/travis/script.sh ; fi
@@ -1,5 +1,5 @@

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

 # Make sure the source and binary directory are not the sample
@@ -39,13 +39,26 @@ 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)
+PROJECT(FS2_Open)

-if(APPLE)
-	set(FSO_LANGUAGES ${FSO_LANGUAGES} OBJC OBJCXX)
+find_program(CCACHE_PROGRAM ccache)
+# Currently only GCC support ccache properly without generating additional warnings
+# Enable ccache on Mac even for clang
+if(CCACHE_PROGRAM AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR APPLE))
+	if(NOT CMAKE_C_COMPILER_LAUNCHER)
+		message(STATUS "Using ccache for C compilation: ${CCACHE_PROGRAM}")
+		SET(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+	endif()
+	if(NOT CMAKE_CXX_COMPILER_LAUNCHER)
+		message(STATUS "Using ccache for C++ compilation: ${CCACHE_PROGRAM}")
+		SET(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+	endif()
 endif()

-PROJECT(FS2_Open LANGUAGES ${FSO_LANGUAGES})
+IF(CMAKE_CROSSCOMPILING)
+	SET(IMPORT_EXE_DIR "IMPORT_EXE_DIR-NOTFOUND" CACHE FILEPATH "Required for a cross compiling build, point to binary directory of a cmake build for the real OS")
+	INCLUDE(${IMPORT_EXE_DIR}/ImportExecutables.cmake)
+ENDIF(CMAKE_CROSSCOMPILING)

 # Check if the external modules exists
 IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules/launcher-templates")
@@ -70,11 +83,9 @@ IF(RESET_INSTALL_PREFIX)
 	ENDIF(NOT $ENV{FS2PATH} STREQUAL "")
 ENDIF(RESET_INSTALL_PREFIX)

-IF(WIN32 OR APPLE)
-	OPTION(FSO_USE_SPEECH "Use text-to-speach libraries" ON)
-ENDIF(WIN32 OR APPLE)
-
 IF (WIN32)
+	OPTION(FSO_USE_SPEECH "Use Windows specific text-to-speach libraries" ON)
+
 	OPTION(FSO_USE_VOICEREC "Enable voice recognition support" ON)

 	OPTION(FSO_BUILD_FRED2 "Build FRED2 binary" ON)
@@ -117,27 +128,9 @@ 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)

-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_VULKAN "Enable compilation of the Vulkan renderer" OFF)
-
-IF(NOT APPLE)
-	SET(OPENXR_BUILD_DEFAULT ON)
-ELSE()
-	SET(OPENXR_BUILD_DEFAULT OFF)
-ENDIF()
-OPTION(FSO_BUILD_WITH_OPENXR "Build with OpenXR support" ${OPENXR_BUILD_DEFAULT})
-IF(FSO_BUILD_WITH_OPENXR AND APPLE)
-	MESSAGE(WARNING "FSO_BUILD_WITH_OPENXR is ON. Not supported on macOS - setting to OFF.")
-	SET(FSO_BUILD_WITH_OPENXR OFF CACHE BOOL "" FORCE)
-ENDIF()
-
-OPTION(FSO_BUILD_WITH_OPENXR_DEBUG "Enables debug option for OpenXR" OFF)
-
-OPTION(FSO_USE_LTO "Build using LTO (only for release builds)" ON)
+OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" ON)

 MARK_AS_ADVANCED(FORCE FSO_CMAKE_DEBUG)
 MARK_AS_ADVANCED(FORCE FSO_BUILD_INCLUDED_LIBS)
@@ -149,12 +142,8 @@ 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_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)
@@ -176,14 +165,6 @@ endif()

 include(clang-tidy)

-include(CheckIPOSupported)
-check_ipo_supported(RESULT LTO_AVAILABLE)
-if (CMAKE_BUILD_TYPE STREQUAL "Release" AND FSO_USE_LTO AND LTO_AVAILABLE)
-	set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
-	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)

@@ -227,10 +208,8 @@ include(package)
 include(doxygen)

 # Print used options to log
-IF(WIN32 OR APPLE)
-	message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
-ENDIF()
 IF (WIN32)
+	message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
 	message(STATUS "Using voice recogition: ${FSO_USE_VOICEREC}")
 	message(STATUS "Building FRED2: ${FSO_BUILD_FRED2}")
 elseif(UNIX)
@@ -241,7 +220,5 @@ message(STATUS "Building qtFRED: ${FSO_BUILD_QTFRED}")
 message(STATUS "Fatal warnings: ${FSO_FATAL_WARNINGS}")
 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 Vulkan: ${FSO_BUILD_WITH_VULKAN}")
-message(STATUS "With OpenXR: ${FSO_BUILD_WITH_OPENXR}")
@@ -3,185 +3,6 @@ All notable changes to this project will be documented in this file.

 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

-## [23.2.0] - 2023-06-16
-### Changes
-
-<details><summary> <b>Big Feature: MSAA</b> </summary>
-
-> The return of a long forgotten feature, with optimizations and improvements
-> Noticeable reduction to artifacts caused by subpixel geometry and glinting.
-</details>
-
-<details><summary> <b>Big Feature: SCPUI</b> </summary>
-
-> A modernized approach to defining menus in FS
-> Tired of having your Menus in FSO be at a resolution of potato? Use SCPUI to have them rendered from Fake-HTML to the actual screensize as opposed to a prebuilt graphics!
-> Tired of being limited to whatever people in the SCP hardcoded in for buttons? Use SCPUI to define buttons and all other manner of shenanigans as Lua-code just as you like.
-> Tired of needing to replace a bajillion interface graphics to reskin FSO? Use SCPUI, and especially Mjn's existing collection of Lua, CSS, Fake-HTML and images, and you only need to replace about 250 graphics.
-</details>
-
-<details><summary> <b>Big Feature: Localized Volumetric Nebulae</b> </summary>
-
-> Allows specifying a POF as the "hull" of a nebula, which will be rendered using ray marching
-> Further details can be found on the [GitHub Pull Request](https://github.com/scp-fs2open/fs2open.github.com/pull/5231)
-> Note: As this is a new feature, many improvements and optimizations remain to be made
-> Adapted from Andrew Schneider's 2015 SIGGRAPH talk "The real-time volumetric cloudscapes of Horizon: Zero Dawn"
-</details>
-
-<details><summary>Game: </summary>
-
- Per bank autoaim
-</details>
-
-<details><summary>Animation: </summary>
-
- Fix CTD on bad legacy animation data
- Add proper time wrapping for Animations
- Actually handle a mssing `Fade_anim` properly
-</details>
-
-<details><summary>Controls: </summary>
-
- Organize and map additional keys to librocket
- Catch when SDL fails to open a joystick that is enumerated by the OS
-</details>
-
-<details><summary>FRED: </summary> 
-
- Add SpaceMouse support
- Add pre-parse enums support
- Add music player to FRED
- Enhanced SEXP comments
- FRED Dialog for Volumetrics
- QoL improvements to Object Editor
- Add FRED support for the "required weapon" feature
- SEXP Tree search and filter
-</details>
-
-<details><summary>QtFRED: </summary>
-
- Campaign Editor
- Add SpaceMouse support
- Make 'player starts in chase view' a toggle
-</details>
-
-<details><summary>Graphics: </summary>
-
- "The other great shader flag removal effort"
- Enhance handling of motion debris
- Expose texture filtering as a built-in option
- Improved particle culling and performance
- Optimized trail renderer
- Beam Particles
- Multiple lighting profiles
- Use volume particles for poofs
- Optimize for simple trails
- Kink shamed the laser bitmaps
-</details>
-
-<details><summary>HUD: </summary>
-
- Flag to apply HUD shudder to chase view
- Add missing HUD gauges
- Explicitly do not split lines when making the message log
-</details>
-
-<details><summary>Localization: </summary>
-
- Add some XSTR entries
-</details>
-
-<details><summary>Modding: </summary>
-
- Mapify built-in strings
- Allow `gameplay_profiles.tbl` to be an alias of `ai_profiles.tbl`
- Modular rank table
- Toggle auto-assigning personas
- Add some parameters for corkscrew starting angle
- Add clip planes to `game_settings.tbl`
- Add `+Use ship` as a Template
- Modular messages table
- Add arbitrary curves support
- Traitor overrides
- Add support for loose lz4 compressed files
- Add per-species warp effects
-</details>
-
-<details><summary>Models: </summary>
-
- Fix submodel sanity check
- Fix techroom modelnum references
- Adjust movement sanity checks to account for more situations
- Modular POF Features 2
- Add fov values to .pof models
- Add a Translation Moveable
- Remove model octants
- Fix glowpoints on animated submodels
- Update type_flags when dock name changes
- Add additional checks for Animation List handling of nonexistent polymodel instances
- Virtual POFs: Modify Subsystems
- Validate chunk size to avoid alignment crash and add align skip flag
-</details>
-
-<details><summary>Multiplayer: </summary>
-
- Generic Lua Multiplayer RPC
-</details>
-
-<details><summary>Performance: </summary>
-
- Increase sound update rate
- Add `line of sight` as an optional AI override
-</details>
-
-<details><summary>SEXPs: </summary>
-
- `turret-fired-since`, returns `true` if the specified turret has fired in the last `N` milliseconds
- `is-ship-emp-active`, returns `true` if the specified ship or list of ships is currently under an EMP effect
- `turret-has-primary` and `turret-has-secondary`, returns `true` if the specified turret contains the specified weapon
- `has-armor-type`, returns `true` if the specified ship or subsystem has the specified armor type
- `OPF_ANY_HUD_GAUGE` and `OPF_EVENT_NAME`, new Lua SEXP parameters
- Enhance Dynamic SEXPs with parent parameters
- Add "afterburn hard" AI goal flag
-</details>
-
-<details><summary>Scripting: </summary>
-
- Add option to deprecate hooks
- Get audiostream duration in float seconds
- Lua method to check if the game has focus
- `On warp complete` hook
- Allow Lua to set the Discord presence to custom strings
- Add virtvars for goal satisfaction and score
- Allow scripts to read and add LuaEnums
- Funcs and virtvars for SCPUI pause screen
- Expose pausing weapon sounds
- Make collision_group_id accessible to parse objects
- Pass shortcut key character to Lua as a hook variable
- Lua method to free all loaded models
- `On Asteroid Created` hook
- SCPUI methods required for handling closeup briefing icons
- Expose some Nebula settings to Lua
- SCPUI mission log
- SCPUI APIsfor the Game Help UI, medals access, and control config
- Force expand wings instead of toggle for SCPUI
- Add misc. validity checks
- Convert hotkey types to enum
- Finalize SCPUI API
- Blocking `On Frame` executor 
- SCPUI Hud Config API
- Configurable restriction for ships that accept Lua player orders
- Add `ship::isPlayer()`
- Lua access to default countermeasures class
- Flag to check if a ship or weapon class is player allowed
- Add hooks for comm menu opening/closing
-</details>
-
-<details><summary>Technical: </summary> 
-
- Improve CFLAGS handling
-</details>
-
 ## [22.2.0] - 2022-08-06

 ```
@@ -1,5 +1,7 @@
 FreeSpace2 *S*ource *C*ode *P*roject
 ==
+[![Travis-CI Build Status](https://travis-ci.org/scp-fs2open/fs2open.github.com.svg?branch=master)](https://travis-ci.org/scp-fs2open/fs2open.github.com)
+[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/scp-fs2open/fs2open.github.com?branch=master&svg=true)](https://ci.appveyor.com/project/SirKnightly/fs2open-github-com/branch/master)
 [![Coverity](https://img.shields.io/coverity/scan/870.svg)](https://scan.coverity.com/projects/870)

 Building
@@ -0,0 +1,62 @@
+version: 1.0.0.{build}
+image: Visual Studio 2015
+configuration:
+  - Debug
+  - Release
+clone_depth: 10
+environment:
+  matrix:
+    - BuildID: 0
+      CMAKE_GENERATOR: Visual Studio 14 2015
+      PlatformToolset: v140
+      QT_DIR: C:\Qt\5.9\msvc2015
+    - BuildID: 1
+      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
+      PlatformToolset: v140
+      QT_DIR: C:\Qt\5.9\msvc2015_64
+before_build:
+  - git submodule update --init --recursive
+build_script:
+  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/build.ps1
+test_script:
+  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/test.ps1
+
+deploy:
+    - provider: GitHub
+      auth_token:
+          secure: h55Scpy+3vmo1Yb7WlSIGA4d9DRnsbzUYc2LYsQdByQHZHbqrqjBpicH0D2FFLEO
+      on:
+          ReleaseBuild: true        # deploy on release push only
+
+    - provider: FTP
+      protocol: sftp
+      host: scp.indiegames.us
+      username:
+        secure: SFivQZfatqWHXK1ijYK3GQ==
+      password:
+        secure: q6Zk/412o1ri+NEya1dl1Q==
+      folder: public_html/builds/nightly/$(VersionName)
+      on:
+          NightlyBuild: true        # deploy on nightly push only
+
+    - provider: FTP
+      protocol: sftp
+      host: porphyrion.feralhosting.com
+      username:
+        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
+      password:
+        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
+      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$(VersionName)
+      on:
+          NightlyBuild: true        # deploy on nightly push only
+
+    - provider: FTP
+      protocol: sftp
+      host: porphyrion.feralhosting.com
+      username:
+        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
+      password:
+        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
+      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$(VersionName)
+      on:
+          TestBuild: true        # deploy on test build push only
@@ -0,0 +1,164 @@
+
+class BuildConfig {
+	[string]$Generator
+	[string]$PackageType
+	[string]$Toolset
+	[string]$SimdType
+	[string]$QtDir
+	[Bool]$SourcePackage
+}
+
+$NightlyConfigurations = @(
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015 Win64";
+#		PackageType="Win64";
+#		Toolset="v140";
+#		SimdType="SSE2";
+#		QtDir="C:\Qt\5.9\msvc2015_64";
+#		SourcePackage=$false;
+#	},
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015";
+#		PackageType="Win32";
+#		Toolset="v140";
+#		SimdType="SSE2";
+#		QtDir="C:\Qt\5.9\msvc2015";
+#		SourcePackage=$false;
+#	}
+)
+$ReleaseConfigurations = @(
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015";
+#		PackageType="Win32";
+#		Toolset="v140";
+#		SimdType="SSE2";
+#		QtDir="C:\Qt\5.9\msvc2015";
+#		SourcePackage=$true;
+#	}
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015";
+#		PackageType="Win32-AVX";
+#		Toolset="v140";
+#		SimdType="AVX";
+#		QtDir="C:\Qt\5.9\msvc2015";
+#		SourcePackage=$false;
+#	}
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015 Win64";
+#		PackageType="Win64";
+#		Toolset="v140";
+#		SimdType="SSE2";
+#		QtDir="C:\Qt\5.9\msvc2015_64";
+#		SourcePackage=$false;
+#	}
+#	[BuildConfig]@{
+#		Generator="Visual Studio 14 2015 Win64";
+#		PackageType="Win64-AVX";
+#		Toolset="v140";
+#		SimdType="AVX";
+#		QtDir="C:\Qt\5.9\msvc2015_64";
+#		SourcePackage=$false;
+#	}
+)
+
+$BuildConfigurations = $null
+
+# Default values
+$ReleaseBuild = $false
+$NightlyBuild = $false
+$TestBuild = $false
+
+# Set to true to test either the release or the nightly part of this script
+$ReleaseTest = $false
+$NightlyTest = $false
+$TestBuildTest = $false
+
+if ($ReleaseTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^release_(.*)"))) {
+    # Tag matches
+    $ReleaseBuild = $true
+    $PackageName = "fs2_open_$($matches[1])"
+	$BuildConfigurations = $ReleaseConfigurations
+}
+
+if ($NightlyTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^nightly_(.*)"))) {
+    # Tag matches
+    $NightlyBuild = $true
+    $PackageName = "nightly_$($matches[1])"
+	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
+	$BuildConfigurations = $NightlyConfigurations
+}
+
+if ($TestBuildTest -Or ([System.Convert]::ToInt32($env:APPVEYOR_PULL_REQUEST_NUMBER) -le 0 -And ("$env:APPVEYOR_REPO_BRANCH" -match "^test\/(.*)"))) {
+    # Tag matches
+    $TestBuild = $true
+    $PackageName = "test_$($matches[1])"
+	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
+	$BuildConfigurations = $NightlyConfigurations
+
+    # Override the revision string so that the builds are named correctly
+	[System.IO.File]::WriteAllLines("$env:APPVEYOR_BUILD_FOLDER/version_override.cmake", "set(FSO_VERSION_REVISION_STR $env:VersionName)")
+}
+
+# Multiply by 2 so that we can add 0 or 1 for debug or release Configs
+$buildID = [convert]::ToInt32($env:BuildID) * 2
+if ($Env:Configuration -eq "Release") {
+    $buildID = $buildID + 1
+}
+
+$DeployBuild = $false
+if ($ReleaseBuild -Or $NightlyBuild -Or $TestBuild) {
+    $DeployBuild = $true
+}
+
+Set-AppveyorBuildVariable 'ReleaseBuild' "$ReleaseBuild"
+Set-AppveyorBuildVariable 'NightlyBuild' "$NightlyBuild"
+Set-AppveyorBuildVariable 'TestBuild' "$TestBuild"
+
+New-Item build -type directory
+Set-Location -Path build
+
+if ($DeployBuild) {
+	# Release build
+	if ($buildID -ge $BuildConfigurations.Length) {
+		# Not needed
+        exit 0
+	}
+
+	$buildConfig = $BuildConfigurations[$buildID]
+
+	if ($buildConfig.SourcePackage -eq $True) {
+		7z a -xr'!.git' "$($PackageName)-source-Win.zip" "$env:APPVEYOR_BUILD_FOLDER"
+		Push-AppveyorArtifact "$($PackageName)-source-Win.zip"
+	}
+	
+	cmake -DCMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER/../install" -DFSO_USE_SPEECH="ON" `
+		-DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$($buildConfig.SimdType)" `
+		-DQT5_INSTALL_ROOT="$($buildConfig.QtDir)" -DFSO_BUILD_QTFRED=ON `
+		-DFSO_INSTALL_DEBUG_FILES="ON" `
+		-G "$($buildConfig.Generator)" -T "$($buildConfig.Toolset)" ..
+
+	$Configs = @("Release", "FastDebug")
+	foreach ($config in $Configs) {
+		cmake --build . --config "$config" --target INSTALL -- /verbosity:minimal
+		if (! ($?)) {
+			Add-AppveyorMessage "A release build failed!"
+			exit 1
+    	}
+	}
+
+    7z a -xr'!*.pdb' "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
+    Push-AppveyorArtifact "$($PackageName)-builds-$($buildConfig.PackageType).zip"
+
+	7z a "$($PackageName)-debug-$($buildConfig.PackageType).7z" "$env:APPVEYOR_BUILD_FOLDER/../install/*.pdb"
+	Push-AppveyorArtifact "$($PackageName)-debug-$($buildConfig.PackageType).7z"
+} else {
+	cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="ON" -DFSO_BUILD_TESTS="ON" -DMSVC_SIMD_INSTRUCTIONS=SSE2 `
+	-DFSO_BUILD_QTFRED=ON -DQT5_INSTALL_ROOT="$env:QT_DIR" -DFSO_BUILD_FRED2="ON" `
+	-G "$Env:CMAKE_GENERATOR" -T "$Env:PlatformToolset" ..
+
+    cmake --build . --config "$Env:CONFIGURATION" -- /verbosity:minimal
+
+    if (! ($?)) {
+        exit 1
+    }
+}
@@ -0,0 +1,13 @@
+
+if ([System.Convert]::ToBoolean($env:ReleaseBuild) -Or [System.Convert]::ToBoolean($env:NightlyBuild) -Or [System.Convert]::ToBoolean($env:TestBuild)) {
+    # Skip tests for deployment
+    exit 0
+} else {    
+    write "Running unit tests..."
+    # Run unit tests
+    &"$pwd\bin\$Env:CONFIGURATION\unittests.exe" --gtest_shuffle 2>&1
+
+    if (! ($?)) {
+        exit 1
+    }
+}
@@ -5,8 +5,6 @@ set -e
 SCRIPT=$(readlink -f "$0")
 HERE=$(dirname "$SCRIPT")

-git config --global --add safe.directory "$GITHUB_WORKSPACE"
-
 COMMIT_RANGE=$1..$2

 if ! git rev-list $COMMIT_RANGE 2>&1 >/dev/null; then
@@ -18,13 +16,8 @@ fi
 # branch
 BASE_COMMIT=$(git merge-base $1 $2)

-# 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 \
-    -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"
+    -clang-tidy-binary /usr/bin/clang-tidy-9 -j$(nproc) -export-fixes "$(pwd)/clang-fixes.yaml"
@@ -1,38 +1,34 @@
 #!/usr/bin/env bash

-if [ "$COMPILER" = "gcc-9" ]; then
-    export CC=gcc-9
-    export CXX=g++-9
+if [ "$COMPILER" = "gcc-5" ]; then
+    export CC=gcc-5
+    export CXX=g++-5
 fi
-if [ "$COMPILER" = "gcc-13" ]; then
-    export CC=gcc-13
-    export CXX=g++-13
+if [ "$COMPILER" = "gcc-10" ]; then
+    export CC=gcc-10
+    export CXX=g++-10
 fi
-if [ "$COMPILER" = "clang-16" ]; then
-    export CC=clang-16
-    export CXX=clang++-16
+if [ "$COMPILER" = "clang-9" ]; then
+    # Work around bug in clang that uses the wrong installation directory: https://bugs.llvm.org/show_bug.cgi?id=47460
+    export CC=$(readlink -f $(which clang-9))
+    export CXX=$(readlink -f $(which clang++-9))
 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"
+    PLATFORM_CMAKE_OPTIONS=""
    export CMAKE_OSX_ARCHITECTURES="$ARCHITECTURE"
 else
-    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON -DFORCED_SIMD_INSTRUCTIONS=SSE2 -DUSE_STATIC_LIBCXX=ON"
+    CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
+    CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
+    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON"
 fi

 CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
 if [[ "$COMPILER" =~ ^clang.*$ ]]; then
    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=ON"
-    # force clang to silently allow -static-libstdc++ flag
-fi
-
-if [ ! "$CCACHE_PATH" = "" ]; then
-    echo "Using ccache at $CCACHE_PATH"
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_C_COMPILER_LAUNCHER=$CCACHE_PATH -DCMAKE_CXX_COMPILER_LAUNCHER=$CCACHE_PATH"
 fi

 mkdir build
@@ -45,11 +41,7 @@ export LD_LIBRARY_PATH
 if [ "$RUNNER_OS" = "macOS" ]; then
    brew install ninja
 fi
-
-# CMAKE_JOB_POOLS and CMAKE_JOB_POOL_LINK ensure that when using ninja, link operations are done sequentially
-# 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 \
-    -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 ..
+    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON \
+    -DSHADERS_ENABLE_COMPILATION=ON ..
@@ -8,29 +8,29 @@ OS="$1"
 source $HERE/dist_functions.sh

 if [ "$OS" = "Linux" ]; then
-    tar -cvzf "$(get_package_name)-builds-Linux-$ARCH.tar.gz" *
+    tar -cvzf "$(get_package_name)-builds-Linux.tar.gz" *

-    echo "package_path=$(pwd)/$(get_package_name)-builds-Linux-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    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
+    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Linux.tar.gz"
+    echo "::set-output name=package_name::$(get_package_name)-builds-Linux.tar.gz"
+    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux.tar.gz")"
 elif [ "$OS" = "Windows" ]; then
    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"

-    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
+    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip"
+    echo "::set-output name=package_name::$(get_package_name)-builds-$ARCH-$SIMD.zip"
+    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip")"

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

-    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
+    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z"
+    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.7z"
+    echo "::set-output name=debug_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z")"
 elif [ "$OS" = "Mac" ]; then
-    tar -cvzf "$(get_package_name)-builds-Mac-$ARCH.tar.gz" *.app
+    tar -cvzf "$(get_package_name)-builds-Mac.tar.gz" *

-    echo "package_path=$(pwd)/$(get_package_name)-builds-Mac-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_name=$(get_package_name)-builds-Mac-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Mac-$ARCH.tar.gz")" >> $GITHUB_OUTPUT
+    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Mac.tar.gz"
+    echo "::set-output name=package_name::$(get_package_name)-builds-Mac.tar.gz"
+    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Mac.tar.gz")"
 else
    echo "Invalid OS: $OS"
 fi
@@ -5,13 +5,6 @@ HERE=$(dirname "$SCRIPT")

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

-# 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
-    echo "Skipping tests due to architecture mismatch!"
-    exit 0
-fi
-
 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
@@ -10,21 +10,11 @@ HERE=$(dirname "$SCRIPT")
 source $HERE/dist_functions.sh

 if [ "$UPLOAD_TYPE" = "nightly" ]; then
-    any_success=false
-    if SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"; then
-        any_success=true
-    fi
+    SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"

-    if SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@perses.feralhosting.com" "www/datacorder.perses.feralhosting.com/public_html/builds/nightly"; then
-        any_success=true
-    fi
-
-    if [ "$any_success" = "false" ]; then
-        echo "All uploads failed"
-        exit 1
-    fi
+    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly"
 elif [ "$UPLOAD_TYPE" = "test" ]; then
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@perses.feralhosting.com" "www/datacorder.perses.feralhosting.com/public_html/builds/test"
+    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/test"
 else
    echo "Unknown upload type $UPLOAD_TYPE"
    exit 1
@@ -12,61 +12,6 @@ from subprocess import check_output
 MAX_PAGES = 100  # maximum number of PR pages to go through
 warnings = 0

-label_scores = {
-"fred" : 6,
-"qtfred" : 6,
-"vr" : 6,
-"multi" : 6,
-"Lab" : 6,
-"pilot file" : 6,
-"scripting" : 6,
-"sexps" : 6,
-"ai" : 6,
-"controls" : 6,
-"HUD" : 6,
-"models" : 6,
-"sound" : 6,
-"graphics" : 6,
-"physics" : 6,
-"ui" : 6,
-"localization / translation" : 6,
-"optimization" : 6,
-"gameplay" : 5,
-"general modding" : 4,
-"fix" : 3,
-"enhancement" : 2,
-"backport" : 1,
-"cleanup" : 0
-}
-
-label_to_category = {
-"fred" : "FRED",
-"qtfred" : "QtFRED",
-"vr" : "VR",
-"multi" : "Multiplayer",
-"Lab" : "Lab",
-"pilot file" : "Pilot File",
-"scripting" : "Scripting",
-"sexps" : "SEXPs",
-"ai" : "AI",
-"controls" : "Controls",
-"HUD" : "HUD",
-"models" : "Models",
-"sound" : "Sound",
-"graphics" : "Graphics",
-"physics" : "Physics",
-"ui" : "UI",
-"localization / translation" : "Localization",
-"optimization" : "Optimization",
-"gameplay" : "Gameplay",
-"general modding" : "General Modding",
-"fix" : "Fix",
-"enhancement" : "Enhancement",
-"backport" : "Backport",
-"cleanup" : "Cleanup",
-"misc" : "Misc."
-}
-
 def get_last_page(response: requests.Response) -> int:
    """
    @brief Extract the last page number from the response header
@@ -95,33 +40,7 @@ def get_last_page(response: requests.Response) -> int:
            return MAX_PAGES
        else:
            return last_page
-
-def label_score(label):
-    try:
-        return label_scores[label['name']]
-    except KeyError:
-        return -1
-
-def get_label(labels) -> str:
-    """
-    @brief Get the primary label from a list of labels
-
-    @param[in] labels The list of labels from a pull request
-
-    @returns The primary label to be used for sorting in the changelog
-    """
-    if len(labels) < 1:
-        return "misc"
-
-    # Sort the labels based on their score and grab the highest valued label
-    name = sorted(labels, key=label_score, reverse=True)[0]['name']
    
-    # If a label couldn't be found, toss it into a miscellaneous bin
-    if name not in label_scores:
-        name = "misc"
-    
-    return name
-

 def main():
    parser = argparse.ArgumentParser(description="Retrieves a log of commit messages and attempts to pretty them into a human-readable format")
@@ -219,16 +138,11 @@ def main():
                print("Found old pull #{} ({}), stopping loop...".format(pull['number'], pull['updated_at']))
                page = last_page + 1
                break
-            
-            # If a label isn't in the changelog, create a bin for it
-            label = get_label(pull['labels'])
-            if label not in changelog:
-                changelog[label] = {}

            # Add the pull to the changelog, indexed by its pull.number
-            if pull['number'] not in changelog[label]:
+            if pull['number'] not in changelog:
                # only add if the key isn't there already
-                changelog[label][pull['number']] = {
+                changelog[pull['number']] = {
                    "date":     merge_date,
                    "title":    pull['title'],
                    "labels":   pull['labels'],
@@ -244,13 +158,9 @@ def main():
    # 2021-09-28 | (#3661) Fix homing child weapons in niche circumstances 
    print("Writing to change.log...")
    str = ''
-    for label, pulls in dict(sorted(changelog.items())).items():
-        str += "[size=18pt]{}[/size]\n".format(label_to_category[label])
-        str += "[list]\n"
-        for key, value in pulls.items():
-            str += "[li](#{}) {} [/li]\n".format(key, value['title'])
-        str += "[/list]\n\n"
-
+    for key, value in changelog.items():
+        str += "{} | (#{}) {} \n".format(value['date'].strftime("%Y-%m-%d"), key, value['title'])
+    
    with open("change.log", "w") as file:
        file.write(str)

@@ -40,7 +40,7 @@ class ForumAPI:
            "body": content
        })

-        if resp.status_code != 200:
+        if resp.text != "OK":
            print("Post failed! Response: %s" %resp.text)
        
        return resp.json()
@@ -19,7 +19,7 @@
 # HLP_API:
 # HLP_KEY:

-# LINUX_RESULT: bool, if the linux builds were successfully uploaded
+# LINUX_RESULT: bool, if the linux builds were sucessfully uploaded
 # WINDOWS_RESULT: bool, if the windows builds were successfully uploaded

 import sys
@@ -137,8 +137,8 @@ def main():
 			"pass": os.environ["INDIEGAMES_SSHPASS"],
 			"path": "public_html/builds/{type}/{version}/",
 			"mirrors": (
-				"https://perses.feralhosting.com/datacorder/builds/{type}/{version}/{file}",
-				"https://scp.indiegames.us/builds/{type}/{version}/{file}",
+				"https://porphyrion.feralhosting.com/datacorder/builds/{type}/{version}/{file}",
+				"http://scp.indiegames.us/builds/{type}/{version}/{file}",
 			),
 		},
 		"nebula": {
@@ -260,10 +260,6 @@ def main():
 		if "Linux" not in groups.keys():
 			print("ERROR: No Linux builds were detected!")
 			sys.exit(1)
-
-		if "Mac" not in groups.keys():
-			print("ERROR: No Mac builds were detected!")
-			sys.exit(1)
 		
 		# z64: What dose this do???
 		# print(installer.render_installer_config(version, groups, config))
@@ -7,15 +7,6 @@ import requests
 from file_list import ReleaseFile
 from util import retry_multi, GLOBAL_TIMEOUT

-LINUX_X64_KEY = "Linux-x86_64"
-LINUX_ARM64_KEY = "Linux-arm64"
-MACOSX_X64_KEY = "Mac-x86_64"
-MACOSX_ARM64_KEY = "Mac-arm64"
-WIN32_SSE2_KEY = "Win32-SSE2"
-WIN64_SSE2_KEY = "Win64-SSE2"
-WIN32_AVX_KEY = "Win32-AVX"
-WIN64_AVX_KEY = "Win64-AVX"
-
 metadata = {
    'type': 'engine',
    'title': 'FSO',
@@ -35,32 +26,28 @@ metadata = {
 }

 platforms = {
-    LINUX_X64_KEY: 'linux',
-    LINUX_ARM64_KEY: 'linux',
-    MACOSX_X64_KEY: 'macosx',
-    MACOSX_ARM64_KEY: 'macosx',
-    WIN32_SSE2_KEY: 'windows',
-    WIN64_SSE2_KEY: 'windows',
-    WIN32_AVX_KEY: 'windows',
-    WIN64_AVX_KEY: 'windows'
+    'Linux': 'linux',
+    'MacOSX': 'macosx',
+    'Win32-SSE2': 'windows',
+    'Win64-SSE2': 'windows',
+    'Win32-AVX': 'windows',
+    'Win64-AVX': 'windows'
 }

 envs = {
-    LINUX_X64_KEY: 'linux && x86_64',
-    LINUX_ARM64_KEY: 'linux && arm64',
-    MACOSX_X64_KEY: 'macosx && x86_64',
-    MACOSX_ARM64_KEY: 'macosx && arm64',
-    WIN32_SSE2_KEY: 'windows',
-    WIN64_SSE2_KEY: 'windows && x86_64',
-    WIN32_AVX_KEY: 'windows && avx',
-    WIN64_AVX_KEY: 'windows && avx && x86_64'
+    'Linux': 'linux && x86_64',  # Linux only has 64bit builds
+    'MacOSX': 'macosx',
+    'Win32-SSE2': 'windows',
+    'Win64-SSE2': 'windows && x86_64',
+    'Win32-AVX': 'windows && avx',
+    'Win64-AVX': 'windows && avx && x86_64'
 }

 subdirs = {
-    WIN32_SSE2_KEY: 'x86',
-    WIN64_SSE2_KEY: 'x64',
-    WIN32_AVX_KEY: 'x86_avx',
-    WIN64_AVX_KEY: 'x64_avx'
+    'Win32-SSE2': 'x86',
+    'Win64-SSE2': 'x64',
+    'Win32-AVX': 'x86_avx',
+    'Win64-AVX': 'x64_avx'
 }


@@ -116,7 +103,7 @@ def render_nebula_release(version, stability, files, config):
                'filename': dest_fn
            })

-            if group.startswith('Linux') and fn.endswith('.AppImage'):
+            if group == 'Linux' and fn.endswith('.AppImage'):
                if 'qtfred' in fn:
                    if '-FASTDBG' in fn:
                        label = 'QtFRED Debug'
@@ -130,8 +117,7 @@ def render_nebula_release(version, stability, files, config):
                        label = None

                props = {
-                    "arm64": "arm64" in fn,
-                    "x64": "x64" in fn,
+                    "x64": True,  # All Linux builds are 64-bit
                    "sse2": True,  # Linux builds are forced to compile with SSE2 but not AVX
                    "avx": False,
                    "avx2": False,
@@ -142,7 +128,7 @@ def render_nebula_release(version, stability, files, config):
                    'label': label,
                    'properties': props,
                })
-            elif group.startswith('Mac') and fn.startswith(os.path.basename(fn) + '.app/'):
+            elif group == 'MacOSX' and fn.startswith(os.path.basename(fn) + '.app/'):
                if 'qtfred' in fn:
                    if '-FASTDBG' in fn:
                        label = 'QtFRED Debug'
@@ -155,8 +141,7 @@ def render_nebula_release(version, stability, files, config):
                        label = None

                props = {
-                    "arm64": "arm64" in fn,
-                    "x64": "x64" in fn,
+                    "x64": True,  # All Mac builds are 64-bit
                    "sse2": True,  # There are no forced options on mac but 64-bit always implies SSE2 so we set that here
                    "avx": False,
                    "avx2": False,
@@ -7,22 +7,22 @@ PLACEHOLDER
 [b]Deprecations:[/b]
 PLACEHOLDER

-Deprecations are a mechanism in FSO where a certain feature or aspect of the engine has changed or is no longer supported. Since this would normally break existing mods, we have the mod table feature "[tt]$Target Version:[/tt]" with which a mod can specify what version of FSO it was developed with. Any features listed under Deprecations will be removed or changed when the target version of a mod is at least the version released in this post.
+Deprecations are a mechanism in FSO where a certain feature or aspect of the engine has changed or is no longer supported. Since this would normally break existing mods we have the mod table feature "[tt]$Target Version:[/tt]" with which a mod can specify what version of FSO it was developed with. The features listed above will be removed or changed when the target version of a mod is at least the version released in this post.

-[size=5pt]Previous [url=https://www.hard-light.net/forums/index.php?topic=99015.0]23.2.1 Release Thread[/url][/size]
+[size=5pt]Previous [url=https://www.hard-light.net/forums/index.php?topic=97293.0]21.0 Release Thread[/url][/size]

 Launchers, if you don't have one already:
-[b]All platforms: [/b] For every day use, we recommend [url=https://knossosnet.github.io/Knossos-Release-Page/]Knossos.NET[/url], an integrated solution for downloading and launching mods.
+[b]All platforms: [/b] For every day use, we recommend [url=https://www.hard-light.net/forums/index.php?topic=94068.0]Knossos[/url], an integrated solution for downloading and launching mods.

 [hidden=Alternative Launchers]
-Cross-platform: [url=https://www.hard-light.net/forums/index.php?topic=89162]wxLauncher 0.12.x Test Build[/url] (legacy project for a unified launcher)
+Cross-platform: [url=http://www.hard-light.net/forums/index.php?topic=89162]wxLauncher 0.12.x Test Build[/url] (ongoing project for a unified launcher, you should upgrade to the latest RC/test build if you have not yet)
 [b]Important:[/b] For best compatibility with FSO 3.8 and later you should use at least wxLauncher 0.12.

-Windows:  [url=http://scp.fsmods.net/builds/Launcher55g.zip]Launcher 5.5g[/url] ([url=https://scp.indiegames.us/builds/Launcher55g.zip]Mirror[/url]) ([url=https://www.mediafire.com/?wdvzn7hhhzh418m]Mirror[/url]) Not compatible with Windows 8+, use wxLauncher above
-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]
+Windows:  [url=http://scp.fsmods.net/files/Launcher55g.zip]Launcher 5.5g[/url] ([url=http://scp.indiegames.us/builds/Launcher55g.zip]Mirror[/url]) ([url=http://www.mediafire.com/?wdvzn7hhhzh418m]Mirror[/url]) Not compatible with Windows 8+, use wxLauncher above
+OS X:  Soulstorm's [url=http://www.hard-light.net/forums/index.php/topic,51391.0.html]OS X Launcher 3.0[/url]
+Linux:  [url=http://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[/url] or [url=http://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)[/size][/color]
+[img]http://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)}
@@ -40,38 +40,29 @@ Linux:  [url=https://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[
 [size=8pt]This one is based on the AVX Optimizations from the MSVC Compiler.[/size]

 [b]What are those SSE, SSE2 and AVX builds I keep seeing everywhere?[/b]
-[url=https://www.hard-light.net/forums/index.php?topic=65628.0]Your answer is in this topic.[/url]
-Don't want to deal with that? Use [url=https://knossosnet.github.io/Knossos-Release-Page/]Knossos.NET[/url] and it will download the best build specifically for your PC!
+[url=http://www.hard-light.net/forums/index.php?topic=65628.0]Your answer is in this topic.[/url]
+Don't want to deal with that? Use [url=https://www.hard-light.net/forums/index.php?topic=94068.0]Knossos[/url] and it will download the best build specifically for your PC!
 [/hidden]

-[img]https://scp.indiegames.us/img/linux-icon.png[/img] [color=green][size=12pt]Linux[/size][/color]
-[size=8pt]Compiled with Ubuntu 20.04 LTS, GCC 9[/size]
-[b]x86_64:[/b] ${build(groups["Linux"].subFiles["x86_64"])}
-[b]arm64:[/b] ${build(groups["Linux"].subFiles["arm64"])}
+[img]http://scp.indiegames.us/img/linux-icon.png[/img] [color=green][size=12pt]Linux 64-bit[/size][/color]
+[size=8pt]Compiled with Ubuntu 16.04 LTS 64-bit, GCC 5[/size]
+${build(groups["Linux"].mainFile)}

-These builds use a mechanism called [url=https://appimage.org/]AppImage[/url] which should allow these builds to run on most Linux distributions. However, we recommend that you compile your own builds which will result in less issues.
+These builds use a mechanism called [url=http://appimage.org/]AppImage[/url] which should allow these builds to run on most Linux distributions. However, we recommend that you compile your own builds which will result in less issues.
 Alternatively, if there is a package in your software repository then you should use that. If you are the maintainer of such a package for a distribution then let us know and we will include that here.


-[img]https://scp.indiegames.us/img/mac-icon.png[/img] [color=green][size=12pt]macOS[/size][/color]
-[size=8pt]macOS 10.9+[/size]
-[b]Intel (64-bit):[/b] ${build(groups["Mac"].subFiles["x86_64"])}
-[b]Apple Silicon:[/b] ${build(groups["Mac"].subFiles["arm64"])}
-
-These builds are not signed and so by default will fail to launch. To run them simply right-click on the app, click open, then click open again on the security confirmation dialog. You should only have to do this once for each app.
-If running the game through Knossos or Knossos.NET this step should not be necessary.
-
-[size=8pt][color=red][b]NOTE:[/b][/color] macOS builds currently have limited support and may exhibit issues not present on other platforms.[/size]
-
+[img]http://scp.indiegames.us/img/mac-icon.png[/img] [color=green][size=12pt]OS X[/size][/color]
+[b][color=red]Not available[/color][/b] We recently lost access to our Mac CI environment which we usually used for compiling these builds so for the time being, there will be no builds for this OS.

 [hidden=TrackIR Users]
 [size=12pt]Important!![/size]
 An external DLL is required for FSO to use TrackIR functions.  The following DLL is simply unpacked in to your main FreeSpace2 root dir.
 TrackIR is only supported on Windows.
-[url=https://www.mediafire.com/download.php?4zw024zrh44etse]TrackIR SCP DLL[/url] ([url=http://scp.fsmods.net/builds/scptrackir.zip]Mirror[/url]) ([url=https://scp.indiegames.us/builds/scptrackir.zip]Mirror[/url])[/hidden]
+[url=http://www.mediafire.com/download.php?4zw024zrh44etse]TrackIR SCP DLL[/url] ([url=http://scp.fsmods.net/builds/scptrackir.zip]Mirror[/url]) ([url=http://scp.indiegames.us/builds/scptrackir.zip]Mirror[/url])[/hidden]

 Known issues:
 [list]
 [li][url=https://github.com/scp-fs2open/fs2open.github.com/issues]Github issues[/url] and [url=https://github.com/scp-fs2open/fs2open.github.com/pulls]pending pull requests[/url][/li]
-[li]See the list of [url=https://github.com/scp-fs2open/fs2open.github.com/projects/8]bugs ranked by priority[/url][/li]
+[li]See the list of [url=http://scp.indiegames.us/mantis/search.php?project_id=1&status_id%5B%5D=10&status_id%5B%5D=20&status_id%5B%5D=30&status_id%5B%5D=40&status_id%5B%5D=50&priority_id%5B%5D=40&priority_id%5B%5D=50&priority_id%5B%5D=60&sticky_issues=on&sortby=last_updated&dir=DESC&per_page=200&hide_status_id=-2]Fix for next release[/url] bugs - mark a bug as an elevated priority (high, urgent, immediate) to get it included in that filter.[/li]
 [/list]
@@ -1,3 +1,3 @@
-Mako==1.2.2
-requests==2.32.0
+Mako==1.1.5
+requests==2.26.0
 semantic-version==2.8.5
@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+
+set -ex
+
+if [ "$NIGHTLY_BUILD" = true ]; then
+    echo "Generating bintray config..."
+    sed -e "s/\$VERSION_NAME/$VERSION_NAME/" ci/bintray.template.json > ci/bintray.json
+fi
@@ -0,0 +1,20 @@
+#!/usr/bin/env sh
+
+set -ex
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    export DEBIAN_FRONTEND=noninteractive
+
+    sudo add-apt-repository -y "ppa:msulikowski/valgrind" # For fixing a bug with valgrind 3.11 which does not recognize the rdrand instruction
+
+    wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+    sudo add-apt-repository -y 'deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+
+    sudo apt-get -yq update
+elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+    # Nothing to do here
+    :
+elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
+    # Nothing to do here
+    :
+fi
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+set -ex
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    mkdir -p /tmp/builds
+    if [ "$RELEASE_BUILD" = true ]; then
+        # Package the source code in release builds
+        PARENT_DIR="$(basename "$PWD")"
+        (cd .. && tar -czvf /tmp/builds/$PACKAGE_NAME-source-Unix.tar.gz --exclude-vcs "$PARENT_DIR")
+    fi
+fi
+
+mkdir -p build
+cd build
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
+    CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
+
+    export CXXFLAGS
+    export CFLAGS
+    CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
+    if [ "$BUILD_DEPLOYMENT" = true ]; then
+        for config in $BUILD_CONFIGS
+        do
+            mkdir -p $config
+            cd $config
+            eval $CMAKE -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_BUILD_TYPE=$config -DCMAKE_INSTALL_PREFIX="/tmp/release/$config" \
+                -DFSO_BUILD_APPIMAGE=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_QTFRED=OFF ../..
+            cd ..
+        done
+    else
+        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
+    fi
+elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+    if [ "$BUILD_DEPLOYMENT" = true ]; then
+        cmake -G "Xcode" -DFSO_FATAL_WARNINGS=ON -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_INSTALL_PREFIX="/tmp/release" ..
+    else
+        cmake -G "Xcode" $CMAKE_OPTIONS ..
+    fi
+elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
+    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
+        cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+            -DFSO_BUILD_FRED2="OFF" -G "$CMAKE_GENERATOR" ..
+    else
+        cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
+            -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "$CMAKE_GENERATOR" -T "$CMAKE_TOOLSET" ..
+    fi
+fi
@@ -0,0 +1,74 @@
+#!/usr/bin/env sh
+
+RELEASE_BUILD=false
+NIGHTLY_BUILD=false
+TEST_BUILD=false
+
+BUILD_DEPLOYMENT=false
+BUILD_CONFIGS="Release FastDebug"
+VERSION_NAME=""
+PACKAGE_NAME=""
+
+RELEASE_PATTERN="^release_(.*)$"
+NIGHTLY_PATTERN="^nightly_(.*)$"
+TEST_BUILD_PATTERN="^test\/(.*)$"
+
+# These are for testing
+NIGHTLY_TEST=false
+RELEASE_TEST=false
+TEST_BUILD_TEST=false
+
+if [ "$RELEASE_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $RELEASE_PATTERN ]]; then
+    echo "This is a release tag!";
+    RELEASE_BUILD=true;
+	PACKAGE_NAME="fs2_open_${BASH_REMATCH[1]}";
+fi
+if [ "$NIGHTLY_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $NIGHTLY_PATTERN ]]; then
+    echo "This is a nightly tag!";
+    NIGHTLY_BUILD=true;
+    VERSION_NAME="${BASH_REMATCH[1]}";
+	PACKAGE_NAME="nightly_${BASH_REMATCH[1]}";
+fi
+if [ "$TEST_BUILD_TEST" = true ] || [[ "$TRAVIS_PULL_REQUEST" == "false" && "$TRAVIS_BRANCH" =~ $TEST_BUILD_PATTERN ]]; then
+    echo "This is a test build branch!";
+    TEST_BUILD=true;
+    if [ "$TEST_BUILD_TEST" = true ]; then
+        VERSION_NAME="test";
+        PACKAGE_NAME="test_test";
+    else
+        VERSION_NAME="${BASH_REMATCH[1]}";
+        PACKAGE_NAME="test_${BASH_REMATCH[1]}";
+    fi
+
+    # Override the revision string so that the builds are named correctly
+    echo "set(FSO_VERSION_REVISION_STR $VERSION_NAME)" > "$TRAVIS_BUILD_DIR/version_override.cmake"
+fi
+
+if ([ "$RELEASE_BUILD" = true ] || [ "$NIGHTLY_BUILD" = true ] || [ "$TEST_BUILD" = true ]); then
+    BUILD_DEPLOYMENT=true;
+fi
+
+if [ "$BUILD_DEPLOYMENT" = true ]; then
+    if ([ "$TRAVIS_OS_NAME" = "linux" ] && (! [[ "$CC" =~ ^gcc-5.*$ ]])); then
+        echo "Skipping non-release compiler";
+        exit 0;
+    fi
+
+    if ([[ "$CONFIGURATION" == "Debug" ]]); then
+        echo "Skipping non-release configuration";
+        exit 0;
+    fi
+
+    if [ "$TRAVIS_OS_NAME" = "windows" ]; then
+        echo "Skipping non-release platform"
+        exit 0
+    fi
+fi
+
+export RELEASE_BUILD
+export NIGHTLY_BUILD
+export TEST_BUILD
+export BUILD_DEPLOYMENT
+export BUILD_CONFIGS
+export VERSION_NAME
+export PACKAGE_NAME
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+
+if [[ ! "$(curl -V)" == *"sftp"* ]]; then
+    # Before
+    echo "Before:"
+    curl -V
+
+    if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+
+        if [ -f ~/curl_cache/curl*.deb ]; then
+            cd ~/curl_cache
+            sudo dpkg -i libcurl3*.deb
+            sudo dpkg -i curl*.deb
+        else
+            # Since the Travis CI people are not capable of enabling SSH/SCP support for their libcurl we need to build that manually...
+            # These commands are based on the tutorial from here: http://zeroset.mnim.org/2013/03/14/sftp-support-for-curl-in-ubuntu-12-10-quantal-quetzal-and-later/
+            mkdir /tmp/curl
+            cd /tmp/curl
+            sudo apt-get update
+            sudo apt-get install build-essential debhelper libssh2-1-dev libgnutls-dev libidn11-dev libkrb5-dev libldap2-dev libnss3-dev librtmp-dev libtool openssh-server quilt
+            apt-get source curl
+            sudo apt-get build-dep curl
+
+            cd curl-*
+            export DEB_BUILD_OPTIONS="nocheck"
+            sudo dpkg-buildpackage -uc -us -j"$(grep -c ^processor /proc/cpuinfo)"
+
+            cd ..
+            dpkg -l | grep curl
+            ls -al
+
+            if [ ! -d ~/curl_cache ]; then
+                mkdir ~/curl_cache
+            fi
+
+            cp libcurl3*.deb curl*.deb ~/curl_cache
+
+            sudo dpkg -i libcurl3*.deb
+            sudo dpkg -i curl*.deb
+        fi
+    elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+        brew install libssh2
+        
+        if [ -d ~/curl_cache/curl ]; then
+            cd ~/curl_cache/curl
+            sudo make install
+        else
+            mkdir /tmp/curl
+            cd /tmp/curl
+
+            curl -LO "https://curl.haxx.se/download/curl-7.64.0.tar.bz2"
+            tar -xjf curl-7.64.0.tar.bz2
+
+            cd curl-7.64.0
+            ./configure --disable-debug --disable-dependency-tracking --disable-silent-rules --with-libssh2 --with-darwinssl --without-ca-bundle --without-ca-path
+            make -j"$(sysctl hw.logicalcpu | cut -d " " -f 2)"
+
+            if [ ! -d ~/curl_cache ]; then
+                mkdir ~/curl_cache
+            fi
+
+            cp -a . ~/curl_cache/curl
+            sudo make install
+        fi
+        export PATH=/usr/local/bin:$PATH
+    fi
+
+    # After
+    echo "After:"
+    curl -V
+fi
+
+cd /tmp/builds
+
+for file in *; do
+    if [ "$TEST_BUILD" = true ]; then
+        # Upload to datacorder
+        curl -k "sftp://porphyrion.feralhosting.com/www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
+    else
+        # Upload to indiegames
+        curl -k "sftp://scp.indiegames.us/~/public_html/builds/nightly/$VERSION_NAME/" --user "$INDIEGAMES_USER:$INDIEGAMES_PASSWORD" -T "$file" --ftp-create-dirs
+
+        # Upload to datacorder
+        curl -k "sftp://porphyrion.feralhosting.com/~/www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
+    fi
+done
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+set -ex
+
+FILENAME=
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    export DEBIAN_FRONTEND=noninteractive
+
+    if [ ! -d "$HOME/cmake-3.8/bin" ]; then
+        # If the cache does not currently contain CMake then download and install it
+    	mkdir -p $HOME/cmake-3.8/
+
+    	wget -O /tmp/cmake.tar.gz --no-check-certificate https://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz
+    	tar -xzf /tmp/cmake.tar.gz -C $HOME/cmake-3.8/ --strip-components=1
+    fi
+    export PATH=$HOME/cmake-3.8/bin:$PATH
+    
+    cd $HOME
+    
+    if [ "${BUILD_DEPLOYMENT}" = true ]; then
+        wget -O appimagetool -c "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" # (64-bit)
+        chmod a+x ./appimagetool
+
+        wget -O linuxdeployqt -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" # (64-bit)
+        chmod a+x ./linuxdeployqt
+    fi
+
+    sudo apt-get -yq install valgrind
+
+    if [[ "$CC" = "clang-9" ]]; then
+      sudo apt-get -yq install clang-9 clang-tidy-9
+    fi
+
+    if [[ "$CC" = "clang-4.0" ]]; then
+      # Fix a header bug present in ubuntu...
+      sudo ln -s /usr/include/libcxxabi/__cxxabi_config.h /usr/include/c++/v1/__cxxabi_config.h
+    fi
+elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+    gem install xcpretty
+    
+    brew update
+    brew outdated cmake || brew upgrade cmake
+elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
+    choco install mingw ninja
+fi
+
+cmake --version
@@ -0,0 +1,68 @@
+#!/usr/bin/env sh
+
+set -ex
+mkdir -p /tmp/builds
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+	cd build
+    for config in $BUILD_CONFIGS
+    do
+        cd "$config"
+
+        # Compile all targets
+        ninja all
+
+        # Install Freespace2 targets
+        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -DCOMPONENT=Unspecified -P cmake_install.cmake
+        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -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 /tmp/release/$config/fso/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
+        $HOME/appimagetool -n /tmp/release/$config/fso "/tmp/release/$config/fso/$FILENAME"
+
+: <<'END'
+        # Install qtFRED targets
+        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=Unspecified -P cmake_install.cmake
+        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=qtFRED -P cmake_install.cmake
+
+        PREV="$(pwd)"
+        cd /tmp/release/$config/qtfred
+
+        unset QTDIR; unset QT_PLUGIN_PATH; unset LD_LIBRARY_PATH
+        $HOME/linuxdeployqt usr/qtfred.desktop -bundle-non-qt-libs
+        # Move our AppRun script to the right location
+        mv usr/AppRun AppRun
+
+        echo "Embed newer libstdc++ for distros that don't come with it (ubuntu 14.04)";
+        mkdir -p usr/optional/; mkdir -p usr/optional/libstdc++/;
+        cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 ./usr/optional/libstdc++/;
+
+        $HOME/appimagetool -n . "$(find /tmp/release/$config/qtfred/usr/bin -name 'qtfred_*' -type f -printf "%f\n").AppImage"
+
+        cd "$PREV"
+END
+
+        cd ..
+    done
+
+    cp `find /tmp/release -name '*.AppImage' -print` /tmp/release
+    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-Linux.tar.gz *.AppImage)
+elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+    cd build
+    
+    for config in $BUILD_CONFIGS
+    do
+        cmake --build . --config "$config" --target install | tee build.log \
+            | xcpretty
+        XCODE_RET=${PIPESTATUS[0]}
+        if [ "$XCODE_RET" -ne "0" ]; then
+            tar -cvzf build.log.tar.gz build.log
+            curl --upload-file build.log.tar.gz "https://transfer.sh/build.log.tar.gz"
+            exit $XCODE_RET
+        fi
+    done
+
+    ls -al /tmp/release
+    
+    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-MacOSX.tar.gz *)
+fi
@@ -0,0 +1,30 @@
+#!/usr/bin/env sh
+
+set -e
+
+cd build
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    ninja -k 20 all
+
+    if [ "$CONFIGURATION" = "Debug" ]; then
+        valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
+            --suppressions="$TRAVIS_BUILD_DIR/ci/travis/valgrind.supp" ./bin/unittests --gtest_shuffle
+    else
+        ./bin/unittests --gtest_shuffle
+    fi
+elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+    cmake --build . --config "$CONFIGURATION" | tee build.log | xcpretty
+    XCODE_RET=${PIPESTATUS[0]}
+    if [ "$XCODE_RET" -ne "0" ]; then
+        tar -cvzf build.log.tar.gz build.log
+        curl --upload-file build.log.tar.gz "https://keep.sh"
+        exit $XCODE_RET
+    fi
+elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
+    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
+        cmake --build . --config "$CONFIGURATION"
+    else
+        cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
+    fi
+fi
@@ -1,16 +0,0 @@
-buildType:
-  default: release
-  description: R
-  choices:
-    release:
-      short: Release
-      long: Release builds
-      buildType: Release
-    fastDebug:
-      short: FastDebug
-      long: Debug with optimizations
-      buildType: FastDebug
-    debug:
-      short: Debug
-      long: Debug without optimizations
-      buildType: Debug
@@ -2,72 +2,50 @@
 #ifdef _WIN32
 #include <intrin.h>
 //  Windows
-#define cpuid    __cpuidex
-#define xgetbv   _xgetbv
+#define cpuid    __cpuid

 #else

-#include <cstdint>
-
 //  GCC Inline Assembly
-void cpuid(int CPUInfo[4], int InfoType, int SubType){
+void cpuid(int CPUInfo[4],int InfoType){
    __asm__ __volatile__ (
        "cpuid":
        "=a" (CPUInfo[0]),
        "=b" (CPUInfo[1]),
        "=c" (CPUInfo[2]),
        "=d" (CPUInfo[3]) :
-        "a" (InfoType),
-		"c" (SubType)
+        "a" (InfoType)
    );
 }

-uint64_t xgetbv(uint32_t xcr) {
-	uint32_t lower, higher;
-	__asm__ __volatile__ (
-		"xgetbv":
-		"=a"(lower),
-		"=d"(higher) :
-		"c"(xcr)
-	);
-	return (static_cast<uint64_t>(higher) << static_cast<uint64_t>(32)) | static_cast<uint64_t>(lower);
-}
-
 #endif

 #include <iostream>

 int main( int argc, char* argv[] )
 {
-	bool SSE     = false;
-	bool SSE2    = false;
-	bool OSXSAVE = false;
-	bool AVX     = false;
-	bool AVX2    = false;
+	int SSE     = false;
+	int SSE2    = false;
+	int AVX     = false;
+	int AVX2    = false;

 	int info[4];
-	cpuid(info, 0, 0);
+	cpuid(info, 0);
 	int nIds = info[0];

 	//  Detect Instruction Set
 	if (nIds >= 1){
-		cpuid(info, 0x00000001, 0);
-		SSE     = (info[3] & ((int)1 << 25)) != 0;
-		SSE2    = (info[3] & ((int)1 << 26)) != 0;
-		OSXSAVE = (info[2] & ((int)1 << 27)) != 0;
-		AVX     = (info[2] & ((int)1 << 28)) != 0;
+		cpuid(info,0x00000001);
+		SSE   = (info[3] & ((int)1 << 25)) != 0;
+		SSE2  = (info[3] & ((int)1 << 26)) != 0;
+
+		AVX   = (info[2] & ((int)1 << 28)) != 0;
 	}
 	if (nIds >= 7){
-		cpuid(info,0x00000007, 0);
+		cpuid(info,0x00000007);
 		AVX2  = (info[1] & ((int)1 <<  5)) != 0;
 	}

-	//  Detect OS Support
-	if (!OSXSAVE || (xgetbv(0) & 0x6) == 0) {
-		AVX = false;
-		AVX2 = false;
-	}
-
 	if (AVX2)
 		std::cout << "AVX2";
 	else if(AVX)
@@ -24,19 +24,3 @@ set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-
-if (FSO_BUILD_WITH_DISCORD)
-    message(WARNING "Discord support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_BUILD_WITH_DISCORD:BOOL=OFF")
-endif()
-
-if (FSO_BUILD_FRED2)
-    message(WARNING "FRED2 support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_BUILD_FRED2:BOOL=OFF")
-endif()
-
-if (FSO_USE_SPEECH)
-    message(WARNING "Speech support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_USE_SPEECH:BOOL=OFF")
-endif()
-
-if (FSO_USE_VOICEREC)
-    message(WARNING "Voice recognition support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_USE_VOICEREC:BOOL=OFF")
-endif()
@@ -97,19 +97,9 @@ function(handle_embedded_files _target)
        set(INCLUDE_LIST "${INCLUDE_LIST}\n#include \"${HEADER_FILE}\"")
        set(ARRAY_ELEMENTS "${ARRAY_ELEMENTS}\n\t{ \"${_pathType}\", \"${FILE_NAME}\" , ${FIELD_NAME} , ${FIELD_NAME}_size },")

-        IF(CMAKE_CROSSCOMPILING)
-            SET(EMBEDFILE_PATH "EMBEDFILE-NOTFOUND" CACHE FILEPATH "Required for a cross compiling build, point to an embedfile of a cmake build for the host OS")
-            IF(EMBEDFILE_PATH STREQUAL "EMBEDFILE-NOTFOUND")
-                #This could, possibly, be configured to compile an embedfile using host compilation automatically, but that seems to be a challenge.
-                message(FATAL_ERROR "A manual embedfile path must be configured for cross compilation. Set EMBEDFILE_PATH to the location of an embedfile executable, found in the build directories for the host OS.")
-            ENDIF()
-        ELSE(CMAKE_CROSSCOMPILING)
-            SET(EMBEDFILE_PATH "embedfile")
-        ENDIF(CMAKE_CROSSCOMPILING)
-
        add_custom_command(
            OUTPUT ${ALL_OUTPUTS}
-            COMMAND ${EMBEDFILE_PATH} "${_filePath}" "${_outputBasePath}" "${FIELD_NAME}"
+            COMMAND embedfile "${_filePath}" "${_outputBasePath}" "${FIELD_NAME}"
            MAIN_DEPENDENCY "${_filePath}"
            COMMENT "Generating string file for ${_filePath}"
        )
@@ -9,8 +9,6 @@ if (WIN32)
 	if (NOT HAVE_SAPI_H)
 		message(SEND_ERROR "sapi.h could not be found on your platform. Please disable speech support.")
 	endif()
-elseif(APPLE)
-	# it should just work
 else()
 	message(SEND_ERROR "Text to Speech is not supported on this platform!")
 endif()
@@ -7,32 +7,3 @@ if (CMAKE_SIZEOF_VOID_P EQUAL 8)
 else()
    set(IS_64BIT FALSE)
 endif()
-
-set(IS_ARM64 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)
-    endif()
-else()
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)")
-        set(IS_ARM64 TRUE)
-    endif()
-endif()
-
-set(IS_RISCV FALSE)
-
-if (NOT "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "")   # needed to cover Visual Studio generator
-    if(CMAKE_GENERATOR_PLATFORM MATCHES "^(riscv64|RISCV64|riscv32|RISCV32)")
-        set(IS_RISCV TRUE)
-    endif()
-else()
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv64|RISCV64|riscv32|RISCV32)")
-        set(IS_RISCV TRUE)
-    endif()
-endif()
-
-set(IS_X86 FALSE)
-if (NOT IS_ARM64 AND NOT IS_RISCV)
-    set(IS_X86 TRUE)
-endif()
@@ -11,8 +11,7 @@ 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_OSX_DEPLOYMENT_TARGET "10.9")

 SET(CMAKE_SKIP_RPATH FALSE)
 SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
@@ -23,14 +22,6 @@ SET(LIBRAY_DESTINATION "../Frameworks")

 set(PLATFORM_MAC TRUE CACHE INTERNAL "" FORCE)

-# Maybe override arm64 setting if we are compiling for different architecture
-# If not specified, or if it's a universal build, then this should do nothing
-if(CMAKE_OSX_ARCHITECTURES MATCHES "arm64")
-    set(IS_ARM64 TRUE)
-elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
-    set(IS_ARM64 FALSE)
-endif()
-
 # Generate and don't strip debug symbols
 # These settings don't seem to generate debug symbols for code and Freespace2
 # so those settings are set manually in code and Freespace2's CMakeLists.txt files
@@ -10,7 +10,6 @@ SET(WIN32_LIBS
 	winmm
 	ws2_32
 	psapi
-	shlwapi
 )

 IF (MINGW)
@@ -9,8 +9,6 @@
 #cmakedefine SCP_HAVE_STD_MAX_ALIGN_T

 #cmakedefine01 IS_64BIT
-#cmakedefine01 IS_ARM64
-#cmakedefine01 IS_RISCV

 #cmakedefine01 SCP_HAVE_STRCASECMP
 #cmakedefine01 SCP_HAVE_STRNCASECMP
@@ -4,7 +4,7 @@ MESSAGE(STATUS "Doing configuration specific to Apple Clang...")
 # TODO: Actually add Mac specific flags here...

 # Suppress specific warning
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fsigned-char -Wno-unknown-pragmas")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -funroll-loops -fsigned-char -Wno-unknown-pragmas")

 # Omit "conversion from string literal to 'char *' is deprecated" warnings.
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-write-strings")
@@ -13,6 +13,6 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated -Wno-char-subscripts")

 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_RELEASE "-Wno-unused-variable")

-set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -Wshadow")
+set(CMAKE_CXX_FLAGS_DEBUG "-Wextra -Wshadow -Wno-unused-parameter")
@@ -10,41 +10,8 @@ option(CLANG_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
 option(CLANG_USE_LIBCXX "Use libc++" OFF)

 # These are the default values
-set(C_BASE_FLAGS "-pipe")
-set(CXX_BASE_FLAGS "-pipe")
-
-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(CLANG_EXTENSIONS "-march=native")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "")
-		set(CLANG_EXTENSIONS "-march=x86-64")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		set(CLANG_EXTENSIONS "-march=x86-64 -msse -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		set(CLANG_EXTENSIONS "-march=x86-64 -msse -msse2 -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		set(CLANG_EXTENSIONS "-march=x86-64-v2 -msse -msse2 -mavx -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		set(CLANG_EXTENSIONS "-march=x86-64-v3 -msse -msse2 -mavx -mavx2 -mfpmath=sse")
-	else ()
-		message( FATAL_ERROR "Unknown instruction set encountered for clang. Update toolchain-clang.cmake!" )
-	endif()
-
-	set(C_BASE_FLAGS "${C_BASE_FLAGS} ${CLANG_EXTENSIONS}")
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} ${CLANG_EXTENSIONS}")
-elseif(IS_ARM)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -march=native")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -march=native")
-    endif ()
-elseif(IS_RISCV)
-    # Default C/CXX_BASE_FLAGS are fine for RISC-V
-endif()
-
-if (USE_STATIC_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -static-libstdc++ -Qunused-arguments")
-	set(CLANG_USE_LIBCXX ON)
-endif()
+set(C_BASE_FLAGS "-march=native -pipe")
+set(CXX_BASE_FLAGS "-march=native -pipe")

 # For C and C++, the values can be overwritten independently
 if(DEFINED ENV{CXXFLAGS})
@@ -66,8 +33,12 @@ set(COMPILER_FLAGS "")
 _enable_extra_compiler_warnings_flags()
 set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")

-set(COMPILER_FLAGS "${COMPILER_FLAGS} -fsigned-char -Wno-unknown-pragmas")
+set(COMPILER_FLAGS "${COMPILER_FLAGS} -funroll-loops -fsigned-char -Wno-unknown-pragmas")

+# Omit "argument unused during compilation" when clang is used with ccache.
+if(${CMAKE_CXX_COMPILER} MATCHES "ccache")
+	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Qunused-arguments")
+endif()

 if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
 	# Force color diagnostics for Ninja generator
@@ -112,41 +83,20 @@ if(SUPPORTS_SHIFT_NEGATIVE_VALUE)
 	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-shift-negative-value")
 endif()

-# Check if there is a user-set optimisation flag
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" CXX_OPT_FLAG ${CXX_BASE_FLAGS})
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
+set(COMPILER_FLAGS_RELEASE "-O2 -Wno-unused-variable -Wno-unused-parameter")

-# 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 "-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 "-Og")
-else()
-	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
-	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
-endif()
+set(COMPILER_FLAGS_DEBUG "-O0 -g -Wshadow")

-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")
-
-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
+# Always use the base flags and add our compiler flags at the bacl
 set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
 set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")

-set(CMAKE_CXX_FLAGS_RELEASE ${CXX_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${C_FLAGS_RELEASE})
+set(CMAKE_CXX_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
+set(CMAKE_C_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
+
+set(CMAKE_CXX_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
+set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})

-set(CMAKE_CXX_FLAGS_DEBUG ${CXX_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${C_FLAGS_DEBUG})

 set(CMAKE_EXE_LINKER_FLAGS "")

@@ -170,7 +120,7 @@ if (FSO_FATAL_WARNINGS)
 	target_compile_options(compiler INTERFACE "-Werror")
 endif()

-# Always define this to make sure that the fixed-width format macros are available
+# Always define this to make sure that the fixed width format macros are available
 target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS)

 if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
@@ -12,49 +12,8 @@ option(GCC_USE_GOLD "Use the gold linker instead of the standard linker" OFF)
 option(GCC_GENERATE_GDB_INDEX "Adds linker option to generate the gdb index for debug builds" OFF)

 # These are the default values
-set(C_BASE_FLAGS "-pipe")
-set(CXX_BASE_FLAGS "-pipe")
-
-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(GCC_EXTENSIONS "-march=native")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "")
-		set(GCC_EXTENSIONS "-march=x86-64")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		set(GCC_EXTENSIONS "-march=x86-64 -msse -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		set(GCC_EXTENSIONS "-march=x86-64 -msse -msse2 -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		set(GCC_EXTENSIONS "-march=x86-64-v2 -msse -msse2 -mavx -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		set(GCC_EXTENSIONS "-march=x86-64-v3 -msse -msse2 -mavx -mavx2 -mfpmath=sse")
-	else ()
-		message( FATAL_ERROR "Unknown instruction set encountered for GCC. Update toolchain-gcc.cmake!" )
-	endif()
-
-	set(C_BASE_FLAGS "${C_BASE_FLAGS} ${GCC_EXTENSIONS}")
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} ${GCC_EXTENSIONS}")
-
-	if (IS_64BIT)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -m64")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -m64")
-	endif()
-elseif(IS_ARM)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -march=native")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -march=native")
-    endif ()
-elseif(IS_RISCV)
-    # You do not need to pass a -march, passing nothing will make gcc to choose itself.
-    # If you want a specific set of instructions like vectors, set -march in CFLAGS and CXXFLAGS env variables
-    # Example for vectors: -march=rv64gcv
-    # https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Options.html
-    # As such, default C/CXX_BASE_FLAGS are sufficient.
-endif()
-
-if (USE_STATIC_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -static-libstdc++")
-endif()
+set(C_BASE_FLAGS "-march=native -pipe")
+set(CXX_BASE_FLAGS "-march=native -pipe")

 # For C and C++, the values can be overwritten independently
 if(DEFINED ENV{CFLAGS})
@@ -86,7 +45,7 @@ endif()
 _enable_extra_compiler_warnings_flags()
 set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")

-set(COMPILER_FLAGS "${COMPILER_FLAGS} -fsigned-char -Wno-unknown-pragmas")
+set(COMPILER_FLAGS "${COMPILER_FLAGS} -funroll-loops -fsigned-char -Wno-unknown-pragmas")

 if (NOT GCC_INCREMENTAL_LINKING)
 	# Place each function and data in its own section so the linker can
@@ -154,41 +113,19 @@ if(SUPPORTS_STRINGOP_TRUNCATION)
 	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-stringop-overflow")
 endif()

-# Check if there is a user-set optimisation flag
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" CXX_OPT_FLAG ${CXX_BASE_FLAGS})
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
+set(COMPILER_FLAGS_RELEASE "-O2 -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered  -Wno-unused-parameter")

-# 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 "-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 "-Og")
-else()
-	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
-	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
-endif()
-
-set(CXX_FLAGS_RELEASE "${CXX_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered -Wno-unused-parameter")
-set(C_FLAGS_RELEASE "${C_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered -Wno-unused-parameter")
-
-set(CXX_FLAGS_DEBUG "${CXX_OPT_FLAG_DEBUG} -g -Wshadow")
-set(C_FLAGS_DEBUG "${C_OPT_FLAG_DEBUG} -g -Wshadow")
+set(COMPILER_FLAGS_DEBUG "-O0 -g -Wshadow")

 # Always use the base flags and add our compiler flags at the back
 set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
 set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")

-set(CMAKE_CXX_FLAGS_RELEASE ${CXX_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${C_FLAGS_RELEASE})
+set(CMAKE_CXX_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})
+set(CMAKE_C_FLAGS_RELEASE ${COMPILER_FLAGS_RELEASE})

-set(CMAKE_CXX_FLAGS_DEBUG ${CXX_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${C_FLAGS_DEBUG})
+set(CMAKE_CXX_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
+set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})

 set(CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}")

@@ -228,7 +165,7 @@ if (FSO_FATAL_WARNINGS)
 	target_compile_options(compiler INTERFACE "-Werror")
 endif()

-# Always define this to make sure that the fixed-width format macros are available
+# Always define this to make sure that the fixed width format macros are available
 target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS=1)

 if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
@@ -46,13 +46,9 @@ target_compile_options(compiler INTERFACE ${WARNING_FLAGS})
 set(CMAKE_C_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
 set(CMAKE_CXX_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")

-set(CMAKE_EXE_LINKER_FLAGS "/MANIFEST /SAFESEH:NO /ERRORREPORT:PROMPT /NOLOGO")
+set(CMAKE_EXE_LINKER_FLAGS "/MANIFEST /DYNAMICBASE:NO /SAFESEH:NO /ERRORREPORT:PROMPT /NOLOGO")
 set(CMAKE_STATIC_LINKER_FLAGS "")

-if(NOT IS_ARM64)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DYNAMICBASE:NO")
-endif()
-
 # Release
 set(CMAKE_C_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
 set(CMAKE_CXX_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
@@ -95,31 +91,49 @@ ENDIF(MSVC_USE_RUNTIME_DLL)
 INCLUDE(MSVCMultipleProcessCompile)

 # Visual Studio supports compiling for multiple vector instruction sets
+SET(POSSIBLE_INSTUCTION_SETS "" SSE SSE2 AVX AVX2)

-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		# MSVC has no direct -march=native equivalent, so just use the detected extensions.
-		SET(FSO_INSTRUCTION_SET ${DETECTED_SIMD_INSTRUCTIONS})
-	endif()
+if (NOT DEFINED MSVC_SIMD_INSTRUCTIONS)
+	detect_simd_instructions(MSVC_DETECTED_SIMD_INSTRUCTIONS)

-	if(FSO_INSTRUCTION_SET STREQUAL "")
-		set(MSVC_SIMD_INSTRUCTIONS "IA32")
-	else()
-		set(MSVC_SIMD_INSTRUCTIONS ${FSO_INSTRUCTION_SET})
-	endif()
+	SET(MSVC_SIMD_INSTRUCTIONS "${MSVC_DETECTED_SIMD_INSTRUCTIONS}" CACHE FILEPATH "The SIMD instructions which will be used, possible values are ${POSSIBLE_INSTUCTION_SETS}")
+	MARK_AS_ADVANCED(FORCE MSVC_SIMD_INSTRUCTIONS)
+endif()
+set(FSO_INSTRUCTION_SET ${MSVC_SIMD_INSTRUCTIONS})

-	if (NOT (IS_64BIT AND (MSVC_SIMD_INSTRUCTIONS STREQUAL "IA32" OR MSVC_SIMD_INSTRUCTIONS STREQUAL "SSE" OR MSVC_SIMD_INSTRUCTIONS STREQUAL "SSE2")))
-		# 32-Bit and SSE(2) mustn't be set, as these are implied in x86_64 and thus MSVC does not support it for the /arch argument
-		CHECK_CXX_COMPILER_FLAG("/arch:${MSVC_SIMD_INSTRUCTIONS}" COMPILER_SUPPORTS_ARCH)
+LIST(FIND POSSIBLE_INSTUCTION_SETS "${MSVC_SIMD_INSTRUCTIONS}" SET_INDEX)

-		IF(COMPILER_SUPPORTS_ARCH)
-			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:${MSVC_SIMD_INSTRUCTIONS}")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${MSVC_SIMD_INSTRUCTIONS}")
-		ELSE()
-			message( FATAL_ERROR "Your version of MSVC does not support the requested instruction set. Consider updating!" )
-		ENDIF()
-	endif()
+if (SET_INDEX LESS 0)
+	MESSAGE(STATUS "An invalid instruction set was specified, defaulting to no special compiler options.")
+else()
+	IF (NOT SET_INDEX EQUAL 0)
+		SET(FOUND)

+		FOREACH(list_index RANGE ${SET_INDEX} 1)
+			list(GET POSSIBLE_INSTUCTION_SETS ${list_index} _simd_set)
+			CHECK_CXX_COMPILER_FLAG("/arch:${_simd_set}" COMPILER_SUPPORTS_ARCH_${_simd_set})
+
+			IF(COMPILER_SUPPORTS_ARCH_${_simd_set})
+				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:${_simd_set}")
+				set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${_simd_set}")
+
+				SET(FOUND TRUE)
+				BREAK()
+			ENDIF()
+		ENDFOREACH(list_index)
+
+		IF(NOT FOUND)
+			# Don't set anything, it will likely not work
+			MESSAGE(STATUS "Your compiler does not support any optimization flags, defaulting to none")
+		ENDIF(NOT FOUND)
+	ELSE()
+		CHECK_CXX_COMPILER_FLAG("/arch:IA32" COMPILER_SUPPORTS_ARCH_IA32)
+
+		IF(COMPILER_SUPPORTS_ARCH_IA32)
+			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:IA32")
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:IA32")
+		ENDIF(COMPILER_SUPPORTS_ARCH_IA32)
+	ENDIF()
 endif()

 target_compile_definitions(compiler INTERFACE _CRT_SECURE_NO_DEPRECATE _CRT_SECURE_NO_WARNINGS _SECURE_SCL=0 NOMINMAX
@@ -5,55 +5,6 @@ add_library(compiler INTERFACE)

 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)
-	SET(POSSIBLE_INSTRUCTION_SETS "" SSE SSE2 AVX AVX2)
-	if (CMAKE_CROSSCOMPILING)
-		message("Cross-Compile cannot detect supported instruction sets. Defaulting to SSE2. Disabling host-optimization.")
-		set(FORCED_NATIVE_SIMD_INSTRUCTIONS OFF)
-		set(DETECTED_SIMD_INSTRUCTIONS SSE2)
-	else()
-		detect_simd_instructions(DETECTED_SIMD_INSTRUCTIONS)
-	endif()
-
-	set(FORCED_SIMD_INSTRUCTIONS "" CACHE STRING "Overrides any instruction set settings (including forced-native). Any of ${POSSIBLE_INSTRUCTION_SETS}.")
-	if (NOT FORCED_SIMD_INSTRUCTIONS STREQUAL "")
-		set(FORCED_NATIVE_SIMD_INSTRUCTIONS OFF)
-		LIST(FIND POSSIBLE_INSTRUCTION_SETS "${FORCED_SIMD_INSTRUCTIONS}" SET_INDEX)
-
-		if (SET_INDEX LESS 0)
-			MESSAGE(STATUS "An invalid instruction set was specified, defaulting to no special compiler options.")
-			set(FSO_INSTRUCTION_SET "")
-		else ()
-			LIST(FIND POSSIBLE_INSTRUCTION_SETS "${DETECTED_SIMD_INSTRUCTIONS}" SET_INDEX)
-			if (SET_INDEX LESS 0)
-				MESSAGE(STATUS "An instruction set was specified which is unsupported on this platform. Compiled binary might not be executable.")
-			endif()
-
-			set(FSO_INSTRUCTION_SET ${FORCED_SIMD_INSTRUCTIONS})
-		endif()
-	else()
-		SET(FSO_INSTRUCTION_SET ${DETECTED_SIMD_INSTRUCTIONS})
-	endif()
-	MESSAGE(STATUS "Using instruction set level ${FSO_INSTRUCTION_SET}. Optimizations for host-system specifically: ${FORCED_NATIVE_SIMD_INSTRUCTIONS}.")
-
-	if (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		add_compile_definitions(FSO_SIMD_SSE)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-		add_compile_definitions(FSO_SIMD_AVX)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-		add_compile_definitions(FSO_SIMD_AVX)
-		add_compile_definitions(FSO_SIMD_AVX2)
-	endif()
-ENDIF()
-
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 	include(toolchain-gcc)
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
@@ -67,43 +67,30 @@ ENDIF(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${TARGET}/${FILE}\")
 ENDFUNCTION(EP_CHECK_FILE_EXISTS)

 MACRO(COPY_FILE_TO_TARGET _target _file)
-	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 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_directory_if_different "${_file}" "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/${_dirName}"
-					COMMENT "copying '${_file}'..."
-					VERBATIM
-			)
-		endif()
+	if(UNIX)
+		ADD_CUSTOM_COMMAND(
+			TARGET ${_target} POST_BUILD
+			COMMAND cp -a "${_file}"  "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
+			COMMENT "copying '${_file}'..."
+		)
 	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
+			TARGET ${_target} POST_BUILD
+			COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_file}"  "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
+			COMMENT "copying '${_file}'..."
 		)
 	endif()
 endmacro(COPY_FILE_TO_TARGET)

 MACRO(COPY_FILES_TO_TARGET _target)
-	ADD_CUSTOM_COMMAND(
-		TARGET ${_target} POST_BUILD
-		COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
-		COMMENT "Creating '$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/'..."
-		VERBATIM
-	)
-
+	if(UNIX)
+		ADD_CUSTOM_COMMAND(
+			TARGET ${_target} POST_BUILD
+			COMMAND mkdir -p "$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/"
+			COMMENT "Creating '$<TARGET_FILE_DIR:${_target}>/${LIBRAY_DESTINATION}/'..."
+		)
+	endif()
+	
 	FOREACH(file IN LISTS TARGET_COPY_FILES)
 		COPY_FILE_TO_TARGET("${_target}" "${file}")
 	ENDFOREACH(file)
@@ -6,8 +6,8 @@ if (EXISTS "${PROJECT_SOURCE_DIR}/version_override.cmake")
    include("${PROJECT_SOURCE_DIR}/version_override.cmake")
 endif()

-set_if_not_defined(FSO_VERSION_MAJOR 24)
-set_if_not_defined(FSO_VERSION_MINOR 3)
+set_if_not_defined(FSO_VERSION_MAJOR 22)
+set_if_not_defined(FSO_VERSION_MINOR 1)
 set_if_not_defined(FSO_VERSION_BUILD 0)

 # A numeric revision e.g. the CI build number
@@ -35,15 +35,7 @@ ELSE()
    SET(FSO_BINARY_SUFFIX "${FSO_VERSION_MAJOR}_${FSO_VERSION_MINOR}_${FSO_VERSION_BUILD}_${FSO_VERSION_REVISION_STR}")
 ENDIF()

-IF(IS_RISCV)
-	IF(IS_64BIT)
-		SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_riscv64")
-	ELSE()
-		SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_riscv32")
-	ENDIF()
-ELSEIF(IS_ARM64)
-    SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_arm64")
-ELSEIF(IS_64BIT)
+IF(IS_64BIT)
 	# This is a 64-bit builds
    SET(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}_x64")
 ENDIF()
@@ -6,7 +6,7 @@ INCLUDE(voice_rec.cmake)

 ADD_LIBRARY(code STATIC ${source_files} ${VOICE_REC_FILES})

-target_compile_features(code PUBLIC cxx_std_17)
+target_compile_features(code PUBLIC cxx_std_11)

 if (MSVC)
 	target_compile_definitions(code PUBLIC "PDB_DEBUGGING=1")
@@ -20,17 +20,6 @@ TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${GENERATED_SOURCE_DIR}/code)

 if (FSO_BUILD_WITH_OPENGL)
 	target_link_libraries(code PUBLIC OpenGL)
-	if(FSO_BUILD_WITH_OPENGL_DEBUG)
-		add_definitions(-DFS_OPENGL_DEBUG)
-	endif()
-endif()
-
-if(FSO_BUILD_WITH_OPENXR)
-	add_definitions(-DFS_OPENXR)
-endif()
-
-if(FSO_BUILD_WITH_OPENXR_DEBUG AND FSO_BUILD_WITH_OPENXR)
-	add_definitions(-DFS_OPENXR_DEBUG)
 endif()

 TARGET_LINK_LIBRARIES(code PUBLIC openal)
@@ -52,15 +41,16 @@ TARGET_LINK_LIBRARIES(code PUBLIC compiler)

 target_link_libraries(code PUBLIC md5)

-if (FSO_BUILD_WITH_DISCORD)
-	target_link_libraries(code PUBLIC discord-rpc)
-	add_definitions(-DWITH_DISCORD)
-endif()
+target_link_libraries(code PUBLIC discord-rpc)

 target_link_libraries(code PUBLIC libRocket)

 target_link_libraries(code PUBLIC pcp)

+if (FSO_BUILD_WITH_VULKAN)
+	target_link_libraries(code PUBLIC vulkan-hpp)
+endif()
+
 target_link_libraries(code PUBLIC parsers)

 target_link_libraries(code PUBLIC mdns)
@@ -74,22 +64,9 @@ ENDIF(FSO_USE_SPEECH)

 TARGET_LINK_LIBRARIES(code PUBLIC jansson)

-target_link_libraries(code PUBLIC anl)
+target_link_libraries(code PUBLIC variant)

-target_link_libraries(code PUBLIC hidapi::hidapi)
-
-target_link_libraries(code PUBLIC imgui)
-
-IF(FSO_BUILD_WITH_OPENXR)
-	target_link_libraries(code PUBLIC OpenXR::openxr_loader)
-	target_include_directories(code PUBLIC OpenXR::Headers)
-ENDIF()
-IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
-	# On Linux, we need to access X11 window data.
-	# On Windows, SDL already provides everything, so no need to do anything
-	find_package(X11)
-	target_link_libraries(code PUBLIC ${X11_LIBRARIES})
-ENDIF()
+target_link_libraries(code PUBLIC any)

 # Headers for standalone "gui" on UNIX
 IF(UNIX)
@@ -113,16 +90,7 @@ if (FSO_BUILD_WITH_OPENGL)
 	target_compile_definitions(code PUBLIC WITH_OPENGL)
 endif()
 if (FSO_BUILD_WITH_VULKAN)
-	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()
+	target_compile_definitions(code PUBLIC WITH_VULKAN)
 endif()

 include(shaders.cmake)
@@ -140,4 +108,4 @@ set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT[va
 set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN[variant=Debug] "NO")

 # Prevent GCC warnings in third-party BitOp... see GitHub #4366
-suppress_file_warnings(scripting/lua/bitop/bit.c)
+suppress_file_warnings(scripting/lua/bitop/bit.c)
@@ -47,7 +47,7 @@ ProgramInstance::ProgramInstance(const actions::Program* program) : _program(pro

 ProgramState ProgramInstance::step()
 {
-	if (!_locals.host.isValid()) {
+	if (!_locals.host.IsValid()) {
 		return ProgramState::Done;
 	}

@@ -18,7 +18,7 @@ struct ProgramLocals {
 	matrix localOrient = vmd_identity_matrix;
 	int hostSubobject = -1;

-	TIMESTAMP waitTimestamp = TIMESTAMP::invalid();
+	int waitTimestamp = 0;

 	expression::ProgramVariables variables;
 };
@@ -122,9 +122,9 @@ class ExpressionBuilderVisitor : public ActionExpressionVisitor {
 	}
 	antlrcpp::Any visitVec3d_constructor(ActionExpressionParser::Vec3d_constructorContext* context) override
 	{
-		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 xExpression = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		auto yExpression = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		auto zExpression = visit(context->expression(2)).as<std::shared_ptr<nodes::AbstractExpression>>();

 		auto expression = std::make_shared<nodes::VectorConstructorExpression>(context->L_PAREN()->getSymbol(),
 			xExpression,
@@ -2,7 +2,7 @@

 #include "globalincs/pstypes.h"

-#include <variant>
+#include <mpark/variant.hpp>

 namespace actions {
 namespace expression {
@@ -85,10 +85,10 @@ class Value {

 		if (currentType == expectedType) {
 			// No conversion necessary
-			return std::get<T>(m_value);
+			return mpark::get<T>(m_value);
 		}

-		return std::visit(detail::implicit_conversion<T>{}, m_value);
+		return mpark::visit(detail::implicit_conversion<T>{}, m_value);
 	}

 	friend bool operator==(const Value& lhs, const Value& rhs);
@@ -97,7 +97,7 @@ class Value {
 	friend std::ostream& operator<<(std::ostream& os, const Value& value);

  private:
-	std::variant<std::monostate, int, float, vec3d, SCP_string> m_value;
+	mpark::variant<mpark::monostate, int, float, vec3d, SCP_string> m_value;
 };

 } // namespace expression
@@ -26,8 +26,10 @@ ActionResult MoveToSubmodel::execute(ProgramLocals& locals) const
 	// The calling code should ensure that this never happens
 	Assertion(locals.hostSubobject >= 0, "Did not have a valid host subobject.");

-	auto pmi = object_get_model_instance(locals.host.objp());
-	Assertion(pmi != nullptr, "Model instances are required if a host subobject is specified.");
+	auto instance = object_get_model_instance(locals.host.objp);
+	Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+	auto pmi = model_get_instance(instance);
 	auto pm = model_get(pmi->model_num);

 	const auto destinationSubObject = m_subObjectExpression.execute(locals.variables);
@@ -55,7 +57,7 @@ ActionResult MoveToSubmodel::execute(ProgramLocals& locals) const

 	// We need to do a linear search for the right subobject
 	for (int i = 0; i < pm->n_models; ++i) {
-		const auto& submodel = pm->submodel[i];
+		const auto submodel = pm->submodel[i];

 		if (subsystem_stricmp(destinationSubObject.c_str(), submodel.name) == 0) {
 			// Found something!
@@ -3,8 +3,6 @@

 #include "math/vecmat.h"
 #include "parse/parselo.h"
-#include "particle/hosts/EffectHostObject.h"
-#include "particle/ParticleManager.h"
 #include "ship/ship.h"

 #include <utility>
@@ -39,8 +37,10 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
 	vec3d local_pos;
 	matrix local_orient;
 	if (locals.hostSubobject != -1) {
-		auto pmi = object_get_model_instance(locals.host.objp());
-		Assertion(pmi != nullptr, "Model instances are required if a host subobject is specified.");
+		auto instance = object_get_model_instance(locals.host.objp);
+		Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+		auto pmi = model_get_instance(instance);
 		auto pm = model_get(pmi->model_num);

 		model_instance_local_to_global_point_orient(&local_pos,
@@ -58,11 +58,11 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
 	local_pos += locals.variables.getValue({"locals", "position"}).getVector();

 	auto direction = locals.variables.getValue({"locals", "direction"}).getVector();
-	matrix orientation;
-	vm_vector_2_matrix_norm(&orientation, &direction);	// direction is normalized in SetDirectionAction::execute

-	source->setHost(make_unique<EffectHostObject>(locals.host.objp(), local_pos, orientation, true));
-	source->finishCreation();
+	source.moveToObject(locals.host.objp, &local_pos);
+	source.setOrientationFromNormalizedVec(&direction, true);
+
+	source.finish();

 	return ActionResult::Finished;
 }
@@ -2,6 +2,7 @@

 #include "actions/Action.h"
 #include "actions/expression/ActionExpression.h"
+#include "particle/ParticleManager.h"

 namespace actions {
 namespace types {
@@ -26,8 +26,10 @@ ActionResult PlaySoundAction::execute(ProgramLocals& locals) const
 	vec3d local_pos;
 	matrix local_orient;
 	if (locals.hostSubobject != -1) {
-		auto pmi = object_get_model_instance(locals.host.objp());
-		Assertion(pmi != nullptr, "Model instances are required if a host subobject is specified.");
+		auto instance = object_get_model_instance(locals.host.objp);
+		Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+		auto pmi = model_get_instance(instance);
 		auto pm = model_get(pmi->model_num);

 		model_instance_local_to_global_point_orient(&local_pos,
@@ -45,8 +47,8 @@ ActionResult PlaySoundAction::execute(ProgramLocals& locals) const
 	local_pos += locals.variables.getValue({"locals", "position"}).getVector();

 	vec3d global_pos;
-	vm_vec_unrotate(&global_pos, &local_pos, &locals.host.objp()->orient);
-	global_pos += locals.host.objp()->pos;
+	vm_vec_unrotate(&global_pos, &local_pos, &locals.host.objp->orient);
+	global_pos += locals.host.objp->pos;

 	const auto soundId = gamesnd_get_by_name(m_soundIdExpression.execute(locals.variables).c_str());

@@ -20,7 +20,7 @@ WaitAction::~WaitAction() = default;

 ActionResult WaitAction::execute(actions::ProgramLocals& locals) const
 {
-	if (!locals.waitTimestamp.isValid()) {
+	if (!timestamp_valid(locals.waitTimestamp)) {
 		auto waitTime = _waitTimeExpression.execute(locals.variables);

 		// Catch errors in the expression
@@ -28,7 +28,7 @@ ActionResult WaitAction::execute(actions::ProgramLocals& locals) const
 			waitTime = 0.001f;
 		}

-		locals.waitTimestamp = _timestamp(fl2i(waitTime * MILLISECONDS_PER_SECOND));
+		locals.waitTimestamp = timestamp(fl2i(waitTime * TIMESTAMP_FREQUENCY));
 	}
 	if (!timestamp_elapsed(locals.waitTimestamp)) {
 		// Wait until the timestamp is elapsed
@@ -36,7 +36,7 @@ ActionResult WaitAction::execute(actions::ProgramLocals& locals) const
 	}
 	// Timestamp is elapsed. The timestamp is elapsed so that timestamp_valid above returns false for the next wait
 	// action
-	locals.waitTimestamp = TIMESTAMP::invalid();
+	locals.waitTimestamp = 0;
 	return ActionResult::Finished;
 }
 std::unique_ptr<Action> WaitAction::clone() const
@@ -52,6 +52,34 @@ void ai_free_slot(int ai_index)
 	Ai_info[ai_index].shipnum = -1;
 }

+int get_wingnum(int objnum)
+{
+	int	shipnum, ai_index;
+
+	shipnum = Objects[objnum].instance;
+
+	ai_index = Ships[shipnum].ai_index;
+
+	return Ai_info[ai_index].wing;
+}
+
+void set_wingnum(int objnum, int wingnum)
+{
+	int	shipnum, ai_index;
+
+	Assert(Objects[objnum].type == OBJ_SHIP);
+
+	shipnum = Objects[objnum].instance;
+
+	Assert((shipnum >= 0) && (shipnum < MAX_SHIPS));
+
+	ai_index = Ships[shipnum].ai_index;
+
+	Assert( (ai_index >= 0) && (ai_index < MAX_AI_INFO) );
+
+	Ai_info[ai_index].wing = wingnum;
+}
+
 const char *ai_get_goal_target_name(const char *name, int *index)
 {
 	Assertion(name != nullptr && index != nullptr, "Arguments cannot be null!");
@@ -12,7 +12,6 @@
 #ifndef _AI_H
 #define _AI_H

-#include "ai/aigoals.h"
 #include "ai/ai_profiles.h"
 #include "globalincs/globals.h"
 #include "globalincs/pstypes.h"
@@ -34,14 +33,8 @@ typedef struct ai_flag_name {
 	char flag_name[TOKEN_LENGTH];
 } ai_flag_name;

-typedef struct ai_flag_description {
-	AI::AI_Flags flag;
-	const char *flag_desc;
-} ai_flag_description;
-
+#define MAX_AI_FLAG_NAMES			2
 extern ai_flag_name Ai_flag_names[];
-extern ai_flag_description Ai_flag_descriptions[];
-extern const int Num_ai_flag_names;

 //	dock_orient_and_approach() modes.
 #define	DOA_APPROACH	1		//	Approach the current point on the path (aip->path_cur)
@@ -56,6 +49,24 @@ extern const int Num_ai_flag_names;
 #define	AIDO_DOCK_NOW	2		//	Immediately move into dock position.  For ships that start mission docked.
 #define	AIDO_UNDOCK		3		//	Set goal of undocking with object.

+//	Submodes for seeking safety.
+#define	AISS_1	41				//	Pick a spot to fly to.
+#define	AISS_2	42				//	Flying to spot.
+#define	AISS_3	43				//  Gotten near spot, fly about there.
+#define	AISS_1a	44				//	Pick a new nearby spot because we are endangered, then go to AISS_2
+
+#define MAX_AI_GOALS	5
+
+// types of ai goals -- tyese types will help us to determination on which goals should
+// have priority over others (i.e. when a player issues a goal to a wing, then a seperate
+// goal to a ship in that wing).  We would probably use this type in conjunction with
+// goal priority to establish which goal to follow
+#define AIG_TYPE_EVENT_SHIP			1		// from mission event direct to ship
+#define AIG_TYPE_EVENT_WING			2		// from mission event direct to wing
+#define AIG_TYPE_PLAYER_SHIP		3		// from player direct to ship
+#define AIG_TYPE_PLAYER_WING		4		// from player direct to wing
+#define AIG_TYPE_DYNAMIC			5		// created on the fly
+
 //	Flags to ai_turn_towards_vector().
 #define	AITTV_FAST					(1<<0)	//	Turn fast, not slowed down based on skill level.
 #define AITTV_VIA_SEXP				(1<<1)	//	Goober5000 - via sexp
@@ -65,7 +76,39 @@ extern const int Num_ai_flag_names;

 #define	KAMIKAZE_HULL_ON_DEATH	-1000.0f	//	Hull strength ship gets set to if it crash-dies.

-// individual AI modes aka AI behaviors
+// structure for AI goals
+typedef struct ai_goal {
+	int	signature;			//	Unique identifier.  All goals ever created (per mission) have a unique signature.
+	int	ai_mode;				// one of the AIM_* modes for this goal
+	int	ai_submode;			// maybe need a submode
+	int	type;					// one of the AIG_TYPE_* values above
+	flagset<AI::Goal_Flags>	flags;				// one of the AIGF_* values above
+	fix	time;					// time at which this goal was issued.
+	int	priority;			// how important is this goal -- number 0 - 100
+
+	const char *target_name;	// name of the thing that this goal acts upon
+	int		target_name_index;	// index of goal_target_name in Goal_target_names[][]
+	waypoint_list *wp_list;		// waypoints that this ship might fly.
+	int target_instance;		// instance of thing this ship might be chasing (currently only used for weapons; note, not the same as objnum!)
+	int	target_signature;		// signature of object this ship might be chasing (currently only used for weapons; paired with above value to confirm target)
+
+	// unions for docking stuff.
+	// (AIGF_DOCKER_INDEX_VALID and AIGF_DOCKEE_INDEX_VALID tell us to use indexes; otherwise we use names)
+	// these are the dockpoints used on the docker and dockee ships, not the ships themselves
+	union {
+		const char *name;
+		int	index;
+	} docker;
+	
+	union {
+		const char *name;
+		int	index;
+	} dockee;
+
+	object_ship_wing_point_team lua_ai_target;
+
+} ai_goal;
+
 #define	AIM_CHASE				0
 #define	AIM_EVADE				1
 #define	AIM_GET_BEHIND			2		//	This mode is not actually implemented.
@@ -87,7 +130,7 @@ extern const int Num_ai_flag_names;
 #define	AIM_BAY_DEPART			18		//  Departing to a fighter bay, following path to do so
 #define	AIM_SENTRYGUN			19		//  AI mode for sentry guns only (floating turrets)
 #define	AIM_WARP_OUT			20		//	Commence warp out sequence.  Point in legal direction.  Then call John's code.
-#define AIM_FLY_TO_SHIP			21		//  Rendezvous with a ship.  Like stay-near, but non-perpetual.
+#define AIM_FLY_TO_SHIP			21		//  [Kazan] Fly to a ship, doesn't matter if it's hostile or friendly -- for Autopilot usage
 #define AIM_LUA					22		//  Generic Lua-based AI mode

 #define	MAX_AI_BEHAVIORS		23		//	Number of AIM_xxxx types
@@ -95,8 +138,8 @@ extern const int Num_ai_flag_names;
 #define	MAX_WAYPOINTS_PER_LIST	20
 #define	MAX_ENEMY_DISTANCE	2500.0f		//	Maximum distance from which a ship will pursue an enemy.

-#define MAX_AI_GOALS	5
-#define AI_ACTIVE_GOAL_NONE		-1
+#define AI_GOAL_NONE				-1
+
 #define	AI_ACTIVE_GOAL_DYNAMIC	999

 typedef struct ai_class {
@@ -181,12 +224,6 @@ typedef struct ai_class {
 #define	AIS_UNDOCK_3	33
 #define	AIS_UNDOCK_4	34

-//	Submodes for seeking safety.
-#define	AISS_1	41				//	Pick a spot to fly to.
-#define	AISS_2	42				//	Flying to spot.
-#define	AISS_3	43				//  Gotten near spot, fly about there.
-#define	AISS_1a	44				//	Pick a new nearby spot because we are endangered, then go to AISS_2.  (Not implemented.)
-
 //	Submodes for Guard behavior
 #define	AIS_GUARD_PATROL		101
 #define	AIS_GUARD_ATTACK		102
@@ -240,7 +277,10 @@ extern pnode	*Ppfp;			//	Free pointer in path points.
 typedef struct ai_info {
 	flagset<AI::AI_Flags> ai_flags;				//	Special flags for AI behavior.
 	int		shipnum;					// Ship using this slot, -1 means none.
+	int		type;						//	
+	int		wing;						//	Member of what wing? -1 means none. 

+	int		behavior;				//	AI behavior; vestigial field from early development of FS1
 	int		mode;
 	int		previous_mode;
 	int		mode_time;				//	timestamp at which current mode elapses.
@@ -277,8 +317,8 @@ typedef struct ai_info {
 	int		ai_class;				//	Class.  Might be override of default.

 	//	Probably become obsolete, to be replaced by path_start, path_cur, etc.
-	int		wp_list_index;			// index of waypoint list being followed
-	int		wp_index;				// index of waypoint in list
+	waypoint_list	*wp_list;		// waypoint list being followed
+	size_t			 wp_index;		// waypoint index in list
 	int		wp_flags;				//	waypoint flags, see WPF_xxxx
 	int		waypoint_speed_cap;		// -1 no cap, otherwise cap - changed to int by Goober5000

@@ -308,7 +348,6 @@ typedef struct ai_info {
 	fix		submode_start_time;	// time at which we entered the current submode
 	int		submode_parm0;			//	parameter specific to current submode
 	int		submode_parm1;			//	SUSHI: Another optional parameter
-	float	submode_float0;			//	Goober5000: a float parameter
 	fix		next_predict_pos_time;			//	Next time to predict position.

 	int		next_dynamic_path_check_time;	//ETP: Time of next path check in ai_new_maybe_reposition_attack_subsys
@@ -318,7 +357,7 @@ typedef struct ai_info {
 	//Unlike the predicted position stuff, also takes into account velocity
 	//Only used against small ships
 	fix		next_aim_pos_time;
-	vec3d	last_aim_enemy_pos;		// Normally this is the position of the enemy a turret is targeting but in the F3 Lab, this is used to pass raw target coordinates to the turret firing methods. 
+	vec3d	last_aim_enemy_pos;
 	vec3d	last_aim_enemy_vel;

 	ai_goal	goals[MAX_AI_GOALS];
@@ -330,7 +369,7 @@ typedef struct ai_info {
 	float	time_enemy_near;					//	SUSHI: amount of time enemy continuously "near" the player
 	fix		last_attack_time;					//	Missiontime of last time this ship attacked its enemy.
 	fix		last_hit_time;						//	Missiontime of last time this ship was hit by anyone.
-	int		danger_shield_quadrant;				//	Shield section AI will prefer to prioritize for recharging, it if possible.
+	int		last_hit_quadrant;				//	Shield section of last hit.
 	fix		last_hit_target_time;			//	Missiontime of last time this ship successfully hit target.
 	int		hitter_objnum;						//	Object index of ship that hit this ship last time.
 	int		hitter_signature;					//	Signature of hitter.  Prevents stupidity if hitter gets killed.
@@ -374,6 +413,11 @@ typedef struct ai_info {
 	float	ai_turret_max_aim_update_delay;
 	flagset<AI::Profile_Flags> ai_profile_flags;	//Holds AI_Profiles flags (possibly overriden by AI class) that actually apply to AI

+
+	union {
+	float		stay_near_distance;				//	Distance to stay within for AIM_STAY_NEAR mode.
+	};
+
 	ship_subsys*	targeted_subsys;			// Targeted subobject on current target.  NULL if none;
 	ship_subsys*	last_subsys_target;		// last known subsystem target
 	int				targeted_subsys_parent;	//	Parent objnum of subobject, not necessarily targeted
@@ -460,12 +504,9 @@ typedef struct ai_info {
 	int multilock_check_timestamp;		// when to check for multilock next
 	SCP_vector<std::pair<int, ship_subsys*>> ai_missile_locks_firing;  // a list of missile locks (locked objnum, locked subsys) the ai is currently firing
 	
-	ai_lua_parameters lua_ai_target;
+	object_ship_wing_point_team lua_ai_target;
 } ai_info;

-int ai_maybe_autoscale(int absolute_index = -1);
-int ai_get_autoscale_index(int absolute_index = -1);
-
 // Goober5000
 typedef struct {
 	vec3d docker_point;
@@ -485,11 +526,16 @@ typedef struct {
 #define SUBSYS_PATH_DIST	500.0f

 // Friendly damage defines
-#define MAX_BURST_DAMAGE	20.0f		// max damage that can be done in BURST_DURATION
+#define MAX_BURST_DAMAGE	20		// max damage that can be done in BURST_DURATION
 #define BURST_DURATION		500	// decay time over which Player->damage_this_burst falls from MAX_BURST_DAMAGE to 0

 extern int Mission_all_attack;	//	!0 means all teams attack all teams.

+extern void update_ai_info_for_hit(int hitter_obj, int hit_obj);
+extern void ai_frame_all(void);
+
+extern int find_guard_obj(void);
+
 extern ai_info Ai_info[];
 extern ai_info *Player_ai;

@@ -500,6 +546,7 @@ extern int Num_ai_classes;
 extern int Ai_firing_enabled;

 extern const char *Skill_level_names(int skill_level, int translate = 1);
+extern int Ai_goal_signature;

 extern control_info AI_ci;

@@ -523,6 +570,9 @@ void ai_object_init(object * obj, int ai_index);
 // Called once a frame
 void ai_process( object * obj, int ai_index, float frametime );

+int get_wingnum(int objnum);
+
+void set_wingnum(int objnum, int wingnum);
 const char *ai_get_goal_target_name(const char *name, int *index);
 void ai_clear_goal_target_names();

@@ -534,11 +584,11 @@ 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_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_start_waypoints(object *objp, waypoint_list *wp_list, int wp_flags);
+extern void ai_ship_hit(object *objp_ship, object *hit_objp, vec3d *hit_normal);
 extern void ai_ship_destroy(int shipnum);
 extern vec3d ai_get_acc_limit(vec3d* vel_limit, const object* objp);
-extern void ai_turn_towards_vector(const vec3d *dest, object *objp, const vec3d *slide_vec, const vec3d *rel_pos, float bank_override, int flags, const vec3d *rvec = nullptr, const vec3d* turnrate_mod = nullptr);
+extern void ai_turn_towards_vector(vec3d *dest, object *objp, vec3d *slide_vec, vec3d *rel_pos, float bank_override, int flags, vec3d *rvec = nullptr, vec3d* turnrate_mod = nullptr);
 extern void init_ai_object(int objnum);
 extern void ai_init(void);				//	Call this one to parse ai.tbl.
 extern void ai_level_init(void);		//	Call before each level to reset AI
@@ -561,7 +611,7 @@ 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 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 void ai_do_stay_near(object *objp, object *other_obj, float dist);
 extern ship_subsys *set_targeted_subsys(ai_info *aip, ship_subsys *new_subsys, int parent_objnum);
 extern void ai_rearm_repair( object *objp, int docker_index, object *goal_objp, int dockee_index );
 extern void ai_add_rearm_goal( object *requester_objp, object *support_objp );
@@ -590,20 +640,17 @@ extern int ai_fire_primary_weapon(object *objp);	//changed to return weather it
 extern int ai_fire_secondary_weapon(object *objp);
 extern float ai_get_weapon_dist(ship_weapon *swp);
 extern void turn_towards_point(object *objp, vec3d *point, vec3d *slide_vec, float bank_override, matrix* target_orient = nullptr, int flags = 0);
-extern bool ai_willing_to_afterburn_hard(ai_info* aip);
-extern void ai_afterburn_hard(object* objp, ai_info* aip);
 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, 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);
+float ai_get_weapon_speed(ship_weapon *swp);
+void set_predicted_enemy_pos_turret(vec3d *predicted_enemy_pos, vec3d *gun_pos, object *pobjp, vec3d *enemy_pos, vec3d *enemy_vel, float weapon_speed, float time_enemy_in_range);

 // function to change rearm status for ai ships (called from sexpression code)
-extern void ai_set_good_rearm_time( int team, int time );
-extern void ai_set_bad_rearm_time(int team, int time);
+extern void ai_set_rearm_status( int team, int new_status );
 extern void ai_good_secondary_time( int team, int weapon_index, int num_weapons, const char *shipname );

 extern void ai_do_objects_docked_stuff(object *docker, int docker_point, object *dockee, int dockee_point, bool update_clients = true);
@@ -622,6 +669,10 @@ int get_nearest_objnum(int objnum, int enemy_team_mask, int enemy_wing, float ra
 // moved to header file by Goober5000
 void ai_announce_ship_dying(object *dying_objp);

+// added by kazan
+void ai_start_fly_to_ship(object *objp, int shipnum);
+void ai_fly_to_ship();
+
 //Moved declaration here for player ship -WMC
 void ai_process_subobjects(int objnum);

@@ -636,6 +687,6 @@ void do_random_sidethrust(ai_info *aip, ship_info *sip);
 void ai_formation_object_recalculate_slotnums(int form_objnum, int exiting_objnum = -1);


-bool test_line_of_sight(const vec3d* from, const vec3d* to, SCP_unordered_set<int>&& excluded_object_ids = {}, float threshold = 10.0f, bool test_for_shields = false, bool test_for_hull = true, float* first_intersect_dist = nullptr, object** first_intersect_obj = nullptr);
+bool test_line_of_sight(vec3d* from, vec3d* to, std::unordered_set<const object*>&& excluded_objects = {}, float threshold = 10.0f, bool test_for_shields = false, bool test_for_hull = true, float* first_intersect_dist = nullptr);

 #endif
@@ -32,8 +32,6 @@ namespace AI {
 		Unload_primaries,			//	Fire primaries as fast as possible!
 		Trying_unsuccessfully_to_warp,	// Trying to warp, but can't warp at the moment
 		Free_afterburner_use,		// Use afterburners while following waypoints or flying towards objects
-		Waypoints_no_formation,		// wont get into formation when running waypoints as part of a wing
-

 		NUM_VALUES
 	};
@@ -43,13 +41,11 @@ namespace AI {
 		Dockee_index_valid,	// when set, index field for dockee is valid
 		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
+		Goal_override,		// paired with AIG_TYPE_DYNAMIC to mean this goal overrides any other goal
 		Purge,				// purge this goal next time we process
 		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
+		Target_own_team,

 		NUM_VALUES
 	};
@@ -101,10 +97,6 @@ namespace AI {
        Fix_heat_seeker_stealth_bug,
        Fix_linked_primary_bug,
 		Fix_ramming_stationary_targets_bug,
-		Fix_avoid_shockwave_bugs,   // a) waiting until a homing weapon actually homes before evading;
-		                            // b) picking the correct expected impact position for capships;
-		                            // c) not clearing shockwave_object for ships;
-		                            // d) checking the explosion damage of the correct ship
        Force_beam_turret_fov,
 		Free_afterburner_use,
        Glide_decay_requires_thrust,
@@ -129,7 +121,7 @@ namespace AI {
        Smart_shield_management,
        Smart_subsystem_targeting_for_turrets,
        Strict_turret_tagged_only_targeting,
-		Support_dont_add_primaries, //Prevents support ship from equipping new primary as requested in https://scp.indiegames.us/mantis/view.php?id=3198
+		Support_dont_add_primaries, //Prevents support ship from equipping new primary as requested in http://scp.indiegames.us/mantis/view.php?id=3198
        Turrets_ignore_target_radius,
        Use_actual_primary_range,
        Use_subsystem_path_point_radii,
@@ -138,14 +130,12 @@ namespace AI {
        Use_only_single_fov_for_turrets,
        No_turning_directional_bias,
 		Use_axial_turnrate_differences,
-		All_nonshielded_ships_can_manage_ets,
-		Fightercraft_nonshielded_ships_can_manage_ets,
-		Ships_playing_dead_dont_manage_ets,
-		Better_combat_collision_avoidance,
-		Better_guard_collision_avoidance,
+		all_nonshielded_ships_can_manage_ets,
+		fightercraft_nonshielded_ships_can_manage_ets,
+		Better_collision_avoidance,
 		Require_exact_los,
 		Improved_missile_avoidance,
-		Unify_usage_countermeasure_firechance,
+		Friendlies_use_countermeasure_firechance,
 		Improved_subsystem_attack_pathing,
 		Fixed_ship_weapon_collision,
 		No_shield_damage_from_ship_collisions,
@@ -155,29 +145,6 @@ namespace AI {
 		Prevent_negative_turret_ammo,
 		Fix_keep_safe_distance,
 		Ignore_aspect_when_leading,
-		Fix_good_rearm_time_bug,
-		No_continuous_turn_on_attack,
-		Fixed_removing_play_dead_order,
-		Disable_bay_emerge_timeout,
-		Adjusted_AI_class_autoscale,
-		Carry_shield_difficulty_scaling_bug,
-		Whackable_debris,
-		Whackable_asteroids,
-		Dynamic_goals_afterburn_hard,
-		Player_orders_afterburn_hard,
-		Hudsquadmsg_tactical_disarm_disable,
-		Align_to_target_when_guarding_still,
-		Debris_respects_big_damage,
-		Dont_limit_change_in_speed_due_to_physics_whack,
-		Guards_ignore_protected_attackers,
-		Standard_strafe_used_more,
-		Unify_usage_ai_shield_manage_delay,
-		Fix_AI_shield_management_bug,
-		AI_balances_shields_when_attacked,
-		Disable_ai_transferring_energy,
-		Freespace_1_missile_behavior,
-		ETS_uses_power_output,
-		ETS_energy_same_regardless_of_system_presence,

 		NUM_VALUES
 	};
@@ -184,14 +184,6 @@ void parse_ai_profiles_tbl(const char *filename)
 				if (optional_string("$Max Beam Friendly Fire Damage:"))
 					parse_float_list(profile->beam_friendly_damage_cap, NUM_SKILL_LEVELS);

-				if (optional_string("$Max Weapon Friendly Fire Damage:")) {
-					parse_float_list(profile->weapon_friendly_damage_cap, NUM_SKILL_LEVELS);
-				}
-					
-				if (optional_string("$Max Weapon Self Damage:")) {
-					parse_float_list(profile->weapon_self_damage_cap, NUM_SKILL_LEVELS);
-				}
-
 				if (optional_string("$Player Countermeasure Life Scale:"))
 					parse_float_list(profile->cmeasure_life_scale, NUM_SKILL_LEVELS);

@@ -231,9 +223,6 @@ void parse_ai_profiles_tbl(const char *filename)
 				if (optional_string("$Player Subsys Damage Factor:") || optional_string("$AI Damage Reduction to Player Subsys:"))
 					parse_float_list(profile->subsys_damage_scale, NUM_SKILL_LEVELS);

-				if (optional_string("$Player Damage Inflicted Factor:"))
-					parse_float_list(profile->player_damage_inflicted_scale, NUM_SKILL_LEVELS);
-
 				// represented in fractions of F1_0
 				if (optional_string("$Predict Position Delay:"))
 				{
@@ -266,7 +255,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				if (optional_string("$Glide Attack Percent:")) {
 					parse_float_list(profile->glide_attack_percent, NUM_SKILL_LEVELS);
-					//Percent is nice for modders, but here in the code we want it between 0 and 1.0
+					//Percent is nice for modders, but here in the code we want it betwwen 0 and 1.0
 					//While we're at it, verify the range
 					for (i = 0; i < NUM_SKILL_LEVELS; i++) {
 						if (profile->glide_attack_percent[i] < 0.0f || profile->glide_attack_percent[i] > 100.0f) {
@@ -279,7 +268,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				if (optional_string("$Circle Strafe Percent:")) {
 					parse_float_list(profile->circle_strafe_percent, NUM_SKILL_LEVELS);
-					//Percent is nice for modders, but here in the code we want it between 0 and 1.0
+					//Percent is nice for modders, but here in the code we want it betwwen 0 and 1.0
 					//While we're at it, verify the range
 					for (i = 0; i < NUM_SKILL_LEVELS; i++) {
 						if (profile->circle_strafe_percent[i] < 0.0f || profile->circle_strafe_percent[i] > 100.0f) {
@@ -292,7 +281,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				if (optional_string("$Glide Strafe Percent:")) {
 					parse_float_list(profile->glide_strafe_percent, NUM_SKILL_LEVELS);
-					//Percent is nice for modders, but here in the code we want it between 0 and 1.0
+					//Percent is nice for modders, but here in the code we want it betwwen 0 and 1.0
 					//While we're at it, verify the range
 					for (i = 0; i < NUM_SKILL_LEVELS; i++) {
 						if (profile->glide_strafe_percent[i] < 0.0f || profile->glide_strafe_percent[i] > 100.0f) {
@@ -305,7 +294,7 @@ void parse_ai_profiles_tbl(const char *filename)

 				if (optional_string("$Random Sidethrust Percent:")) {
 					parse_float_list(profile->random_sidethrust_percent, NUM_SKILL_LEVELS);
-					//Percent is nice for modders, but here in the code we want it between 0 and 1.0
+					//Percent is nice for modders, but here in the code we want it betwwen 0 and 1.0
 					//While we're at it, verify the range
 					for (i = 0; i < NUM_SKILL_LEVELS; i++) {
 						if (profile->random_sidethrust_percent[i] < 0.0f || profile->random_sidethrust_percent[i] > 100.0f) {
@@ -377,7 +366,7 @@ void parse_ai_profiles_tbl(const char *filename)
 				}

 				if (optional_string("$Detail Distance Multiplier:"))
-					parse_float_list(profile->detail_distance_mult, MAX_DETAIL_VALUE + 1);
+					parse_float_list(profile->detail_distance_mult, MAX_DETAIL_LEVEL + 1);

 				set_flag(profile, "$big ships can attack beam turrets on untargeted ships:", AI::Profile_Flags::Big_ships_can_attack_beam_turrets_on_untargeted_ships);

@@ -479,20 +468,10 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$firing requires exact los:", AI::Profile_Flags::Require_exact_los);

-				if (optional_string("$exact los minimum detection radius:")) {
-					stuff_float(&profile->los_min_detection_radius);
-				}
-
 				set_flag(profile, "$fighterbay arrivals use carrier orientation:", AI::Profile_Flags::Fighterbay_arrivals_use_carrier_orient);

 				set_flag(profile, "$fighterbay departures use carrier orientation:", AI::Profile_Flags::Fighterbay_departures_use_carrier_orient);

-				set_flag(profile, "$debris damage respects 'big damage' flag:", AI::Profile_Flags::Debris_respects_big_damage);
-
-				set_flag(profile, "$don't limit change in speed due to physics whack:", AI::Profile_Flags::Dont_limit_change_in_speed_due_to_physics_whack);
-
-				set_flag(profile, "$guards ignore protected attackers:", AI::Profile_Flags::Guards_ignore_protected_attackers);
-
 				if (optional_string("$ai path mode:"))
 				{
 					stuff_string(buf, F_NAME, NAME_LENGTH);
@@ -567,40 +546,22 @@ void parse_ai_profiles_tbl(const char *filename)
 					mprintf(("Warning: \"$ships with no shields can manage ETS\" flag is deprecated in favor of \"$any ship with no shields can manage ETS\"\n"));
 					bool temp;
 					stuff_boolean(&temp);
-                    profile->flags.set(AI::Profile_Flags::All_nonshielded_ships_can_manage_ets, temp);
+                    profile->flags.set(AI::Profile_Flags::all_nonshielded_ships_can_manage_ets, temp);
 				}

-				// ----------
-
-				set_flag(profile, "$no directional bias for missile and ship turning:", AI::Profile_Flags::No_turning_directional_bias);
+                set_flag(profile, "$no directional bias for missile and ship turning:", AI::Profile_Flags::No_turning_directional_bias);

 				set_flag(profile, "$respect ship axial turnrate differences:", AI::Profile_Flags::Use_axial_turnrate_differences);

-				set_flag(profile, "$any ship with no shields can manage ETS:", AI::Profile_Flags::All_nonshielded_ships_can_manage_ets);
+				set_flag(profile, "$any ship with no shields can manage ETS:", AI::Profile_Flags::all_nonshielded_ships_can_manage_ets);

-				set_flag(profile, "$fighters/bombers with no shields can manage ETS:", AI::Profile_Flags::Fightercraft_nonshielded_ships_can_manage_ets);
+				set_flag(profile, "$fighters/bombers with no shields can manage ETS:", AI::Profile_Flags::fightercraft_nonshielded_ships_can_manage_ets);

-				set_flag(profile, "$ships playing dead don't manage ETS:", AI::Profile_Flags::Ships_playing_dead_dont_manage_ets);
-
-				set_flag(profile, "$better combat collision avoidance for fightercraft:", AI::Profile_Flags::Better_combat_collision_avoidance);
-
-				if (optional_string("+combat collision avoidance aggression for fightercraft:")) {
-					stuff_float(&profile->better_collision_avoid_aggression_combat);
-				}
-
-				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:")) {
-					stuff_float(&profile->better_collision_avoid_aggression_guard);
-				}
+				set_flag(profile, "$better combat collision avoidance for fightercraft:", AI::Profile_Flags::Better_collision_avoidance);

 				set_flag(profile, "$improved missile avoidance for fightercraft:", AI::Profile_Flags::Improved_missile_avoidance);

-				if (optional_string_either("$friendly ships use AI profile countermeasure chance:", "$unify usage of AI profile countermeasure chance:", true) >= 0) {
-					bool val;
-					stuff_boolean(&val);
-					profile->flags.set(AI::Profile_Flags::Unify_usage_countermeasure_firechance, val);
-				}
+				set_flag(profile, "$friendly ships use AI profile countermeasure chance:", AI::Profile_Flags::Friendlies_use_countermeasure_firechance);

 				set_flag(profile, "$improved subsystem attack pathing:", AI::Profile_Flags::Improved_subsystem_attack_pathing);

@@ -639,80 +600,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$AI ignores aspect lock for leading:", AI::Profile_Flags::Ignore_aspect_when_leading);

-				set_flag(profile, "$fix good-rearm-time bug:", AI::Profile_Flags::Fix_good_rearm_time_bug);
-
-				set_flag(profile, "$no continuous turn on attack:", AI::Profile_Flags::No_continuous_turn_on_attack);
-
-				set_flag(profile, "$remove-goal properly removes play-dead order:", AI::Profile_Flags::Fixed_removing_play_dead_order);
-
-				set_flag(profile, "$bay arrivals not time limited:", AI::Profile_Flags::Disable_bay_emerge_timeout);
-
-				set_flag(profile, "$use adjusted AI class autoscale:", AI::Profile_Flags::Adjusted_AI_class_autoscale);
-
-				set_flag(profile, "$carry shield difficulty scaling bug:", AI::Profile_Flags::Carry_shield_difficulty_scaling_bug);
-
-				set_flag(profile, "$debris affected by physics whacks:", AI::Profile_Flags::Whackable_debris);
-
-				set_flag(profile, "$asteroids affected by physics whacks:", AI::Profile_Flags::Whackable_asteroids);
-
-				set_flag(profile, "$dynamic goals afterburn hard:", AI::Profile_Flags::Dynamic_goals_afterburn_hard);
-
-				set_flag(profile, "$player orders afterburn hard:", AI::Profile_Flags::Player_orders_afterburn_hard);
-
-				set_flag(profile, "$hud squad messages use tactical disarm/disable:", AI::Profile_Flags::Hudsquadmsg_tactical_disarm_disable);
-
-				set_flag(profile, "$align to target when guarding stationary ship:", AI::Profile_Flags::Align_to_target_when_guarding_still);
-
-				if (optional_string("$rotation factor multiplier for player collisions:")) {
-					stuff_float(&profile->rot_fac_multiplier_ply_collisions);
-				}
-
-				set_flag(profile, "$fix avoid-shockwave bugs:", AI::Profile_Flags::Fix_avoid_shockwave_bugs);
-
-				set_flag(profile, "$standard strafe used more:", AI::Profile_Flags::Standard_strafe_used_more);
-
-				if (optional_string("$standard strafe triggers under this speed:")) {
-					stuff_float(&profile->standard_strafe_when_below_speed);
-				}
-
-				if (optional_string("$strafe distance from target bounding box:")) {
-					stuff_float(&profile->strafe_retreat_box_dist);
-				}
-
-				if (optional_string("$strafe stops after time unhit:")) {
-					stuff_float(&profile->strafe_max_unhit_time);
-				}
-
-				if (optional_string("$guard uses big-orbit for target radius above:")) {
-					stuff_float(&profile->guard_big_orbit_above_target_radius);
-				}
-
-				if (optional_string("$guard with big-orbit uses max speed percent:")) {
-					float max_percent;
-					stuff_float(&max_percent);
-					if (max_percent > 0.0f && max_percent <= 1.0f) {
-						profile->guard_big_orbit_max_speed_percent = max_percent;
-					} else {
-						mprintf(("Warning: \"$guard with big-orbit uses max speed percent:\" should be > 0 and <= 1 (read %f). Value will not be used.\n", max_percent));
-					}
-				}
-
-				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);
-
-				set_flag(profile, "$AI balances shields instead of directs when attacked:", AI::Profile_Flags::AI_balances_shields_when_attacked);
-
-				set_flag(profile, "$disable AI transferring energy:", AI::Profile_Flags::Disable_ai_transferring_energy);
-
-				set_flag(profile, "$enable freespace 1 style missile behavior:", AI::Profile_Flags::Freespace_1_missile_behavior);
-
-				set_flag(profile, "$ETS uses ship class power output:", AI::Profile_Flags::ETS_uses_power_output);
-
-				set_flag(profile, "$ETS energy same regardless of system presence:", AI::Profile_Flags::ETS_energy_same_regardless_of_system_presence);
-
-
-				// end of options ----------------------------------------

 				// if we've been through once already and are at the same place, force a move
 				if (saved_Mp && (saved_Mp == Mp))
@@ -720,7 +607,7 @@ void parse_ai_profiles_tbl(const char *filename)
 					char tmp[60];
 					memset(tmp, 0, 60);
 					strncpy(tmp, Mp, 59);
-					mprintf(("WARNING: Unrecognized parameter in %s: %s\n", filename, tmp));
+					mprintf(("WARNING: Unrecognized parameter in ai_profiles: %s\n", tmp));

 					Mp++;
 				}
@@ -755,21 +642,12 @@ void ai_profiles_init()
 	// init retail entry first
 	parse_ai_profiles_tbl(NULL);

-	// Allow mission_profiles.tbl to be a alias of ai_profiles.tbl, but only load one or the other.
-	// mission_profiles.tbl would be newer so assume intended, but print to the log to be sure - Mjn
-	char filename[MAX_FILENAME_LEN] = "ai_profiles.tbl";
-	if (cf_exists_full("mission_profiles.tbl", CF_TYPE_TABLES)) {
-		mprintf(("mission_profiles.tbl was found! Using that instead of ai_profiles.tbl...\n"));
-		strcpy_s(filename, "mission_profiles.tbl");
-	}
-
 	// now parse the supplied table (if any)
-	if (cf_exists_full(filename, CF_TYPE_TABLES))
-		parse_ai_profiles_tbl(filename);
+	if (cf_exists_full("ai_profiles.tbl", CF_TYPE_TABLES))
+		parse_ai_profiles_tbl("ai_profiles.tbl");

 	// parse any modular tables
 	parse_modular_table("*-aip.tbm", parse_ai_profiles_tbl);
-	parse_modular_table("*-msp.tbm", parse_ai_profiles_tbl);

 	// set default if specified
 	temp = ai_profile_lookup(Default_profile_name);
@@ -794,7 +672,6 @@ void ai_profile_t::reset()

    flags.reset();

-    los_min_detection_radius = 10.0f;
    ai_path_mode = AI_PATH_MODE_NORMAL;
 	subsystem_path_radii = 0;
    bay_arrive_speed_mult = 1.0f;
@@ -802,17 +679,6 @@ void ai_profile_t::reset()
 	second_order_lead_predict_factor = 0;
 	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;
-
-	better_collision_avoid_aggression_combat = 3.5f;
-	better_collision_avoid_aggression_guard = 3.5f;
-
-	standard_strafe_when_below_speed = 3.0f;
-	strafe_retreat_box_dist = 300.0f;
-	strafe_max_unhit_time = 20.0f;
-
-	guard_big_orbit_above_target_radius = 500.0f;
-	guard_big_orbit_max_speed_percent = 1.0f;

    for (int i = 0; i < NUM_SKILL_LEVELS; ++i) {
        max_incoming_asteroids[i] = 0;
@@ -835,12 +701,9 @@ void ai_profile_t::reset()
        shield_energy_scale[i] = 0;
        afterburner_recharge_scale[i] = 0;
        player_damage_scale[i] = 0;
-        player_damage_inflicted_scale[i] = 0;

        subsys_damage_scale[i] = 0;
-        beam_friendly_damage_cap[i] = -1.f;
-        weapon_friendly_damage_cap[i] = -1.f;
-        weapon_self_damage_cap[i] = -1.f;
+        beam_friendly_damage_cap[i] = 0;
        turn_time_scale[i] = 0;
        glide_attack_percent[i] = 0;
        circle_strafe_percent[i] = 0;
@@ -871,7 +734,7 @@ void ai_profile_t::reset()
        player_autoaim_fov[i] = 0;
    }

-    for (int i = 0; i <= MAX_DETAIL_VALUE; ++i) {
+    for (int i = 0; i <= MAX_DETAIL_LEVEL; ++i) {
        detail_distance_mult[i] = 0;
    }

@@ -887,7 +750,7 @@ void ai_profile_t::reset()
 		flags.set(AI::Profile_Flags::Fix_ai_path_order_bug);
 		flags.set(AI::Profile_Flags::Aspect_invulnerability_fix);
 		flags.set(AI::Profile_Flags::Use_actual_primary_range);
-		flags.set(AI::Profile_Flags::Fightercraft_nonshielded_ships_can_manage_ets);
+		flags.set(AI::Profile_Flags::fightercraft_nonshielded_ships_can_manage_ets);
 	}
 	// this flag has been enabled ever since 3.7.2
 	if (mod_supports_version(3, 7, 2)) {
@@ -897,10 +760,6 @@ void ai_profile_t::reset()
 	if (mod_supports_version(3, 6, 10)) {
 		flags.set(AI::Profile_Flags::Reset_last_hit_target_time_for_player_hits);
 	}
-	// backwards compatible flag for a bug accidentally introduced during this time
-	if (mod_supports_version(3, 6, 14) && !mod_supports_version(23, 1, 0)) {
-		flags.set(AI::Profile_Flags::Carry_shield_difficulty_scaling_bug);
-	}
 	if (mod_supports_version(21, 4, 0)) {
 		flags.set(AI::Profile_Flags::Fixed_ship_weapon_collision);
 	}
@@ -909,23 +768,4 @@ void ai_profile_t::reset()
 		flags.set(AI::Profile_Flags::Prevent_negative_turret_ammo);
 		flags.set(AI::Profile_Flags::Fix_keep_safe_distance);
 	}
-	if (mod_supports_version(23, 0, 0)) {
-		flags.set(AI::Profile_Flags::Fix_good_rearm_time_bug);
-		flags.set(AI::Profile_Flags::No_continuous_turn_on_attack);
-		flags.set(AI::Profile_Flags::Fixed_removing_play_dead_order);
-	}
-	if (mod_supports_version(23, 2, 0)) {
-		flags.set(AI::Profile_Flags::Ships_playing_dead_dont_manage_ets);
-	}
-	if (mod_supports_version(23, 4, 0)) {
-		flags.set(AI::Profile_Flags::Hudsquadmsg_tactical_disarm_disable);
-	}
-	if (mod_supports_version(24, 2, 0)) {
-		flags.set(AI::Profile_Flags::Debris_respects_big_damage);
-		flags.set(AI::Profile_Flags::Force_beam_turret_fov);
-		flags.set(AI::Profile_Flags::Guards_ignore_protected_attackers);
-	}
-	if (mod_supports_version(25, 0, 0)) {
-		flags.set(AI::Profile_Flags::Fix_avoid_shockwave_bugs);
-	}
 }
@@ -21,7 +21,7 @@
 #define	AI_RANGE_AWARE_SEC_SEL_MODE_RETAIL 0
 #define	AI_RANGE_AWARE_SEC_SEL_MODE_AWARE 1
 	
-#define MAX_AI_PROFILES	8
+#define MAX_AI_PROFILES	5

 class ai_profile_t {
 public:
@@ -53,12 +53,9 @@ public:
 	float shield_energy_scale[NUM_SKILL_LEVELS];			// shield energy available
 	float afterburner_recharge_scale[NUM_SKILL_LEVELS];		// speed of afterburner recharge
 	float player_damage_scale[NUM_SKILL_LEVELS];			// damage applied to the player
-	float player_damage_inflicted_scale[NUM_SKILL_LEVELS];	// damage applied by the player
 	
 	float subsys_damage_scale[NUM_SKILL_LEVELS];			// damage applied to a player subsystem
 	float beam_friendly_damage_cap[NUM_SKILL_LEVELS];		// damage cap values for friendly beam fire
-	float weapon_friendly_damage_cap[NUM_SKILL_LEVELS];
-	float weapon_self_damage_cap[NUM_SKILL_LEVELS];
 	float turn_time_scale[NUM_SKILL_LEVELS];				// speed at which enemy ships turn
 	float glide_attack_percent[NUM_SKILL_LEVELS];			// SUSHI: The likelihood (0.0-1.0) of the AI to use the "glide attack" move
 	float circle_strafe_percent[NUM_SKILL_LEVELS];			// SUSHI: The likelihood (0.0-1.0) of the AI to use the "circle strafe" move
@@ -99,10 +96,7 @@ public:
 	// Player-specific autoaim FOV override
 	float player_autoaim_fov[NUM_SKILL_LEVELS];

-	float detail_distance_mult[MAX_DETAIL_VALUE + 1];	//MAX_DETAIL_VALUE really needs to be 4
-
-	// minimum radius for the line-of-sight (los) detection --wookieejedi
-	float los_min_detection_radius;
+	float detail_distance_mult[MAX_DETAIL_LEVEL + 1];	//MAX_DETAIL_LEVEL really needs to be 4

 	int ai_path_mode;

@@ -123,27 +117,6 @@ public:
 	// how often turrets shoulds check for new targets, milliseconds
 	float turret_target_recheck_time;

-	// Multiplier value so the player can also experience rotational effects from collisions --wookieejedi
-	float rot_fac_multiplier_ply_collisions; 
-
-	// Collision avoidance options  --developed by asteroth, exposed by wookieejedi
-	//   Velocity / turn rate gives us a vector which represents the minimum 'bug out' distance.
-	//   However this will be a significant underestimate, it doesn't take into account acceleration
-	//   with regards to its turn speed, nor already existing rotvel, nor the angular distance
-	//   to the particular avoidance vector it comes up with.
-	//   These would significantly complicate the calculation, so for now, it is all bundled into these magic numbers.
-	float better_collision_avoid_aggression_combat;
-	float better_collision_avoid_aggression_guard;
-
-	// AI strafing options  --wookieejedi
-	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
-
-	// 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() 
-
    void reset();
 };

@@ -39,9 +39,10 @@
 #define MIN_DOT_TO_ATTACK_MOVING_SUBSYS	0.97f

 // 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	STRAFE_RETREAT_BOX_DIST			300		// distance beyond the bounding box to retreat
+#define STRAFE_MAX_UNHIT_TIME		20		// Maximum amount of time to stay in strafe mode if not hit

 #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
@@ -66,8 +67,9 @@ int	ai_big_maybe_follow_subsys_path(int do_dot_check=1);
 void ai_big_strafe_position();
 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);
+extern int model_which_octant_distant_many( vec3d *pnt, int model_num,matrix *model_orient, vec3d * model_pos, polymodel **pm, int *octs);
+extern void compute_desired_rvec(vec3d *rvec, vec3d *goal_pos, vec3d *cur_pos);
+extern void big_ship_collide_recover_start(object *objp, object *big_objp, vec3d *collision_normal);


 //	Called by ai_big_pick_attack_point.
@@ -75,15 +77,16 @@ extern void big_ship_collide_recover_start(const object *objp, const object *big
 //	If truly_random flag set (haha), then generate a pretty random number.  Otherwise, generate a static rand which
 //	tends to not change from frame to frame.
 //	Try four times and choose nearest point to increase chance of getting a good point.
-void ai_bpap(const object *objp, const vec3d *attacker_objp_pos, const vec3d *attacker_objp_fvec, vec3d *attack_point, vec3d *local_attack_point, float fov, float weapon_travel_dist, vec3d *surface_normal, const ship_subsys *ss)
+void ai_bpap(object *objp, vec3d *attacker_objp_pos, vec3d *attacker_objp_fvec, vec3d *attack_point, vec3d *local_attack_point, float fov, float weapon_travel_dist, vec3d *surface_normal, ship_subsys *ss)
 {
 	float		nearest_dist;
 	vec3d	result_point, best_point;
 	vec3d	rel_point;
 	int		num_tries;
-	int		i;	
+	model_octant	*octp;
+	polymodel	*pm;
+	int		i, q, octs[4];	
 	ship_info *sip = &Ship_info[Ships[objp->instance].ship_info_index];
-	polymodel* pm = model_get(sip->model_num);
 	model_subsystem *tp = NULL;
 	if (ss != NULL)
 		tp = ss->system_info;	
@@ -91,53 +94,63 @@ void ai_bpap(const object *objp, const vec3d *attacker_objp_pos, const vec3d *at
 	best_point = objp->pos;
 	nearest_dist = weapon_travel_dist;

-	// attempt anywhere from 16 to 4 times, more if we're closer
+	model_which_octant_distant_many(attacker_objp_pos, sip->model_num, &objp->orient, &objp->pos, &pm, octs);
+
 	num_tries = (int) (vm_vec_dist(&objp->pos, attacker_objp_pos)/objp->radius);
+
 	if (num_tries >= 4)
 		num_tries = 1;
 	else
-		num_tries = (4 - num_tries) * 4;
+		num_tries = 4 - num_tries;

-	vm_vec_zero(local_attack_point);
+	//	Index #0 is best one.
+	if ( pm->octants[octs[0]].verts ) {
+		*local_attack_point = *pm->octants[octs[0]].verts[0];	//	Set just in case it doesn't get set below.
+	} else {
+		vm_vec_zero(local_attack_point);
+	}

-	auto collision_tree = model_get_bsp_collision_tree(pm->submodel[pm->detail[0]].collision_tree_index);
+	for (q=0; q<4; q++) {
+		octp = &pm->octants[octs[q]];
+		if (octp->nverts > 0) {

-	if (!collision_tree->poly_centers.empty()) {
-		int num_polies = (int)collision_tree->poly_centers.size();
+			if (num_tries > octp->nverts)
+				num_tries = octp->nverts;

-		if (num_tries > num_polies)
-			num_tries = num_polies;
+			if (num_tries > octp->nverts)
+				num_tries = octp->nverts;

-		for (i=0; i<num_tries; i++) {
-			int	index;
-			float	dist, dot;
-			vec3d	v2p;
+			for (i=0; i<num_tries; i++) {
+				int	index;
+				float	dist, dot;
+				vec3d	v2p;

-			index = (int) (frand() * num_polies);
+				index = (int) (frand() * (octp->nverts));

-			rel_point = collision_tree->poly_centers[index];
-			vm_vec_unrotate(&result_point, &rel_point, &objp->orient);
-			vm_vec_add2(&result_point, &objp->pos);
+				rel_point = *octp->verts[index];
+				vm_vec_unrotate(&result_point, &rel_point, &objp->orient);
+				vm_vec_add2(&result_point, &objp->pos);

-			dist = vm_vec_normalized_dir(&v2p, &result_point, attacker_objp_pos);
-			bool in_fov = false;
+				dist = vm_vec_normalized_dir(&v2p, &result_point, attacker_objp_pos);
+				bool in_fov = false;

-			dot = vm_vec_dot(&v2p, attacker_objp_fvec);
-			if (tp == NULL) {
-				if (dot > fov)
-					in_fov = true;
-			} else {
-				in_fov = turret_fov_test(ss, attacker_objp_fvec, &v2p);
-			}
+				dot = vm_vec_dot(&v2p, attacker_objp_fvec);
+				if (tp == NULL) {
+					if (dot > fov)
+						in_fov = true;
+				} else {
+					in_fov = turret_fov_test(ss, attacker_objp_fvec, &v2p);
+				}

-			if (in_fov) {
-				if (dist < nearest_dist) {
-					nearest_dist = dist;
-					best_point = result_point;
-					*local_attack_point = rel_point;
-					Assert( !vm_is_vec_nan(local_attack_point) );
-					if (dot > (1.0f + fov)/2.0f)	//	If this point is quite good, quit searching for a better one.
-						goto done_1;
+				if (in_fov) {
+					if (dist < nearest_dist) {
+						nearest_dist = dist;
+						best_point = result_point;
+						*local_attack_point = rel_point;
+						Assert( !vm_is_vec_nan(local_attack_point) );
+						if (dot > (1.0f + fov)/2.0f)	//	If this point is quite good, quit searching for a better one.
+							goto done_1;
+					}
 				}
 			}
 		}
@@ -161,6 +174,8 @@ done_1:
 	}
 	
 	mc_info mc;
+	mc_info_init(&mc);
+
 	mc.model_instance_num = Ships[objp->instance].model_instance_num;
 	mc.model_num = sip->model_num;
 	mc.orient = &objp->orient;
@@ -192,7 +207,7 @@ done_1:
 //
 //	Note: Default value for fov is 1.0f  1.0f means don't use fov parameter.
 //	If fov != 1.0f, try up to four times to find a point that's in the field of view.
-void ai_big_pick_attack_point_turret(const object *objp, ship_subsys *ssp, const vec3d *gpos, const vec3d *gvec, vec3d *attack_point, float fov, float weapon_travel_dist)
+void ai_big_pick_attack_point_turret(object *objp, ship_subsys *ssp, vec3d *gpos, vec3d *gvec, vec3d *attack_point, float fov, float weapon_travel_dist)
 {
 	if (!timestamp_elapsed(ssp->turret_pick_big_attack_point_timestamp)) {
 		vec3d	result_point;
@@ -212,7 +227,7 @@ void ai_big_pick_attack_point_turret(const object *objp, ship_subsys *ssp, const
 //	Note: Default value for fov is 1.0f  1.0f means don't use fov parameter.
 //	If fov != 1.0f, try up to four times to find a point that's in the field of view.
 //	Note, attacker_objp can be a ship or a weapon.
-void ai_big_pick_attack_point(const object *objp, const object *attacker_objp, vec3d *attack_point, float fov)
+void ai_big_pick_attack_point(object *objp, object *attacker_objp, vec3d *attack_point, float fov)
 {
 	Assert(objp->instance > -1);
 	Assert(objp->type == OBJ_SHIP);
@@ -410,7 +425,7 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 				}
 			}

-			if ( ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, true) ) {
+			if ( ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, 1) ) {
 				subsys_in_sight = 1;
 			}
 		}
@@ -534,18 +549,18 @@ bool ai_new_maybe_reposition_attack_subsys() {

 	// get world pos of eye (stored in geye)
 	ep = &(pm->view_positions[Ships[Pl_objp->instance].current_viewpoint]);
-	model_local_to_global_point(&geye, &ep->pnt, pm, 0, &Pl_objp->orient, &Pl_objp->pos);
+	model_local_to_global_point(&geye, &ep->pnt, pm->id, 0, &Pl_objp->orient, &Pl_objp->pos);

 	// get world pos of subsystem
-	get_subsystem_pos(&gsubpos, target_objp, aip->targeted_subsys);
+	vm_vec_unrotate(&gsubpos, &aip->targeted_subsys->system_info->pnt, &En_objp->orient);
+	vm_vec_add2(&gsubpos, &En_objp->pos);

 	// you're in sight! shoot it!
-	if (ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, false))
+	if (ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, 0))
 		return false;

 	// not in sight, gotta get there
 	vec3d* good_pos = nullptr;
-	vec3d world_goal_pos;
 	// For performance reasons we only recheck once a second, otherwise we reuse the last found target.
 	if (timestamp_elapsed(aip->next_dynamic_path_check_time)) {
 		vec3d tgt2pl = Pl_objp->pos - target_objp->pos;
@@ -567,6 +582,7 @@ bool ai_new_maybe_reposition_attack_subsys() {
 		vm_rot_point_around_line(&goal_pos, &tgt2pl, angle2goal, &vmd_zero_vector, &cross);

 		// then scale in (or out) towards our subsys
+		vec3d world_goal_pos;
 		float new_radius = ((subsys_dist - pl_dist) * (angle2goal / angle2subsys)) + pl_dist;
 		vm_vec_copy_scale(&world_goal_pos, &goal_pos, new_radius / pl_dist);
 		world_goal_pos += target_objp->pos;
@@ -602,7 +618,6 @@ bool ai_new_maybe_reposition_attack_subsys() {
 		else
 			good_pos = &world_goal_pos;
 		aip->next_dynamic_path_check_time = timestamp( AI_DYNAMIC_PATH_RECHECK_DELAY );
-		aip->last_dynamic_path_goal = *good_pos;

 	}
 	else{ //Not enough time has passed till recheck.
@@ -616,17 +631,15 @@ bool ai_new_maybe_reposition_attack_subsys() {
 	accelerate_ship(aip, subsys_distance > 200.0f ? 1.0f : subsys_distance / 200.0f);

 	if (!(Ships[Pl_objp->instance].flags[Ship::Ship_Flags::Afterburner_locked])) {
-		if (ai_willing_to_afterburn_hard(aip) && subsys_distance > 1000.0f)
-			ai_afterburn_hard(Pl_objp, aip);
-		else if (subsys_distance > 300.0f) {
+		if (subsys_distance > 300.0f) {
 			if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
 				afterburners_start(Pl_objp);
 				aip->afterburner_stop_time = Missiontime + 2 * F1_0;
 			}
 		}
-	} else
-		afterburners_stop(Pl_objp);
-
+		else
+			afterburners_stop(Pl_objp);
+	}
 	return true;

 }
@@ -648,17 +661,16 @@ int ai_big_maybe_start_strafe(ai_info *aip, ship_info *sip)
 	// are near
 	if ( sip->is_small_ship() ) {
 		if ( timestamp_elapsed(aip->scan_for_enemy_timestamp) ) {
+			ship_obj	*so;
 			object	*test_objp;
 			ship		*test_sp;
 			float		dist_squared;
 			
 			aip->scan_for_enemy_timestamp = timestamp(SCAN_FIGHTERS_INTERVAL);
 			// iterate through ships, and see if any fighter/bomber from opposite team are near
-			for (auto so: list_range(&Ship_obj_list)) {
+			so = GET_FIRST(&Ship_obj_list);
+			while( so != END_OF_LIST(&Ship_obj_list) ) {
 				test_objp = &Objects[so->objnum];
-				if (test_objp->flags[Object::Object_Flags::Should_be_dead])
-					continue;
-
 				test_sp = &Ships[test_objp->instance];

 				if ( iff_x_attacks_y(Ships[Pl_objp->instance].team, test_sp->team) ) {
@@ -669,6 +681,7 @@ int ai_big_maybe_start_strafe(ai_info *aip, ship_info *sip)
 						}
 					}
 				}
+				so = GET_NEXT(so);
 			}
 		}
 	}
@@ -693,9 +706,6 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 		if (Pl_objp->phys_info.speed < 3.0f) {
 			object *objp;
 			for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
-				if (objp->flags[Object::Object_Flags::Should_be_dead])
-					continue;
-
 				if ((objp->type == OBJ_WEAPON) && (iff_x_attacks_y(Ships[Pl_objp->instance].team, Weapons[objp->instance].team)))
 					if (Weapon_info[Weapons[objp->instance].weapon_info_index].subtype == WP_LASER) {
 						vec3d	in_vec;
@@ -718,21 +728,19 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 						}
 					}
 			}
+			
+			// Since ship is moving slowly and attacking a large ship, scan if enemy fighters are near, if so
+			// then enter strafe mode
+			if ( ai_big_maybe_start_strafe(aip, sip) ) {
+				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();
+				return;
+			}

 		} // end if ( Pl_objp->phys_info.speed < 3.0f ) 

-		// if moving slowly and attacking a large ship, 
-		// check if need to enter standard strafe mode
-		// 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))) {
-			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();
-			return;
-		}
-
 		//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) {
 			aip->previous_mode = aip->mode;
@@ -748,7 +756,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 			if (ai_new_maybe_reposition_attack_subsys())
 				return;
 		} else if ( ai_big_maybe_follow_subsys_path() ) {
-			if ((Pl_objp->phys_info.flags & PF_AFTERBURNER_ON) && !(aip->ai_flags[AI::AI_Flags::Kamikaze]) && !ai_willing_to_afterburn_hard(aip)) {
+			if ((Pl_objp->phys_info.flags & PF_AFTERBURNER_ON) && !(aip->ai_flags[AI::AI_Flags::Kamikaze])) {
 				afterburners_stop(Pl_objp);
 			}
 			return;
@@ -840,9 +848,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 			} else {
 				accelerate_ship(aip, accel);

-				if (ai_willing_to_afterburn_hard(aip) && accel > 0.99f && !(shipp->flags[Ship::Ship_Flags::Afterburner_locked])) {
-					ai_afterburn_hard(Pl_objp, aip);
-				} else if ((aip->ai_flags[AI::AI_Flags::Free_afterburner_use] || aip->ai_profile_flags[AI::Profile_Flags::Free_afterburner_use]) && !(shipp->flags[Ship::Ship_Flags::Afterburner_locked]) && (accel > 0.95f)) {
+				if ((aip->ai_flags[AI::AI_Flags::Free_afterburner_use] || aip->ai_profile_flags[AI::Profile_Flags::Free_afterburner_use]) && !(shipp->flags[Ship::Ship_Flags::Afterburner_locked]) && (accel > 0.95f)) {
 					if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
 						afterburners_start(Pl_objp);
 						aip->afterburner_stop_time = Missiontime + 3*F1_0;
@@ -861,9 +867,9 @@ void ai_big_chase_ct()
 	ai_chase_ct();
 }

-extern bool ai_select_secondary_weapon(object *objp, ship_weapon *swp, int priority1 = -1, int priority2 = -1);
+extern void 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 void ai_choose_secondary_weapon(object *objp, ai_info *aip, object *en_objp);
 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);
@@ -894,7 +900,7 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 		
 		//	Chance of hitting ship is based on dot product of firing ship's forward vector with vector to ship
 		//	and also the size of the target relative to distance to target.
-		if (dot_to_enemy > std::max(0.5f, 0.90f + aip->ai_accuracy / 10.0f - En_objp->radius / std::max(1.0f, dist_to_enemy))) {
+		if (dot_to_enemy > MAX(0.5f, 0.90f + aip->ai_accuracy/10.0f - En_objp->radius/MAX(1.0f,dist_to_enemy))) {

 			ship *temp_shipp;
 			temp_shipp = &Ships[Pl_objp->instance];
@@ -914,13 +920,13 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 			}

 			if (tswp->num_secondary_banks > 0) {
-				if ( !(En_objp->flags[Object::Object_Flags::Protected]) || ai_goal_is_disable_or_disarm(aip->goals[0].ai_mode) ) {
-					bool valid_secondary = ai_choose_secondary_weapon(Pl_objp, aip, En_objp);
+				if (!(En_objp->flags[Object::Object_Flags::Protected]) || (aip->goals[0].ai_mode & (AI_GOAL_DISABLE_SHIP | AI_GOAL_DISARM_SHIP))) {
+					ai_choose_secondary_weapon(Pl_objp, aip, En_objp);
 					int current_bank = tswp->current_secondary_bank;
-					if (current_bank > -1 && valid_secondary) {
+					if (current_bank > -1) {
 						weapon_info	*swip = &Weapon_info[tswp->secondary_bank_weapons[current_bank]];

-						if ( !(En_objp->flags[Object::Object_Flags::Protected]) || (ai_goal_is_disable_or_disarm(aip->goals[0].ai_mode) && swip->wi_flags[Weapon::Info_Flags::Puncture]) ) { //override lockdown on protected ships when using anti subsystem weapons - Valathil
+						if(!(En_objp->flags[Object::Object_Flags::Protected]) || ((aip->goals[0].ai_mode & (AI_GOAL_DISABLE_SHIP | AI_GOAL_DISARM_SHIP)) && swip->wi_flags[Weapon::Info_Flags::Puncture] )) { //override lockdown on protected ships when using anti subsystem weapons - Valathil
 							//	If ship is protected and very low on hits, don't fire missiles.
 							if (!(En_objp->flags[Object::Object_Flags::Protected]) || (En_objp->hull_strength > 10*swip->damage)) {
 								if (aip->ai_flags[AI::AI_Flags::Unload_secondaries]) {
@@ -1013,8 +1019,6 @@ void ai_big_switch_to_chase_mode(ai_info *aip)
 	aip->submode_start_time = Missiontime;
 }

-extern weapon_info* ai_get_weapon(ship_weapon* swp);
-
 // Make object Pl_objp chase object En_objp, which is a big ship, not a small ship.
 void ai_big_chase()
 {
@@ -1034,38 +1038,16 @@ void ai_big_chase()
 	player_pos = Pl_objp->pos;
 	ai_big_pick_attack_point(En_objp, Pl_objp, &enemy_pos, 0.8f);

-	weapon_info* wip = ai_get_weapon(&shipp->weapons);
-	bool ballistic_aiming = !IS_VEC_NULL(&The_mission.gravity) && wip && wip->gravity_const != 0.0f;
-	bool valid_ballistic_trajectory = true;
+	//	Compute the predicted position of the center of the ship, then add the delta to the goal pos.
+	if (En_objp->phys_info.speed > 3.0f) {
+		set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, &En_objp->pos, &En_objp->phys_info.vel, aip);
+		vm_vec_add2(&enemy_pos, &predicted_enemy_pos);
+		vm_vec_sub2(&enemy_pos, &En_objp->pos);
+	}	else
+		predicted_enemy_pos = En_objp->pos;

-	if (!ballistic_aiming) {
-		//	Compute the predicted position of the center of the ship, then add the delta to the goal pos.
-		if (En_objp->phys_info.speed > 3.0f) {
-			set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, &En_objp->pos, &En_objp->phys_info.vel, aip);
-			vm_vec_add2(&enemy_pos, &predicted_enemy_pos);
-			vm_vec_sub2(&enemy_pos, &En_objp->pos);
-		} else
-			predicted_enemy_pos = En_objp->pos;
-
-		if (aip->targeted_subsys != NULL) {
-			get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
-		}
-	} else {
-		if (aip->targeted_subsys != NULL) {
-			get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
-		}
-
-		vec3d gravity = The_mission.gravity * wip->gravity_const;
-		vec3d target;
-		valid_ballistic_trajectory = 
-			physics_lead_ballistic_trajectory(&player_pos, &enemy_pos, &En_objp->phys_info.vel, wip->max_speed, &gravity, &target);
-
-		if (valid_ballistic_trajectory) {
-			enemy_pos = Pl_objp->pos + target * vm_vec_dist(&Pl_objp->pos, &enemy_pos);
-			predicted_enemy_pos = enemy_pos;
-		} else {
-			set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, &En_objp->pos, &En_objp->phys_info.vel, aip);
-		}
+	if (aip->targeted_subsys != NULL) {
+		get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
 	}

 	dist_to_enemy = vm_vec_normalized_dir(&vec_to_enemy, &enemy_pos, &player_pos); // - En_objp->radius;
@@ -1096,7 +1078,7 @@ void ai_big_chase()
 	//	If just acquired target, or target is not in reasonable cone, don't refine believed enemy position.
 	if ((dot_to_enemy < 0.25f) || (aip->target_time < 1.0f) || (aip->ai_flags[AI::AI_Flags::Seek_lock])) {
 		update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy - En_objp->radius, En_objp->radius);
-	} else if (aip->targeted_subsys != NULL && !ballistic_aiming) {
+	} else if (aip->targeted_subsys != NULL) {		
 		Assert(aip->targeted_subsys != NULL);
 		get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
 		vm_vec_add2(&enemy_pos, &predicted_enemy_pos);
@@ -1128,7 +1110,7 @@ void ai_big_chase()
 			}
 		}

-		if (!aip->ai_profile_flags[AI::Profile_Flags::No_continuous_turn_on_attack] && aip->target_time < 2.0f)
+		if (aip->target_time < 2.0f)
 			if ((dot_to_enemy < 0.9f) || (dist_to_enemy > 300.0f)) {
 				aip->submode = SM_CONTINUOUS_TURN;
 				aip->submode_start_time = Missiontime - fl2f(2.75f);	//	This backdated start time allows immediate switchout.
@@ -1336,7 +1318,7 @@ void ai_big_chase()
 	//     I noticed AI ships firing inappropriately when following a path near a big ship.
 	//		 TODO: investigate why ships fire (and aren't close to hitting ship) when following a path near
 	//				 a big ship
-	if (aip->mode != AIM_EVADE && aip->path_start == -1 && (!ballistic_aiming || valid_ballistic_trajectory)) {
+	if (aip->mode != AIM_EVADE && aip->path_start == -1 ) {
 		ai_big_maybe_fire_weapons(dist_to_enemy, dot_to_enemy);
 	} else {
 		if (flFrametime < 1.0f)
@@ -1440,7 +1422,7 @@ static int ai_big_strafe_maybe_retreat(const vec3d *target_pos)

 	//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
+	// Inside 2 sec retreat, setting goal point to box point + 300m
 	// If collision, use std collision resolution.
 	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]) {
@@ -1448,13 +1430,13 @@ static int ai_big_strafe_maybe_retreat(const vec3d *target_pos)
 			aip->ai_flags.remove(AI::AI_Flags::Target_collision);
 			big_ship_collide_recover_start(Pl_objp, En_objp, nullptr);
 		} else {
-			// too close for comfort so fly to box point + strafe_retreat_box_dist
+			// too close for comfort so fly to box point + 300
 			aip->submode = AIS_STRAFE_RETREAT1;
 			aip->submode_start_time = Missiontime;

 			int is_inside;
 			vec3d goal_point;
-			get_world_closest_box_point_with_delta(&goal_point, En_objp, &Pl_objp->pos, &is_inside, The_mission.ai_profile->strafe_retreat_box_dist);
+			get_world_closest_box_point_with_delta(&goal_point, En_objp, &Pl_objp->pos, &is_inside, STRAFE_RETREAT_BOX_DIST);

 			// set goal point
 			aip->goal_point = goal_point;
@@ -1569,7 +1551,8 @@ void ai_big_strafe_attack()
 	accelerate_ship(aip, accel);

 	// if haven't been hit in quite a while, leave strafe mode
-	fix long_enough = fl2f(The_mission.ai_profile->strafe_max_unhit_time);
+	fix long_enough;
+	long_enough = F1_0 * STRAFE_MAX_UNHIT_TIME;
 	if ( (last_hit > long_enough) && ( (Missiontime - aip->submode_parm0) > long_enough) ) {
 		ai_big_switch_to_chase_mode(aip);
 	}
@@ -1616,11 +1599,11 @@ void ai_big_strafe_glide_attack()
 	//If we haven't chosen the goal point yet, do so now
 	if (aip->submode_parm1 == 0) {
 		//Pick goal point. This should be a random point that passes through the circle whose normal is the vector between attacker and target
-		vec3d targetToAttackerDir;
-		vm_vec_normalized_dir(&targetToAttackerDir, &Pl_objp->pos, &target_objp->pos);
-		matrix orient;
-		vm_vector_2_matrix_norm(&orient, &targetToAttackerDir, nullptr, nullptr);
+		vec3d targetToAttacker;
 		vec3d tangentPoint;
+		vm_vec_sub(&targetToAttacker, &Pl_objp->pos, &target_objp->pos);
+		matrix orient;
+		vm_vector_2_matrix(&orient, &targetToAttacker, NULL, NULL);
 		vm_vec_random_in_circle(&tangentPoint, &target_objp->pos, &orient, target_objp->radius + GLIDE_STRAFE_DISTANCE, true);
 		//Get tangent point in coords relative to ship, scale it up so the actual goal point is far away, then put back in world coords
 		vm_vec_sub2(&tangentPoint, &Pl_objp->pos);
@@ -1641,7 +1624,7 @@ void ai_big_strafe_glide_attack()
 		//Keep going until we are too far away.
 		//If we are still on approach but too far away, this will still trigger. This will allow us to reposition the target
 		//point and allow for a "jinking" effect.
-		if (target_ship_dist > (The_mission.ai_profile->strafe_retreat_box_dist + target_objp->radius) &&
+		if (target_ship_dist > (STRAFE_RETREAT_BOX_DIST + target_objp->radius) &&
 			Missiontime - aip->submode_start_time > i2f(GLIDE_STRAFE_MIN_TIME)) {
 			//This checks whether we are moving toward the target or away from it.  If moving towards, we reset the stage so that we
 			//pick a new attack vector (jinking). If moving away, we're at the end of a run so do a full reset (possibly allowing a 
@@ -1691,7 +1674,7 @@ void ai_big_strafe_glide_attack()

 	// if haven't been hit in quite a while, leave strafe mode
 	// (same as ai_big_strafe_attack)
-	fix long_enough = fl2f(The_mission.ai_profile->strafe_max_unhit_time);
+	fix long_enough = F1_0 * STRAFE_MAX_UNHIT_TIME;
 	if ( (Missiontime - aip->last_hit_time > long_enough) && ( (Missiontime - aip->submode_parm0) > long_enough) ) {
 		ai_big_switch_to_chase_mode(aip);
 	}
@@ -1841,7 +1824,7 @@ void ai_big_strafe()

 /*
 	if ( aip->goal_objnum != aip->target_objnum ) {
-		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
+		Int3();	// what is going on here? - Get Alan
 		aip->mode = AIM_NONE;
 		return;
 	}
@@ -1887,7 +1870,7 @@ void ai_big_strafe()
 	{
 		//Re-roll for random sidethrust every 2 seconds
 		if (static_randf((Missiontime + static_rand(aip->shipnum)) >> 17) < aip->ai_random_sidethrust_percent) {
-			do_random_sidethrust(aip, &Ship_info[Ships[aip->shipnum].ship_info_index]);
+			do_random_sidethrust(aip, &Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index]);
 		}
 	}
 }
@@ -1933,10 +1916,7 @@ int ai_big_maybe_enter_strafe_mode(const object *pl_objp, int weapon_objnum)
 	weapon_objp = &Objects[weapon_objnum];
 	Assert(weapon_objp->type == OBJ_WEAPON);

-	if (weapon_objp->parent < 0) {
-		return 0;
-	}
-	Assert(weapon_objp->parent < MAX_OBJECTS);
+	Assert(weapon_objp->parent >= 0 && weapon_objp->parent < MAX_OBJECTS);
 	parent_objp = &Objects[weapon_objp->parent];
 	if ( (parent_objp->signature != weapon_objp->parent_sig) || (parent_objp->type != OBJ_SHIP) ) {
 		return 0;
@@ -24,8 +24,8 @@ void	ai_big_subsys_path_cleanup(ai_info *aip);
 void	ai_big_strafe();
 int	ai_big_maybe_enter_strafe_mode(const object *objp, int weapon_objnum);
 void	ai_big_strafe_maybe_attack_turret(const object *ship_objp, const object *weapon_objp);
-void ai_big_pick_attack_point(const object *objp, const object *attacker_objp, vec3d *attack_point, float fov=1.0f);
-void ai_big_pick_attack_point_turret(const object *objp, ship_subsys *ssp, const vec3d *gpos, const vec3d *gvec, vec3d *attack_point, float weapon_travel_dist, float fov=1.0f);
+void ai_big_pick_attack_point(object *objp, object *attacker_objp, vec3d *attack_point, float fov=1.0f);
+void ai_big_pick_attack_point_turret(object *objp, ship_subsys *ssp, vec3d *gpos, vec3d *gvec, vec3d *attack_point, float weapon_travel_dist, float fov=1.0f);

 // default distance for following subsystem path points --wookieejedi
 // the value is 5 because that was the original value specified in ai_big_maybe_follow_subsys_path()
@@ -12,161 +12,89 @@
 #ifndef _AIGOALS_H
 #define _AIGOALS_H

-#include "ai/ai_flags.h"
 #include "globalincs/globals.h"
 #include "globalincs/pstypes.h"
 #include "parse/sexp.h"
-#include "scripting/lua/LuaTypes.h"
-#include "scripting/lua/LuaValue.h"

 struct wing;
 struct ai_info;
+struct ai_goal;

 // macros for goals which get set via sexpressions in the mission code

-// types of ai goals -- these will help us to determine which goals should
-// have priority over others (i.e. when a player issues a goal to a wing, then a seperate
-// goal to a ship in that wing).  We would probably use this type in conjunction with
-// goal priority to establish which goal to follow
-enum class ai_goal_type
-{
-	INVALID = 0,
-	EVENT_SHIP,		// from mission event direct to ship
-	EVENT_WING,		// from mission event direct to wing
-	PLAYER_SHIP,	// from player direct to ship
-	PLAYER_WING,	// from player direct to wing
-	DYNAMIC			// created on the fly
-};
-
-// IMPORTANT!  If you add a new AI_GOAL_x enum, be sure to update the functions
+// IMPORTANT!  If you add a new AI_GOAL_x define, be sure to update the functions
 // ai_update_goal_references() and query_referenced_in_ai_goals() or else risk breaking
 // Fred.  If the goal you add doesn't have a target (such as chase_any), then you don't have
 // to worry about doing this.  Also add it to list in Fred\Management.cpp, and let Hoffoss know!
 // WMC - Oh and add them to Ai_goal_names plz. TY! :)
 // Goober5000 - As well as Ai_goal_text and Ai_goal_list, if appropriate
-enum ai_goal_mode : uint8_t
-{
-	AI_GOAL_NONE = 0,
-	AI_GOAL_PLACEHOLDER_1,
+#define AI_GOAL_CHASE					(1<<1)	// 0x00000002
+#define AI_GOAL_DOCK					(1<<2)	// 0x00000004	// used for undocking as well
+#define AI_GOAL_WAYPOINTS				(1<<3)	// 0x00000008
+#define AI_GOAL_WAYPOINTS_ONCE			(1<<4)	// 0x00000010
+#define AI_GOAL_WARP					(1<<5)	// 0x00000020
+#define AI_GOAL_DESTROY_SUBSYSTEM		(1<<6)	// 0x00000040
+#define AI_GOAL_FORM_ON_WING			(1<<7)	// 0x00000080
+#define AI_GOAL_UNDOCK					(1<<8)	// 0x00000100
+#define AI_GOAL_CHASE_WING				(1<<9)	// 0x00000200
+#define AI_GOAL_GUARD					(1<<10)	// 0x00000400
+#define AI_GOAL_DISABLE_SHIP			(1<<11)	// 0x00000800
+#define AI_GOAL_DISARM_SHIP				(1<<12)	// 0x00001000
+#define AI_GOAL_CHASE_ANY				(1<<13)	// 0x00002000
+#define AI_GOAL_IGNORE					(1<<14)	// 0x00004000
+#define AI_GOAL_GUARD_WING				(1<<15)	// 0x00008000
+#define AI_GOAL_EVADE_SHIP				(1<<16)	// 0x00010000

-	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,
-	AI_GOAL_WARP,
-	AI_GOAL_DESTROY_SUBSYSTEM,
-	AI_GOAL_FORM_ON_WING,
-	AI_GOAL_UNDOCK,
-	AI_GOAL_CHASE_WING,
-	AI_GOAL_GUARD,
-	AI_GOAL_DISABLE_SHIP,
-	AI_GOAL_DISARM_SHIP,
-	AI_GOAL_CHASE_ANY,
-	AI_GOAL_IGNORE,
-	AI_GOAL_GUARD_WING,
-	AI_GOAL_EVADE_SHIP,
+// the next goals are for support ships only
+#define AI_GOAL_STAY_NEAR_SHIP			(1<<17)	// 0x00020000
+#define AI_GOAL_KEEP_SAFE_DISTANCE		(1<<18)	// 0x00040000
+#define AI_GOAL_REARM_REPAIR			(1<<19)	// 0x00080000

-	// the next goals are for support ships only
-	AI_GOAL_STAY_NEAR_SHIP,
-	AI_GOAL_KEEP_SAFE_DISTANCE,
-	AI_GOAL_REARM_REPAIR,
+// resume regular goals
+#define AI_GOAL_STAY_STILL				(1<<20)	// 0x00100000
+#define AI_GOAL_PLAY_DEAD				(1<<21)	// 0x00200000

-	// resume regular goals
-	AI_GOAL_STAY_STILL,
-	AI_GOAL_PLAY_DEAD,
+// added by SCP
+#define AI_GOAL_CHASE_WEAPON			(1<<22)	// 0x00400000
+#define AI_GOAL_FLY_TO_SHIP				(1<<23) // 0x00800000
+#define AI_GOAL_IGNORE_NEW				(1<<24)	// 0x01000000
+#define AI_GOAL_CHASE_SHIP_CLASS		(1<<25)	// 0x02000000
+#define AI_GOAL_PLAY_DEAD_PERSISTENT	(1<<26)	// 0x03000000
+#define AI_GOAL_LUA						(1<<27) // 0x04000000

-	// added by SCP
-	AI_GOAL_CHASE_WEAPON,
-	AI_GOAL_FLY_TO_SHIP,
-	AI_GOAL_IGNORE_NEW,
-	AI_GOAL_CHASE_SHIP_CLASS,
-	AI_GOAL_PLAY_DEAD_PERSISTENT,
-	AI_GOAL_LUA,
-	AI_GOAL_DISARM_SHIP_TACTICAL,
-	AI_GOAL_DISABLE_SHIP_TACTICAL,
+// now the masks for ship types

-	AI_GOAL_NUM_VALUES
-};
+// Goober5000: added AI_GOAL_STAY_NEAR_SHIP and AI_GOAL_KEEP_SAFE_DISTANCE as valid for fighters
+//WMC - Don't need these anymore. Whee!
+/*
+#define AI_GOAL_ACCEPT_FIGHTER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_DESTROY_SUBSYSTEM | AI_GOAL_CHASE_WING | AI_GOAL_GUARD | AI_GOAL_DISABLE_SHIP | AI_GOAL_DISARM_SHIP | AI_GOAL_CHASE_ANY | AI_GOAL_IGNORE | AI_GOAL_IGNORE_NEW | AI_GOAL_GUARD_WING | AI_GOAL_EVADE_SHIP | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE )
+#define AI_GOAL_ACCEPT_BOMBER			( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FIGHTER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_STEALTH		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FIGHTER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_TRANSPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_CHASE_WING | AI_GOAL_DOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_UNDOCK | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_FREIGHTER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_TRANSPORT | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_CRUISER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FREIGHTER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_CORVETTE		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_GAS_MINER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_AWACS			( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_CAPITAL		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER & ~(AI_GOAL_DOCK | AI_GOAL_UNDOCK) | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_SUPERCAP		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CAPITAL | AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_SUPPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_DOCK | AI_GOAL_UNDOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT )
+#define AI_GOAL_ACCEPT_ESCAPEPOD		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_TRANSPORT| AI_GOAL_STAY_NEAR_SHIP  )
+*/

-inline ai_goal_mode int_to_ai_goal_mode(int int_mode)
-{
-	if (int_mode >= 0 && int_mode < AI_GOAL_NUM_VALUES)
-		return static_cast<ai_goal_mode>(int_mode);
-
-	Warning(LOCATION, "ai_goal_mode %d out of range!  Setting to AI_GOAL_NONE.", int_mode);
-	return AI_GOAL_NONE;
-}
-
-inline bool ai_goal_is_disable_or_disarm(ai_goal_mode ai_mode)
-{
-	return ai_mode == AI_GOAL_DISABLE_SHIP || ai_mode == AI_GOAL_DISABLE_SHIP_TACTICAL || ai_mode == AI_GOAL_DISARM_SHIP || ai_mode == AI_GOAL_DISARM_SHIP_TACTICAL;
-}
-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;
-}
+#define MAX_AI_DOCK_NAMES				25

 enum class ai_achievability { ACHIEVABLE, NOT_ACHIEVABLE, NOT_KNOWN, SATISFIED };

-struct ai_lua_parameters {
-	object_ship_wing_point_team target;
-	luacpp::LuaValueList arguments;
-};
-
-// structure for AI goals
-typedef struct ai_goal {
-	int	signature;			//	Unique identifier.  All goals ever created (per mission) have a unique signature.
-	ai_goal_mode ai_mode;	// one of the AI_GOAL_* modes for this goal
-	int	ai_submode;			// maybe need a submode
-	ai_goal_type type;		// one of the ai_goal_type (originally AIG_TYPE_*) values above
-	flagset<AI::Goal_Flags>	flags;				// one of the AIGF_* values above
-	fix	time;					// time at which this goal was issued.
-	int	priority;			// how important is this goal -- number 0 - 100
-
-	const char *target_name;	// name of the thing that this goal acts upon
-	int		target_name_index;	// index of goal_target_name in Goal_target_names[][]
-	int wp_list_index;			// waypoints that this ship might fly.
-	int target_instance;		// instance of thing this ship might be chasing (currently only used for weapons; note, not the same as objnum!)
-	int	target_signature;		// signature of object this ship might be chasing (currently only used for weapons; paired with above value to confirm target)
-
-	// extra goal-specific data
-	int int_data;
-	float float_data;
-
-	// unions for docking stuff.
-	// (AIGF_DOCKER_INDEX_VALID and AIGF_DOCKEE_INDEX_VALID tell us to use indexes; otherwise we use names)
-	// these are the dockpoints used on the docker and dockee ships, not the ships themselves
-	union {
-		const char *name;
-		int	index;
-	} docker;
-	
-	union {
-		const char *name;
-		int	index;
-	} dockee;
-
-	ai_lua_parameters lua_ai_target;
-
-} 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);
-
-
-typedef flag_def_list_templated<ai_goal_mode> ai_goal_list;
+typedef flag_def_list ai_goal_list;

 extern ai_goal_list Ai_goal_names[];
 extern int Num_ai_goals;

-#define MAX_AI_DOCK_NAMES				25
-
 extern int Num_ai_dock_names;
 extern char Ai_dock_names[MAX_AI_DOCK_NAMES][NAME_LENGTH];

-extern const char *Ai_goal_text(ai_goal_mode goal, int submode);
-
-// every goal in a mission gets a unique signature
-extern int Ai_goal_signature;
+extern const char *Ai_goal_text(int goal, int submode);

 // extern function definitions
 extern void ai_post_process_mission();
@@ -176,17 +104,17 @@ 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);
-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);
+extern void ai_add_ship_goal_scripting(int mode, int submode, int priority, char *shipname, ai_info *aip);
+extern void ai_add_ship_goal_sexp( int sexp, int type, ai_info *aip );
+extern void ai_add_wing_goal_sexp( int sexp, int type, wing *wingp );
+extern void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp, char *actor_name);

-extern int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp, bool &remove_more );
+extern int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp );
 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, 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_add_ship_goal_player( int type, int mode, int submode, char *shipname, ai_info *aip, const object_ship_wing_point_team& lua_target = object_ship_wing_point_team());
+extern void ai_add_wing_goal_player( int type, int mode, int submode, char *shipname, int wingnum, const object_ship_wing_point_team& lua_target = object_ship_wing_point_team());

 extern void ai_remove_ship_goal( ai_info *aip, int index );
 extern void ai_clear_ship_goals( ai_info *aip );
@@ -197,11 +125,11 @@ extern void ai_copy_mission_wing_goal( ai_goal *aigp, ai_info *aip );
 extern void ai_mission_goal_complete( ai_info *aip );
 extern void ai_mission_wing_goal_complete( int wingnum, ai_goal *remove_goalp );

-extern void ai_update_goal_references(ai_goal *goals, sexp_ref_type type, const char *old_name, const char *new_name);
-extern bool query_referenced_in_ai_goals(ai_goal *goals, sexp_ref_type type, const char *name);
+extern void ai_update_goal_references(ai_goal *goals, int type, const char *old_name, const char *new_name);
+extern int query_referenced_in_ai_goals(ai_goal *goals, int type, const char *name);
 extern char *ai_add_dock_name(const char *str);

-extern int ai_query_goal_valid( int ship, ai_goal_mode ai_mode );
+extern int ai_query_goal_valid( int ship, int ai_goal_type );

 extern void ai_add_goal_ship_internal( ai_info *aip, int goal_type, char *name, int docker_point, int dockee_point, int immediate = 1 );

@@ -14,24 +14,24 @@
 #include "weapon/weapon.h"

 //Returns true if the specified object is a stealth ship, false if not
-bool is_object_stealth_ship(const object* objp);
+bool is_object_stealth_ship(object* objp);

 //Number of live turrets on the object attacking
-int num_turrets_attacking(const object *turret_parent, int target_objnum);
+int num_turrets_attacking(object *turret_parent, int target_objnum);

 //Determine whether an object is targetable within a nebula (checks for stealth)
-bool object_is_targetable(const object *target, const ship *viewer);
+int object_is_targetable(object *target, ship *viewer);

 //Returns the number of enemy fighters within threshold of pos.
-int num_nearby_fighters(int enemy_team_mask, const vec3d *pos, float threshold);
+int num_nearby_fighters(int enemy_team_mask, vec3d *pos, float threshold);

 //Returns true if OK for *aip to fire its current weapon at its current target.
-bool check_ok_to_fire(int objnum, int target_objnum, const weapon_info *wip, int secondary_bank, const vec3d *firing_pos_global);
+int check_ok_to_fire(int objnum, int target_objnum, weapon_info *wip, int secondary_bank, ship_subsys* turret);

 //Returns true if *aip has a line of sight to its current target.
-bool check_los(int objnum, int target_objnum, float threshold, int primary_bank, int secondary_bank, const vec3d *firing_pos_global);
+bool check_los(int objnum, int target_objnum, float threshold, int primary_bank, int secondary_bank, ship_subsys* turret);

 //Does all the stuff needed to aim and fire a turret.
-void ai_turret_execute_behavior(const ship *shipp, ship_subsys *ss);
+void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss);

 #endif
@@ -18,9 +18,9 @@ void ai_lua_add_mode(int sexp_op, const ai_mode_lua& mode) {
 }

 bool ai_lua_add_order(int sexp_op, player_order_lua order) {
-	Player_orders.emplace_back(order.parseText, order.displayText, -1, sexp_op);
+	Player_orders.emplace_back(vm_strdup(order.parseText.c_str()), vm_strdup(order.displayText.c_str()), -1, sexp_op);
 	Player_orders.back().localize();
-	
+
 	Lua_player_orders.emplace(sexp_op, std::move(order));

 	return true;
@@ -48,140 +48,6 @@ const player_order_lua* ai_lua_find_player_order(int sexp_op) {
 		return &aiLuaOrder->second;
 }

-int ai_lua_get_num_general_orders() {
-	int count = 0;
-	
-	for (const auto& order : Lua_player_orders) {
-		if (order.second.generalOrder) {
-			count++;
-		}
-	}
-
-	return count;
-}
-
-SCP_vector<SCP_string> ai_lua_get_general_order_categories(bool enabled_only)
-{
-	SCP_vector<SCP_string> list;
-
-	for (const auto& order : Lua_player_orders) {
-		const SCP_string &cat = order.second.category;
-
-		// If it's not a general order then move on
-		if (!order.second.generalOrder) {
-			continue;
-		}
-
-		// If the order is not enabled then move on
-		if (enabled_only && !order.second.cur_enabled) {
-			continue;
-		}
-
-		Assertion((cat.length() > 0), "Lua general orders category name must be longer than 0 characters!");
-
-		for (size_t i = 0; i <= list.size(); i++) {
-
-			// reached the end of the list, so add it
-			if (i == list.size()) {
-				list.push_back(cat);
-				break;
-			}
-
-			// if it's already in the list then don't add it
-			if (cat == list[i]) {
-				break;
-			}
-		}
-	}
-
-	return list;
-}
-
-// Provides a list of general orders for mission saving. You can only get one kind
-// of list at a time. If onlyEnabled and onlyValid are both true, for example, you will get
-// a list of onlyEnabled orders. If you need a list of enabled orders that are also valid, you'll
-// need to get both lists separately and compare.
-SCP_vector<SCP_string> ai_lua_get_general_orders(bool onlyEnabled, bool onlyValid, const SCP_string& category)
-{
-	SCP_vector<SCP_string> list;
-
-	for (const auto& order : Lua_player_orders) {
-		if (order.second.generalOrder) {
-			bool add = false;
-
-			// All general orders
-			if (!onlyEnabled && !onlyValid && category.empty()) {
-				add = true;
-			} else {
-
-				// Only enabled orders
-				if (onlyEnabled && order.second.cur_enabled) {
-					add = true;
-
-					// Only valid orders
-				} else if (onlyValid && order.second.cur_valid) {
-					add = true;
-
-					// Only orders that match the category requested
-				} else if ((!category.empty()) && (order.second.category == category)) {
-					add = true;
-				}
-			}
-
-			if (add) {
-				list.push_back(order.second.parseText);
-			}
-		}
-	}
-
-	return list;
-}
-
-int ai_lua_find_general_order_id(const SCP_string& name) {
-	for (const auto& order : Lua_player_orders) {
-		if (order.second.parseText == name) {
-			return order.first;
-		}
-	}
-
-	return -1;
-}
-
-void ai_lua_enable_general_order(int sexp_op, bool enable) {
-	auto aiLuaOrder = Lua_player_orders.find(sexp_op);
-
-	if (aiLuaOrder == Lua_player_orders.end())
-		return;
-	else
-		aiLuaOrder->second.cur_enabled = enable;
-}
-
-void ai_lua_validate_general_order(int sexp_op, bool validity)
-{
-	auto aiLuaOrder = Lua_player_orders.find(sexp_op);
-
-	if (aiLuaOrder == Lua_player_orders.end())
-		return;
-	else
-		aiLuaOrder->second.cur_valid = validity;
-}
-
-void ai_lua_reset_general_orders() {
-	for (const auto& order : Lua_player_orders) {
-		ai_lua_enable_general_order(order.first, false);
-		ai_lua_validate_general_order(order.first, false);
-	}
-}
-
-bool ai_lua_is_general_order(int sexp_op) {
-	auto aiLuaOrder = Lua_player_orders.find(sexp_op);
-
-	if (aiLuaOrder == Lua_player_orders.end())
-		return false;
-
-	return aiLuaOrder->second.generalOrder;
-}
-
 void run_ai_lua_action(const luacpp::LuaFunction& action, const ai_mode_lua& lua_ai, ai_info* aip) {
 	if (!action.isValid()) {
 		Error(LOCATION,
@@ -190,28 +56,16 @@ void run_ai_lua_action(const luacpp::LuaFunction& action, const ai_mode_lua& lua
 	}

 	luacpp::LuaValueList luaParameters;
-	if (aip->shipnum >= 0){
-		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_AI_Helper.Set(object_h(&Objects[Ships[aip->shipnum].objnum]))));
-	} else {
-		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_AI_Helper.Set(object_h())));
-	}
+	luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_AI_Helper.Set(object_h(&Objects[Ships[aip->shipnum].objnum]))));
 	if (lua_ai.needsTarget) {
-		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(aip->lua_ai_target.target)));
-	}
-	for (const auto& additionalParam : aip->lua_ai_target.arguments) {
-		luaParameters.push_back(additionalParam);
+		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(aip->lua_ai_target)));
 	}

 	auto retVals = action.call(Script_system.GetLuaSession(), luaParameters);

 	if (!retVals.empty() && retVals[0].getValueType() == luacpp::ValueType::BOOLEAN) {
-		if (retVals[0].getValue<bool>()) {
-
-			// If we don't have a ship then it's a general order and we have nothing else to do
-			if (aip->shipnum >= 0) {
-				ai_mission_goal_complete(aip);
-			}
-		}
+		if (retVals[0].getValue<bool>())
+			ai_mission_goal_complete(aip);
 	}
 }

@@ -220,10 +74,14 @@ void ai_lua(ai_info* aip){

 	const auto& lua_ai = Lua_ai_modes.at(aip->submode);
 	
-	const auto& lua_ai_sexp = lua_ai.sexp;
-	const auto& action = lua_ai_sexp.getAction();
+	auto dynamicSEXP = sexp::get_dynamic_sexp(aip->submode);

-	run_ai_lua_action(action, lua_ai, aip);
+	if (dynamicSEXP != nullptr && typeid(*dynamicSEXP) == typeid(sexp::LuaAISEXP)) {
+		auto lua_ai_sexp = static_cast<sexp::LuaAISEXP*>(dynamicSEXP);
+		const auto& action = lua_ai_sexp->getActionFrame();
+
+		run_ai_lua_action(action, lua_ai, aip);
+	}
 }

 void ai_lua_start(ai_goal* aigp, object* objp){
@@ -240,30 +98,15 @@ void ai_lua_start(ai_goal* aigp, object* objp){
 	
 	const auto& lua_ai = Lua_ai_modes.at(aigp->ai_submode);

-	const auto& lua_ai_sexp = lua_ai.sexp;
-	const auto& action = lua_ai_sexp.getActionEnter();
+	auto dynamicSEXP = sexp::get_dynamic_sexp(aigp->ai_submode);

-	run_ai_lua_action(action, lua_ai, aip);
-}
+	if (dynamicSEXP != nullptr && typeid(*dynamicSEXP) == typeid(sexp::LuaAISEXP)) {
+		auto lua_ai_sexp = static_cast<sexp::LuaAISEXP*>(dynamicSEXP);
+		const auto& action = lua_ai_sexp->getActionEnter();

-// For sending general orders that don't run on a ship.
-// Essentially just runs arbitrary lua script when the command is called
-void ai_lua_start_general(int lua_sexp_id, int target_objnum)
-{
-	//Create a dummy aip to pass the target data
-	ai_info aip;
-	aip.shipnum = -1;
-
-	if (target_objnum >= 0 && Objects[target_objnum].type == OBJ_SHIP) {
-		aip.lua_ai_target = {object_ship_wing_point_team(&Ships[Objects[target_objnum].instance]), {}};
+		run_ai_lua_action(action, lua_ai, aip);
 	}
 	
-	const auto& lua_ai = ai_lua_find_mode(lua_sexp_id);
-
-	const auto& lua_ai_sexp = lua_ai->sexp;
-	const auto& action = lua_ai_sexp.getActionEnter();
-
-	run_ai_lua_action(action, *lua_ai, &aip);
 }

 bool ai_lua_is_valid_target_intrinsic(int sexp_op, int target_objnum, ship* self) {
@@ -296,32 +139,36 @@ bool ai_lua_is_valid_target_intrinsic(int sexp_op, int target_objnum, ship* self
 	return false;
 }

-bool ai_lua_is_valid_target_lua(const ai_mode_lua& mode, int target_objnum, ship* self) {
+bool ai_lua_is_valid_target_lua(const ai_mode_lua& mode, int sexp_op, int target_objnum, ship* self) {
+	auto dynamicSEXP = sexp::get_dynamic_sexp(sexp_op);

-	const auto& action = mode.sexp.getTargetRestrict();
+	if (dynamicSEXP != nullptr && typeid(*dynamicSEXP) == typeid(sexp::LuaAISEXP)) {
+		auto lua_ai_sexp = static_cast<sexp::LuaAISEXP*>(dynamicSEXP);
+		const auto& action = lua_ai_sexp->getTargetRestrict();

-	if (!action.isValid())
-		return true;
+		if (!action.isValid())
+			return true;

-	luacpp::LuaValueList luaParameters;
-	luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_Ship.Set(object_h(&Objects[self->objnum]))));
-	if (mode.needsTarget) {
-		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(object_ship_wing_point_team(&Ships[Objects[target_objnum].instance]))));
-	}
+		luacpp::LuaValueList luaParameters;
+		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_Ship.Set(object_h(&Objects[self->objnum]))));
+		if (mode.needsTarget) {
+			luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(object_ship_wing_point_team(&Ships[Objects[target_objnum].instance]))));
+		}

-	auto retVals = action.call(Script_system.GetLuaSession(), luaParameters);
+		auto retVals = action.call(Script_system.GetLuaSession(), luaParameters);

-	if (!retVals.empty() && retVals[0].getValueType() == luacpp::ValueType::BOOLEAN) {
-		return retVals[0].getValue<bool>();
-	}
-	else {
-		Error(LOCATION, "LuaAI target restriction function did not return a valid boolean!");
+		if (!retVals.empty() && retVals[0].getValueType() == luacpp::ValueType::BOOLEAN) {
+			return retVals[0].getValue<bool>();
+		}
+		else {
+			Error(LOCATION, "LuaAI target restriction function did not return a valid boolean!");
+		}
 	}

 	return true;
 }

-bool ai_lua_is_valid_target(int sexp_op, int target_objnum, ship* self, size_t order) {
+bool ai_lua_is_valid_target(int sexp_op, int target_objnum, ship* self) {
 	const ai_mode_lua& mode = *ai_lua_find_mode(sexp_op);

 	//All targetless AI modes are fine
@@ -337,77 +184,55 @@ bool ai_lua_is_valid_target(int sexp_op, int target_objnum, ship* self, size_t o

 		if (!ai_lua_is_valid_target_intrinsic(sexp_op, target_objnum, self))
 			return false;
-
-		// check if this order can be issued against the target
-		ship *shipp = &Ships[Objects[target_objnum].instance];
-		if (shipp->orders_allowed_against.find(order) == shipp->orders_allowed_against.end()) {
-			return false;
-		}
 	}

 	//If we haven't bailed yet, query the custom callback
-	return ai_lua_is_valid_target_lua(mode, target_objnum, self);
-}
-
-bool ai_lua_is_valid_ship(int sexp_op, bool isWing, ship* self)
-{
-	const player_order_lua& order = *ai_lua_find_player_order(sexp_op);
-
-	switch (order.shipRestrictions) {
-	case player_order_lua::ship_restrictions::ANY:
-		return true;
-	case player_order_lua::ship_restrictions::WING:
-		return isWing;
-	case player_order_lua::ship_restrictions::IN_PLAYER_WING:
-		return self->wingnum != -1 && Ships[Player_obj->instance].wingnum == self->wingnum;
-	case player_order_lua::ship_restrictions::PLAYER_WING:
-		return isWing && self->wingnum != -1 && Ships[Player_obj->instance].wingnum == self->wingnum;
-	}
-
-	return false;
+	return ai_lua_is_valid_target_lua(mode, sexp_op, target_objnum, self);
 }

 ai_achievability ai_lua_is_achievable(const ai_goal* aigp, int objnum){
 	const auto& lua_ai = Lua_ai_modes.at(aigp->ai_submode);

-	const auto& action = lua_ai.sexp.getAchievable();
+	auto dynamicSEXP = sexp::get_dynamic_sexp(aigp->ai_submode);

-	if (!action.isValid())
-		return ai_achievability::ACHIEVABLE;
+	if (dynamicSEXP != nullptr && typeid(*dynamicSEXP) == typeid(sexp::LuaAISEXP)) {
+		auto lua_ai_sexp = static_cast<sexp::LuaAISEXP*>(dynamicSEXP);
+		const auto& action = lua_ai_sexp->getAchievable();

-	luacpp::LuaValueList luaParameters;
-	luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_Ship.Set(object_h(&Objects[objnum]))));
-	if (lua_ai.needsTarget) {
-		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(aigp->lua_ai_target.target)));
-	}
-	for (const auto& additionalParam : aigp->lua_ai_target.arguments) {
-		luaParameters.push_back(additionalParam);
-	}
-
-	auto retVals = action.call(Script_system.GetLuaSession(), luaParameters);
-
-	if (!retVals.empty() && retVals[0].getValueType() == luacpp::ValueType::USERDATA) {
-		scripting::api::enum_h enumData;
-		retVals[0].getValue(scripting::api::l_Enum.Get(&enumData));
-		if (!enumData.isValid()) {
-			Error(LOCATION, "LuaAI SEXP achievability hook returned an invalid avilability enum.");
+		if (!action.isValid())
 			return ai_achievability::ACHIEVABLE;
+
+		luacpp::LuaValueList luaParameters;
+		luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_Ship.Set(object_h(&Objects[objnum]))));
+		if (lua_ai.needsTarget) {
+			luaParameters.push_back(luacpp::LuaValue::createValue(action.getLuaState(), scripting::api::l_OSWPT.Set(aigp->lua_ai_target)));
 		}

-		switch (enumData.index) {
-		case scripting::api::LE_LUAAI_ACHIEVABLE:
-			return ai_achievability::ACHIEVABLE;
-		case scripting::api::LE_LUAAI_NOT_YET_ACHIEVABLE:
-			return ai_achievability::NOT_KNOWN;
-		case scripting::api::LE_LUAAI_UNACHIEVABLE:
-			return ai_achievability::NOT_ACHIEVABLE;
-		default:
-			Error(LOCATION, "LuaAI SEXP achievability hook returned an invalid avilability enum.");
-			return ai_achievability::ACHIEVABLE;
+		auto retVals = action.call(Script_system.GetLuaSession(), luaParameters);
+
+		if (!retVals.empty() && retVals[0].getValueType() == luacpp::ValueType::USERDATA) {
+			scripting::api::enum_h enumData;
+			retVals[0].getValue(scripting::api::l_Enum.Get(&enumData));
+			if (!enumData.IsValid()) {
+				Error(LOCATION, "LuaAI SEXP achievability hook returned an invalid avilability enum.");
+				return ai_achievability::ACHIEVABLE;
+			}
+
+			switch (enumData.index) {
+			case scripting::api::LE_LUAAI_ACHIEVABLE:
+				return ai_achievability::ACHIEVABLE;
+			case scripting::api::LE_LUAAI_NOT_YET_ACHIEVABLE:
+				return ai_achievability::NOT_KNOWN;
+			case scripting::api::LE_LUAAI_UNACHIEVABLE:
+				return ai_achievability::NOT_ACHIEVABLE;
+			default:
+				Error(LOCATION, "LuaAI SEXP achievability hook returned an invalid avilability enum.");
+				return ai_achievability::ACHIEVABLE;
+			}
+		}
+		else {
+			Error(LOCATION, "LuaAI SEXP achievability hook did not return any avilability enum!");
 		}
-	}
-	else {
-		Error(LOCATION, "LuaAI SEXP achievability hook did not return any avilability enum!");
 	}

 	return ai_achievability::ACHIEVABLE;
@@ -4,13 +4,9 @@
 #include "ai/aigoals.h"
 #include "mission/missionmessage.h"
 #include "ship/ship.h"
-#include "parse/sexp.h"
 #include "globalincs/globals.h"

-namespace sexp { class LuaAISEXP; }
-
 struct ai_mode_lua {
-	const sexp::LuaAISEXP& sexp;
 	bool needsTarget;
 	const char* hudText;
 };
@@ -19,31 +15,15 @@ struct player_order_lua {
 	int ai_message = MESSAGE_YESSIR;
 	SCP_string parseText = "";
 	SCP_string displayText = "";
-	bool generalOrder = false;
-	SCP_string category = "";
-	bool cur_enabled = false;
-	bool cur_valid = false;
 	enum class target_restrictions : int { TARGET_ALLIES, TARGET_ALL, TARGET_OWN, TARGET_ENEMIES, TARGET_SAME_WING, TARGET_PLAYER_WING, TARGET_ALL_CAPS, TARGET_ALLIED_CAPS, TARGET_ENEMY_CAPS, TARGET_NOT_SELF } targetRestrictions = target_restrictions::TARGET_ALL;
-	enum class ship_restrictions : int { ANY, WING, IN_PLAYER_WING, PLAYER_WING } shipRestrictions = ship_restrictions::ANY;
 };

-
 void ai_lua_add_mode(int sexp_op, const ai_mode_lua& mode);
 bool ai_lua_add_order(int sexp_op, player_order_lua order);
 bool ai_lua_has_mode(int sexp_op);
 const ai_mode_lua* ai_lua_find_mode(int sexp_op);
 const player_order_lua* ai_lua_find_player_order(int sexp_op);
-SCP_vector<SCP_string> ai_lua_get_general_order_categories(bool enabled_only = true);
-int ai_lua_get_num_general_orders();
-SCP_vector<SCP_string> ai_lua_get_general_orders(bool onlyEnabled = false, bool onlyValid = false, const SCP_string& category = "");
-int ai_lua_find_general_order_id(const SCP_string& name);
-void ai_lua_enable_general_order(int sexp_op, bool enable);
-void ai_lua_validate_general_order(int sexp_op, bool validity);
-void ai_lua_reset_general_orders();
-bool ai_lua_is_general_order(int sexp_op);
 void ai_lua(ai_info* aip);
 void ai_lua_start(ai_goal* aigp, object* objp);
-void ai_lua_start_general(int lua_sexp_id, int target_objnum);
-bool ai_lua_is_valid_target(int sexp_op, int target_objnum, ship* self, size_t order);
-bool ai_lua_is_valid_ship(int sexp_op, bool isWing, ship* self);
+bool ai_lua_is_valid_target(int sexp_op, int target_objnum, ship* self);
 ai_achievability ai_lua_is_achievable(const ai_goal* aigp, int objnum);
@@ -397,6 +397,8 @@ int anim_show_next_frame(anim_instance *instance, float frametime)

 		t1 = timer_get_fixed_seconds();
 		for ( i = 0; i < frame_diff; i++ ) {
+			anim_check_for_palette_change(instance);			
+
 			// if we're playing backwards, every frame must be a keyframe and we set the data ptr here
 			if(instance->direction == ANIM_DIRECT_REVERSE){
 				if ( anim_instance_is_streamed(instance) ) {
@@ -641,7 +643,7 @@ void anim_read_header(anim *ptr, CFILE *fp)

 	if (diff != 0) {
 		if (ptr->height > 16) {
-			nprintf(("ANI","ANI %s with size %dx%d (%.1f%% wasted)\n", ptr->name, ptr->width, ptr->height, waste));
+			mprintf(("ANI %s with size %dx%d (%.1f%% wasted)\n", ptr->name, ptr->width, ptr->height, waste));
 		}
 	}
 #endif
@@ -667,10 +669,12 @@ void anim_read_header(anim *ptr, CFILE *fp)
 * 
 * @param real_filename Filename of animation
 * @param cf_dir_type 
- *
- * @return Pointer to anim that is loaded if success, NULL if failure.
+ * @param file_mapped Whether to use memory-mapped file or not.
+ * 
+ * @details Memory-mapped files will page in the animation from disk as it is needed, but performance is not as good.
+ * @return Pointer to anim that is loaded if sucess, NULL if failure.
 */
-anim *anim_load(const char *real_filename, int cf_dir_type)
+anim *anim_load(const char *real_filename, int cf_dir_type, int file_mapped)
 {
 	anim			*ptr;
 	CFILE			*fp;
@@ -695,7 +699,7 @@ anim *anim_load(const char *real_filename, int cf_dir_type)
 	}

 	if (!ptr) {
-		fp = cfopen(name, "rb", cf_dir_type);
+		fp = cfopen(name, "rb", CFILE_NORMAL, cf_dir_type);
 		if ( !fp )
 			return NULL;

@@ -741,9 +745,18 @@ anim *anim_load(const char *real_filename, int cf_dir_type)

 		ptr->cfile_ptr = NULL;

-		// NOTE: mapped files no longer supported!!
-		ptr->flags |= ANF_STREAMED;
-		ptr->cfile_ptr = cfopen(name, "rb", cf_dir_type);
+		if ( file_mapped == PAGE_FROM_MEM) {
+			// Try mapping the file to memory 
+			ptr->flags |= ANF_MEM_MAPPED;
+			ptr->cfile_ptr = cfopen(name, "rb", CFILE_MEMORY_MAPPED, cf_dir_type);
+		}
+
+		// couldn't memory-map file... must be in a packfile, so stream manually
+		if ( file_mapped == PAGE_FROM_MEM && !ptr->cfile_ptr ) {
+			ptr->flags &= ~ANF_MEM_MAPPED;
+			ptr->flags |= ANF_STREAMED;
+			ptr->cfile_ptr = cfopen(name, "rb", CFILE_NORMAL, cf_dir_type);
+		}

 		ptr->cache = NULL;

@@ -777,6 +790,9 @@ anim *anim_load(const char *real_filename, int cf_dir_type)

 		cfclose(fp);

+		// store screen signature, so we can tell if palette changes
+		ptr->screen_sig = gr_screen.signature;
+
 		anim_set_palette(ptr);
 	}

@@ -38,6 +38,12 @@ typedef struct {
 	int ping_pong;
 } anim_play_struct;

+enum
+{
+	PAGE_FROM_DISK		  = 0,
+	PAGE_FROM_MEM		  = 1
+};
+
 extern int Anim_paused;

 void				anim_init();
@@ -51,7 +57,7 @@ void				anim_ignore_next_frametime();
 int				anim_show_next_frame(anim_instance *instance, float frametime);
 void				anim_release_all_instances(int screen_id = 0);
 void				anim_release_render_instance(anim_instance* instance);
-anim			  *anim_load(const char *name, int cf_dir_type = CF_TYPE_ANY);
+anim			  *anim_load(const char *name, int cf_dir_type = CF_TYPE_ANY, int file_mapped = PAGE_FROM_DISK);
 int				anim_free(anim *ptr);
 void				anim_read_header(anim *ptr, CFILE *fp);
 void				anim_reverse_direction(anim_instance *ai);						// called automatically for ping-ponging, and can also be called externally
@@ -18,23 +18,30 @@
 const int packer_code = PACKER_CODE;
 const int transparent_code = 254;

+void anim_check_for_palette_change(anim_instance *instance) {
+	if ( instance->parent->screen_sig != gr_screen.signature ) {
+		instance->parent->screen_sig = gr_screen.signature;
+		anim_set_palette(instance->parent);
+	}
+}
+
 anim_instance *init_anim_instance(anim *ptr, int bpp)
 {
 	anim_instance *inst;

-	Assertion(ptr, "Bad pointer in init_anim_instance(), please report to the SCP!");
 	if (!ptr) {
+		Int3();
 		return NULL;
 	}

 	if ( ptr->flags & ANF_STREAMED ) {
-		Assertion(ptr->file_offset > -1, "Bad file offset of %d in init_anim_instance(), please report to the SCP!", ptr->file_offset);
 		if ( ptr->file_offset < 0 ) {
+			Int3();
 			return NULL;
 		}
 	} else {
-		Assertion(ptr->data, "Bad data in init_anim_instance(), please report to the SCP!");
 		if ( !ptr->data ) {
+			Int3();
 			return NULL;
 		}
 	}
@@ -90,6 +97,8 @@ ubyte *anim_get_next_raw_buffer(anim_instance *inst, int xlate_pal, int aabitmap
 		return NULL;
 	}

+	anim_check_for_palette_change(inst);
+
 	if ( anim_instance_is_streamed(inst) ) {
 		if ( xlate_pal ){
 			inst->file_offset = unpack_frame_from_file(inst, inst->frame, inst->parent->width*inst->parent->height, inst->parent->palette_translation, aabitmap, bpp);
@@ -58,6 +58,7 @@ typedef struct anim {
 	ubyte			xparent_g;		// green component for the transparent color in source image
 	ubyte			xparent_b;		// blue component for the transparent color in source image
 	int			flags;
+	uint			screen_sig;	
 	int			file_offset;	// file offset to start of frame data
 	int			cache_file_offset;
 	ubyte			*cache;
@@ -104,6 +105,7 @@ anim_instance *init_anim_instance(anim *ptr, int bpp);
 void	free_anim_instance(anim_instance *inst);
 ubyte *anim_get_next_raw_buffer(anim_instance *inst, int xlate_pal, int aabitmap, int bpp);
 void	anim_set_palette(anim *a);
+void	anim_check_for_palette_change(anim_instance *inst);


 #endif  /* __PACKUNPACK_H__ */
@@ -14,29 +14,34 @@

 #include "globalincs/globals.h"		// for NAME_LENGTH
 #include "globalincs/pstypes.h"
-#include "object/object_flags.h"
-#include "io/timer.h"
+

 class object;
 class polymodel;
 struct collision_info_struct;
 class model_draw_list;

-#define	MAX_ASTEROIDS			2000	//Increased from 512 to 2000 in 2022
+#define	MAX_ASTEROIDS			512

-#define	NUM_ASTEROID_SIZES		3
+#define NUM_DEBRIS_SIZES		3
+#define	NUM_DEBRIS_POFS			3				// Number of POFs per debris size

-#define	ASTEROID_TYPE_DEBRIS    -1
 #define	ASTEROID_TYPE_SMALL		0
 #define	ASTEROID_TYPE_MEDIUM	1
 #define	ASTEROID_TYPE_LARGE		2

-// Only used for parsing & saving retail compatible mission files
-#define	MAX_RETAIL_DEBRIS_TYPES		3
+// these should always be equal for the benefit of generic asteroids (c.f. asteroid_page_in)
+#define	MAX_ACTIVE_DEBRIS_TYPES		NUM_DEBRIS_SIZES

 // Goober5000 - currently same as MAX_SHIP_DETAIL_LEVELS (put here to avoid an #include)
 #define MAX_ASTEROID_DETAIL_LEVELS	5

+// whether to do retail behavior, just throw at the first big ship in the field
+// must be explicitly opted out of by the mission
+extern bool Default_asteroid_throwing_behavior;
+
+extern SCP_vector<SCP_string> Asteroid_target_ships;
+
 // Data structure to track the active asteroids
 typedef struct asteroid_obj {
 	asteroid_obj *next, *prev;
@@ -48,28 +53,19 @@ extern asteroid_obj Asteroid_obj_list;
 // Data structure for determining a type and amount of other asteroids an
 // asteroid will split to when destroyed.
 typedef struct asteroid_split_info {
-	int		asteroid_type;		//index position
-	char	name[NAME_LENGTH];	//asteroid name
-	int		min;				//minimum asteroids to spawn
-	int		max;				//maximum asteroids to spawn
+	int		asteroid_type;
+	int		min;
+	int		max;
 } asteroid_split_info;

-// Data structure for storing asteroid subtype info. POFs, model pointer, model num, etc.
-typedef struct asteroid_subtype_info {
-	char        pof_filename[MAX_FILENAME_LEN];
-	int         model_number;
-	SCP_string  type_name;
-} asteroid_subtype_info;
-
 class asteroid_info
 {
 public:
 	char		name[NAME_LENGTH];								// name for the asteroid
-	int			type;											// type of asteroid, 0 = small, 1 = medium, 2 = large, -1 = debris
-	int			num_detail_levels;								// number of detail levels for this asteroid
+	char		pof_files[NUM_DEBRIS_POFS][MAX_FILENAME_LEN];	// POF files to load/associate with ship
+	int			num_detail_levels;								// number of detail levels for this ship
 	int			detail_distance[MAX_ASTEROID_DETAIL_LEVELS];	// distance to change detail levels at
 	float		max_speed;										// cap on speed for asteroid
-	float		rotational_vel_multiplier;						// rotational velocity multiplier for asteroid --wookieejedi
 	int			damage_type_idx;								//Damage type of the asteroid
 	int			damage_type_idx_sav;							// stored value from table used to reset damage_type_idx
 	float		inner_rad;										// radius within which maximum area effect damage is applied
@@ -78,23 +74,28 @@ public:
 	float		blast;											// maximum blast impulse from area effect explosion
 	float		initial_asteroid_strength;						// starting strength of asteroid
 	SCP_vector< asteroid_split_info > split_info;
+	polymodel	*modelp[NUM_DEBRIS_POFS];
+	int			model_num[NUM_DEBRIS_POFS];
 	SCP_vector<int> explosion_bitmap_anims;
 	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
-	SCP_vector<asteroid_subtype_info> subtypes;
+	SCP_string	display_name;									// only used for hud targeting display and for 'ship' asteroids
+	float		spawn_weight;									// ship asteroids only, relative proportion to spawn compared to other types in its asteroid field

 	asteroid_info( )
-		: type(ASTEROID_TYPE_DEBRIS), num_detail_levels(0), max_speed(0), 
-		  rotational_vel_multiplier(1), damage_type_idx(0),
+		: num_detail_levels( 0 ), max_speed( 0 ), 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 ), spawn_weight( 1 ), gravity_const( 0 )
+		  fireball_radius_multiplier( -1 )
 	{
 		name[ 0 ] = 0;
-		display_name = "";
 		memset( detail_distance, 0, sizeof( detail_distance ) );
+
+		for (int i = 0; i < NUM_DEBRIS_POFS; i++)
+		{
+			modelp[i] = NULL;
+			model_num[i] = -1;
+			pof_files[i][0] = 0;
+		}
 	}
 };

@@ -103,14 +104,13 @@ public:

 typedef	struct asteroid {
 	int		flags;
-	flagset<Object::Raw_Pof_Flags> render_flags; // Render flags
 	int		objnum;
 	int		model_instance_num;
 	int		asteroid_type;		// 0..MAX_DEBRIS_TYPES
 	int		asteroid_subtype;	// Index in asteroid_info for modelnum and modelp
-	TIMESTAMP	check_for_wrap;		// timestamp to check for asteroid wrapping around field
-	TIMESTAMP	check_for_collide;	// timestamp to check for asteroid colliding with escort ships
-	TIMESTAMP	final_death_time;	// timestamp to swap in new models after explosion starts
+	int		check_for_wrap;		// timestamp to check for asteroid wrapping around field
+	int		check_for_collide;	// timestamp to check for asteroid colliding with escort ships
+	int		final_death_time;	// timestamp to swap in new models after explosion starts
 	int		collide_objnum;		// set to objnum that asteroid will be impacting soon
 	int		collide_objsig;		// object signature corresponding to collide_objnum
 	vec3d	death_hit_pos;		// hit pos that caused death
@@ -121,7 +121,7 @@ typedef	struct asteroid {
 // TYPEDEF FOR DEBRIS TYPE
 typedef enum {
 	DG_ASTEROID,
-	DG_DEBRIS
+	DG_SHIP
 } debris_genre_t;

 // TYPEDEF FOR FIELD TYPE
@@ -134,7 +134,7 @@ typedef	struct asteroid_field {
 	vec3d	min_bound;					// Minimum range of field.
 	vec3d	max_bound;					// Maximum range of field.
 	float	bound_rad;
-	bool	has_inner_bound;
+	int		has_inner_bound;
 	vec3d	inner_min_bound;
 	vec3d	inner_max_bound;
 	vec3d	vel;						// Average asteroid moves at this velocity.
@@ -142,11 +142,8 @@ typedef	struct asteroid_field {
 	int		num_initial_asteroids;		// Number of asteroids at creation.
 	field_type_t		field_type;		// active throws and wraps, passive does not
 	debris_genre_t	debris_genre;		// type of debris (ship or asteroid)  [generic type]
-	SCP_vector<int>	field_debris_type;	// one of the debris type defines above
-	SCP_vector<SCP_string> field_asteroid_type; // one of the asteroid subtypes
-	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
+	int				field_debris_type[MAX_ACTIVE_DEBRIS_TYPES];	// one of the debris type defines above
+	int				num_used_field_debris_types;	// how many of the above are used
 } asteroid_field;

 extern SCP_vector< asteroid_info > Asteroid_info;
@@ -160,32 +157,21 @@ extern vec3d	Asteroid_icon_closeup_position;  // closeup position for asteroid f
 extern float	Asteroid_icon_closeup_zoom;		 // zoom position for asteroid field briefing icon rendering

 void	asteroid_init();
-bool    asteroid_is_within_view(vec3d *pos, float range, bool range_override = false);
 void	asteroid_level_init();
 void	asteroid_level_close();
 void	asteroid_create_all();
-void	asteroid_create_asteroid_field(int num_asteroids, int field_type, int asteroid_speed, vec3d o_min, vec3d o_max, bool inner_box, vec3d i_min, vec3d i_max, SCP_vector<SCP_string> asteroid_types);
-void	asteroid_create_debris_field(int num_asteroids, int asteroid_speed, SCP_vector<int> debris_types, vec3d o_min, vec3d o_max, bool enhanced);
-void	asteroid_render(object* obj, model_draw_list* scene);
+void	asteroid_render(object * obj, model_draw_list *scene);
 void	asteroid_delete( object *asteroid_objp );
 void	asteroid_process_pre( object *asteroid_objp );
 void	asteroid_process_post( object *asteroid_objp);
 int	asteroid_check_collision( object *asteroid_objp, object * other_obj, vec3d * hitpos, collision_info_struct *asteroid_hit_info=NULL, vec3d* hitnormal=NULL );
-void	asteroid_hit( object *pasteroid_objp, object *other_objp, vec3d *hitpos, float damage, vec3d* force );
+void	asteroid_hit( object *pasteroid_objp, object *other_objp, vec3d *hitpos, float damage );
 int	asteroid_count();
 int	asteroid_collide_objnum(object *asteroid_objp);
 float asteroid_time_to_impact(object *asteroid_objp);
 void	asteroid_show_brackets();
 void	asteroid_target_closest_danger();
 void asteroid_add_target(object* objp);
-int get_asteroid_index(const char* asteroid_name);
-SCP_vector<SCP_string> get_list_valid_asteroid_subtypes();
-
-// extern for the lab
-void asteroid_load(int asteroid_info_index, int asteroid_subtype);
-
-// need to extern for keycontrol debug commands
-object *asteroid_create(asteroid_field *asfieldp, int asteroid_type, int asteroid_subtype, bool check_visibility = false);

 // need to extern for multiplayer
 void asteroid_sub_create(object *parent_objp, int asteroid_type, vec3d *relvec);
@@ -30,7 +30,7 @@
 #include <map>

 // Extern functions/variables
-extern bool Player_use_ai;
+extern int		Player_use_ai;
 extern int get_wing_index(object *objp, int wingnum);
 extern object * get_wing_leader(int wingnum);
 extern int Cmdline_autopilot_interruptable;
@@ -47,9 +47,10 @@ NavMessage NavMsgs[NP_NUM_MESSAGES];
 int audio_handle;
 int NavLinkDistance;
 // time offsets for autonav events
-TIMESTAMP LockAPConv;
-TIMESTAMP EndAPCinematic;
-TIMESTAMP MoveCamera;
+int LockAPConv;
+int EndAPCinematic;
+int MoveCamera;
+int camMovingTime;
 //float CameraSpeed;
 bool CinematicStarted, CameraMoving;
 vec3d cameraPos, cameraTarget;
@@ -66,7 +67,7 @@ int start_dist;
 void autopilot_ai_waypoint_goal_fixup(ai_goal* aigp)
 {
 	// this function sets wp_index properly;
-	aigp->wp_list_index = find_matching_waypoint_list_index(aigp->target_name);
+	aigp->wp_list = find_matching_waypoint_list(aigp->target_name);
 }


@@ -111,15 +112,13 @@ const vec3d *NavPoint::GetPosition()
 {
 	if (flags & NP_WAYPOINT)
 	{
-		auto wpt = find_waypoint_at_indexes(target_index, waypoint_num-1);
-		Assert(wpt != nullptr);
-		if (wpt == nullptr)
-			return &vmd_zero_vector;
+		waypoint *wpt = find_waypoint_at_index((waypoint_list*) target_obj, waypoint_num-1);
+		Assert(wpt != NULL);
 		return wpt->get_pos();
 	}
 	else
 	{
-		return &Objects[target_index].pos;
+		return &Objects[((ship*) target_obj)->objnum].pos;
 	}
 }

@@ -152,9 +151,6 @@ bool CanAutopilot(const vec3d *targetPos, bool send_msg)
 		for (ship_obj *so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so))
 		{
 			object *other_objp = &Objects[so->objnum];
-			if (other_objp->flags[Object::Object_Flags::Should_be_dead])
-				continue;
-
 			// attacks player?
 			if (iff_x_attacks_y(obj_team(other_objp), obj_team(Player_obj)) 
 				&& !(Ship_info[Ships[other_objp->instance].ship_info_index].flags[Ship::Info_Flags::Cargo])) // ignore cargo
@@ -210,9 +206,8 @@ bool StartAutopilot()
 {
 	// Check for support ship and dismiss it if it is not doing anything.
 	// If the support ship is doing something then tell the user such.
-	for (auto so: list_range(&Ship_obj_list))
+	for ( object *objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) )
 	{
-		auto objp = &Objects[so->objnum];
 		if ((objp->type == OBJ_SHIP) && !(objp->flags[Object::Object_Flags::Should_be_dead]))
 		{
 			Assertion((objp->instance >= 0) && (objp->instance < MAX_SHIPS),
@@ -241,7 +236,7 @@ bool StartAutopilot()
 			// is support ship trying to rearm-repair
 			if ( ai_find_goal_index( support_ship_aip->goals, AI_GOAL_REARM_REPAIR ) == -1 ) {
 				// no, so tell it to depart
-				ai_add_ship_goal_player( ai_goal_type::PLAYER_SHIP, AI_GOAL_WARP, -1, nullptr, support_ship_aip );
+				ai_add_ship_goal_player( AIG_TYPE_PLAYER_SHIP, AI_GOAL_WARP, -1, NULL, support_ship_aip );
 			} else {
 				// yes
 				send_autopilot_msgID(NP_MSG_FAIL_SUPPORT_WORKING);
@@ -267,10 +262,10 @@ bool StartAutopilot()
 	}

 	if (The_mission.flags[Mission::Mission_Flags::Use_ap_cinematics])
-		LockAPConv = _timestamp(); // lock convergence instantly
+		LockAPConv = timestamp(); // lock convergence instantly
 	else
-		LockAPConv = _timestamp(3 * MILLISECONDS_PER_SECOND); // 3 seconds before we lock convergence
-	Player_use_ai = true;
+		LockAPConv = timestamp(3000); // 3 seconds before we lock convergence
+	Player_use_ai = 1;
 	set_time_compression(1);
 	lock_time_compression(true);

@@ -300,16 +295,15 @@ bool StartAutopilot()
 	autopilot_wings.clear();

 	// vars for usage w/ cinematic
-	vec3d pos, perp, tpos, rpos = Player_obj->pos, zero;
+	vec3d pos, norm1, perp, tpos, rpos = Player_obj->pos, zero;
 	memset(&zero, 0, sizeof(vec3d));


 	// instantly turn player toward tpos
 	if (The_mission.flags[Mission::Mission_Flags::Use_ap_cinematics])
 	{
-		vec3d norm1;
-		vm_vec_normalized_dir(&norm1, Navs[CurrentNav].GetPosition(), &Player_obj->pos);
-		vm_vector_2_matrix_norm(&Player_obj->orient, &norm1, nullptr, nullptr);
+		vm_vec_sub(&norm1, Navs[CurrentNav].GetPosition(), &Player_obj->pos);
+		vm_vector_2_matrix(&Player_obj->orient, &norm1, NULL, NULL);
 	}

 	for (i = 0; i < MAX_SHIPS; i++)
@@ -396,12 +390,10 @@ bool StartAutopilot()
 				radius = Objects[Ships[i].objnum].radius;
 			}

-			// instantly turn the ship to match the direction player is looking
 			if (The_mission.flags[Mission::Mission_Flags::Use_ap_cinematics])
-			{
-				vec3d norm1;
-				vm_vec_normalized_dir(&norm1, Navs[CurrentNav].GetPosition(), &Player_obj->pos);
-				vm_vector_2_matrix_norm(&Objects[Ships[i].objnum].orient, &norm1, nullptr, nullptr);
+			{// instantly turn the ship to match the direction player is looking
+				//vm_vec_sub(&norm1, Navs[CurrentNav].GetPosition(), &Player_obj->pos);
+				vm_vector_2_matrix(&Objects[Ships[i].objnum].orient, &norm1, NULL, NULL);
 			}

 			// snap wings into formation
@@ -410,7 +402,7 @@ bool StartAutopilot()
 				&& Autopilot_flight_leader != &Objects[Ships[i].objnum]) //only if not flight leader's object
 			{	
 				ai_info	*aip = &Ai_info[Ships[i].ai_index];
-				int wingnum = Ships[i].wingnum, wing_index = get_wing_index(&Objects[Ships[i].objnum], wingnum);
+				int wingnum = aip->wing, wing_index = get_wing_index(&Objects[Ships[i].objnum], wingnum);
 				vec3d goal_point;
 				object *leader_objp = get_wing_leader(wingnum);
 				
@@ -467,12 +459,12 @@ bool StartAutopilot()
 			{ 
 				if (Navs[CurrentNav].flags & NP_WAYPOINT)
 				{
-					ai_add_ship_goal_player( ai_goal_type::PLAYER_SHIP, AI_GOAL_WAYPOINTS_ONCE, 0, Waypoint_lists[Navs[CurrentNav].target_index].get_name(), &Ai_info[Ships[i].ai_index] );
+					ai_add_ship_goal_player( AIG_TYPE_PLAYER_SHIP, AI_GOAL_WAYPOINTS_ONCE, 0, ((waypoint_list*)Navs[CurrentNav].target_obj)->get_name(), &Ai_info[Ships[i].ai_index] );
 					//fixup has to wait until after wing goals
 				}
 				else
 				{
-					ai_add_ship_goal_player( ai_goal_type::PLAYER_SHIP, AI_GOAL_FLY_TO_SHIP, 0, Ships[Objects[Navs[CurrentNav].target_index].instance].ship_name, &Ai_info[Ships[i].ai_index] );
+					ai_add_ship_goal_player( AIG_TYPE_PLAYER_SHIP, AI_GOAL_FLY_TO_SHIP, 0, ((ship*)Navs[CurrentNav].target_obj)->ship_name, &Ai_info[Ships[i].ai_index] );
 				}

 			}
@@ -488,15 +480,15 @@ bool StartAutopilot()
 			{	
 				//ai_add_ship_goal_player( int type, int mode, int submode, char *shipname, ai_info *aip );

-				//ai_add_wing_goal_player( ai_goal_type::PLAYER_WING, AI_GOAL_STAY_NEAR_SHIP, 0, target_shipname, wingnum );
-				//ai_add_wing_goal_player( ai_goal_type::PLAYER_WING, AI_GOAL_WAYPOINTS_ONCE, 0, target_shipname, wingnum );
+				//ai_add_wing_goal_player( AIG_TYPE_PLAYER_WING, AI_GOAL_STAY_NEAR_SHIP, 0, target_shipname, wingnum );
+				//ai_add_wing_goal_player( AIG_TYPE_PLAYER_WING, AI_GOAL_WAYPOINTS_ONCE, 0, target_shipname, wingnum );
 				//ai_clear_ship_goals( &(Ai_info[Ships[num].ai_index]) );
 				
 				ai_clear_wing_goals( &Wings[i] );
 				if (Navs[CurrentNav].flags & NP_WAYPOINT)
 				{
 					
-					ai_add_wing_goal_player( ai_goal_type::PLAYER_WING, AI_GOAL_WAYPOINTS_ONCE, 0, Waypoint_lists[Navs[CurrentNav].target_index].get_name(), i );
+					ai_add_wing_goal_player( AIG_TYPE_PLAYER_WING, AI_GOAL_WAYPOINTS_ONCE, 0, ((waypoint_list*)Navs[CurrentNav].target_obj)->get_name(), i );

 					// "fix up" the goal
 					for (j = 0; j < MAX_AI_GOALS; j++)
@@ -510,7 +502,7 @@ bool StartAutopilot()
 				}
 				else
 				{
-					ai_add_wing_goal_player( ai_goal_type::PLAYER_WING, AI_GOAL_FLY_TO_SHIP, 0, Ships[Objects[Navs[CurrentNav].target_index].instance].ship_name, i );
+					ai_add_wing_goal_player( AIG_TYPE_PLAYER_WING, AI_GOAL_FLY_TO_SHIP, 0, ((ship*)Navs[CurrentNav].target_obj)->ship_name, i );

 				}
 			}
@@ -836,8 +828,9 @@ bool StartAutopilot()
 		//CameraMoving = false;


-		EndAPCinematic = _timestamp((10 * MILLISECONDS_PER_SECOND * tc_factor) + NPS_TICKRATE); // 10 objective seconds before end of cinematic 
-		MoveCamera = _timestamp(fl2i(5.5 * MILLISECONDS_PER_SECOND * tc_factor) + NPS_TICKRATE);
+		EndAPCinematic = timestamp((10000*tc_factor)+NPS_TICKRATE); // 10 objective seconds before end of cinematic 
+		MoveCamera = timestamp((5500*tc_factor)+NPS_TICKRATE);
+		camMovingTime = int(4.5*float(tc_factor));
 		set_time_compression((float)tc_factor);
 	}

@@ -858,7 +851,7 @@ void EndAutoPilot()

 	set_time_compression(1);
 	lock_time_compression(false);
-	Player_use_ai = false;
+	Player_use_ai = 0;
 	//Clear AI Goals

 	if (CinematicStarted) // clear cinematic if we need to
@@ -874,17 +867,17 @@ void EndAutoPilot()
 	Assert( CurrentNav >= 0 );

 	int goal = 0;
-	const char *goal_name = NULL;
+	char *goal_name = NULL;

 	if (Navs[CurrentNav].flags & NP_WAYPOINT)
 	{
 		goal = AI_GOAL_WAYPOINTS_ONCE;
-		goal_name = Waypoint_lists[Navs[CurrentNav].target_index].get_name();
+		goal_name = ((waypoint_list*)Navs[CurrentNav].target_obj)->get_name();
 	}
 	else
 	{
 		goal = AI_GOAL_FLY_TO_SHIP;
-		goal_name = Ships[Objects[Navs[CurrentNav].target_index].instance].ship_name;
+		goal_name = ((ship*)Navs[CurrentNav].target_obj)->ship_name;
 	}

 	// assign ship goals
@@ -930,7 +923,10 @@ void EndAutoPilot()
 					if ( ((aigp->target_name != NULL) && !stricmp(aigp->target_name, goal_name))
 							&& (aigp->ai_mode == goal) )
 					{
-						ai_goal_reset(aigp);
+						aigp->ai_mode = AI_GOAL_NONE;
+						aigp->signature = -1;
+						aigp->priority = -1;
+						aigp->flags.reset();
 					}
 				}
 			}
@@ -951,7 +947,10 @@ void EndAutoPilot()
 					if ( ((aigp->target_name != NULL) && !stricmp(aigp->target_name, goal_name))
 							&& (aigp->ai_mode == goal) )
 					{
-						ai_goal_reset(aigp);
+						aigp->ai_mode = AI_GOAL_NONE;
+						aigp->signature = -1;
+						aigp->priority = -1;
+						aigp->flags.reset();
 					}
 				}
 			}
@@ -1016,7 +1015,7 @@ void nav_warp(bool prewarp=false)
 	vm_vec_scale(&velocity, (float)Ai_info[Ships[Autopilot_flight_leader->instance].ai_index].waypoint_speed_cap);

 	// Find all ships that are supposed to autopilot with the player and move them
-	// to the cinematic location or the final destination
+	// to the cinimatic location or the final destination
 	for (int i = 0; i < MAX_SHIPS; i++)
 	{
 		if (Ships[i].objnum != -1
@@ -1025,12 +1024,11 @@ void nav_warp(bool prewarp=false)
 		{
 				vm_vec_add(&Objects[Ships[i].objnum].pos, &Objects[Ships[i].objnum].pos, &targetPos);
 				Objects[Ships[i].objnum].phys_info.vel = velocity;
-
-				// retime collision pairs
-				if (Objects[Ships[i].objnum].flags[Object::Object_Flags::Collides])
-					obj_collide_obj_cache_stale(&Objects[Ships[i].objnum]);
 		}
 	}
+
+	// retime all collision pairs
+	obj_collide_retime_cached_pairs();
 }

 // ********************************************************************************************
@@ -1055,13 +1053,15 @@ void NavSystem_Do()
 					if(cam != NULL)
 						cam->set_rotation_facing(&Player_obj->pos);

-					if (timestamp_elapsed(MoveCamera) && !CameraMoving && vm_vec_mag(&cameraTarget) > 0.0f)
+					if (timestamp() >= MoveCamera && !CameraMoving && vm_vec_mag(&cameraTarget) > 0.0f)
 					{
+						//Free_camera->set_position(&cameraTarget, float(camMovingTime), float(camMovingTime)/2.0f);
+						//Free_camera->set_translation_velocity(&cameraTarget);
 						CameraMoving = true;
 					}


-					if (timestamp_elapsed(EndAPCinematic) || !CanAutopilot())
+					if (timestamp() >= EndAPCinematic || !CanAutopilot())
 					{
 						nav_warp();
 						EndAutoPilot();
@@ -1099,9 +1099,9 @@ void NavSystem_Do()

 		for (i = 0; i < MAX_NAVPOINTS; i++)
 		{
-			if ((Navs[i].flags & NP_SHIP) && (Navs[i].target_index >= 0))
+			if ((Navs[i].flags & NP_SHIP) && (Navs[i].target_obj != NULL))
 			{
-				if (Objects[Navs[i].target_index].flags[Object::Object_Flags::Should_be_dead])
+				if (((ship*)Navs[i].target_obj)->objnum == -1)
 				{
 					if (CurrentNav == i)
 						CurrentNav = -1;
@@ -1113,7 +1113,7 @@ void NavSystem_Do()
 		// check if we're reached a Node
 		for (i = 0; i < MAX_NAVPOINTS; i++)
 		{
-			if (Navs[i].target_index >= 0)
+			if (Navs[i].target_obj != NULL)
 			{
 				if (Navs[i].flags & NP_VALIDTYPE && DistanceTo(i) < 1000)
 					Navs[i].flags |= NP_VISITED;
@@ -1189,10 +1189,6 @@ void send_autopilot_msgID(int msgid)
 	if (msgid < 0 || msgid >= NP_NUM_MESSAGES)
 		return;

-	// bail out if message is not set
-	if (NavMsgs[msgid].message[0] == '\0')
-		return;
-
 	send_autopilot_msg(NavMsgs[msgid].message, NavMsgs[msgid].filename);
 }
 // ********************************************************************************************
@@ -1222,7 +1218,7 @@ void send_autopilot_msg(const char *msg, const char *snd)
 	}

 	if (msg[0] != '\0' && strcmp(msg, "none") != 0)
-		message_training_queue("autopilot builtin message", TIMESTAMP::immediate(), 5); // display message for five seconds
+		message_training_queue("autopilot builtin message", timestamp(0), 5); // display message for five seconds
 }

 // ********************************************************************************************
@@ -1232,15 +1228,6 @@ void NavSystem_Init()
 	for (int i = 0; i < MAX_NAVPOINTS; i++)
 		Navs[i].clear();

-	//Initialize all these as empty strings so we can detect and bail out later -Mjn
-	for (int i = 0; i < NP_NUM_MESSAGES; i++)
-		NavMsgs[i].message[0] = '\0';
-
-	//Set defaults here before parsing
-	NavLinkDistance = 1000;
-	AutopilotMinEnemyDistance = 5000;
-	AutopilotMinAsteroidDistance = 1000;
-	LockWeaponsDuringAutopilot = false;
 	AutoPilotEngaged = false;
 	CurrentNav = -1;
 	audio_handle = -1;
@@ -1248,9 +1235,10 @@ void NavSystem_Init()
 	UseCutsceneBars = true;

 	// defaults... can be tabled or bound to mission later
-	parse_autopilot_table("autopilot.tbl");
-	
-	parse_modular_table("*-aplt.tbm", parse_autopilot_table);
+	if (cf_exists_full("autopilot.tbl", CF_TYPE_TABLES))
+		parse_autopilot_table("autopilot.tbl");
+	else
+		parse_autopilot_table(NULL);
 }

 // ********************************************************************************************
@@ -1261,16 +1249,10 @@ void parse_autopilot_table(const char *filename)

 	try
 	{
-
-		if (!Parsing_modular_table) {
-			// if table doesn't exist, use the default table
-			if (cf_exists_full(filename, CF_TYPE_TABLES))
-				read_file_text(filename, CF_TYPE_TABLES);
-			else
-				read_file_text_from_default(defaults_get_file("autopilot.tbl"));
-		} else {
+		if (filename == NULL)
+			read_file_text_from_default(defaults_get_file("autopilot.tbl"));
+		else
 			read_file_text(filename, CF_TYPE_TABLES);
-		}

 		reset_parse();

@@ -1278,17 +1260,23 @@ void parse_autopilot_table(const char *filename)
 		required_string("#Autopilot");

 		// autopilot link distance
-		if (optional_string("$Link Distance:"))
-			stuff_int(&NavLinkDistance);
+		required_string("$Link Distance:");
+		stuff_int(&NavLinkDistance);

 		if (optional_string("$Interrupt autopilot if enemy within distance:"))
 			stuff_int(&AutopilotMinEnemyDistance);
+		else
+			AutopilotMinEnemyDistance = 5000;

 		if (optional_string("$Interrupt autopilot if asteroid within distance:"))
 			stuff_int(&AutopilotMinAsteroidDistance);
+		else
+			AutopilotMinAsteroidDistance = 1000;

 		if (optional_string("$Lock Weapons During Autopilot:"))
 			stuff_boolean(&LockWeaponsDuringAutopilot);
+		else
+			LockWeaponsDuringAutopilot = false;

 		// optional no cutscene bars
 		if (optional_string("+No_Cutscene_Bars"))
@@ -1303,14 +1291,13 @@ void parse_autopilot_table(const char *filename)
 			"$Support Present:", "$Support Working:" };
 		for (int i = 0; i < NP_NUM_MESSAGES; i++)
 		{
-			if (optional_string(msg_tags[i])) {
+			required_string(msg_tags[i]);

-				required_string("+Msg:");
-				stuff_string(NavMsgs[i].message, F_MESSAGE, 256);
+			required_string("+Msg:");
+			stuff_string(NavMsgs[i].message, F_MESSAGE, 256);

-				required_string("+Snd File:");
-				stuff_string(NavMsgs[i].filename, F_NAME, 256);
-			}
+			required_string("+Snd File:");
+			stuff_string(NavMsgs[i].filename, F_NAME, 256);
 		}


@@ -1397,7 +1384,7 @@ bool AddNav_Ship(const char *Nav, const char *TargetName, int flags)
 	{
 		if (Ships[i].objnum != -1 && !stricmp(TargetName, Ships[i].ship_name))
 		{
-			tnav.target_index = Ships[i].objnum;
+			tnav.target_obj = (void *)&Ships[i];		
 		}
 	}

@@ -1438,7 +1425,7 @@ bool AddNav_Waypoint(const char *Nav, const char *WP_Path, int node, int flags)

 	Assert(!(tnav.flags & NP_SHIP));

-	tnav.target_index = find_matching_waypoint_list_index(WP_Path);
+	tnav.target_obj = find_matching_waypoint_list(WP_Path);
 	tnav.waypoint_num = node;

 	// copy it into it's location
@@ -29,17 +29,16 @@
 class NavPoint 
 {
 public:
-	char m_NavName[32] = { 0 };
-	int flags = 0;
-	ubyte normal_color[3] = { 0x80, 0x80, 0xFF };
-	ubyte visited_color[3] = { 0xFF, 0xFF, 0x00 };
+	char m_NavName[32];
+	int flags;
+	ubyte normal_color[3];
+	ubyte visited_color[3];

-	int target_index = -1; //waypoint list index if NP_WAYPOINT, otherwise object index
-	int waypoint_num = -1; //only used when flags & NP_WAYPOINT
+	const void *target_obj;
+	int waypoint_num; //only used when flags & NP_WAYPOINT

 	const vec3d *GetPosition();

-	// these assignments should match the initialization
 	void clear()
 	{
 		m_NavName[0] = 0;
@@ -53,7 +52,7 @@ public:
 		visited_color[1] = 0xFF;
 		visited_color[2] = 0x00;

-		target_index = -1;
+		target_obj = nullptr;
 		waypoint_num = -1;
 	}
 };
@@ -79,7 +78,7 @@ extern bool AutoPilotEngaged;
 extern int CurrentNav;
 extern NavPoint Navs[MAX_NAVPOINTS];
 extern NavMessage NavMsgs[NP_NUM_MESSAGES];
-extern TIMESTAMP LockAPConv;
+extern int LockAPConv;
 extern SCP_map<int,int> autopilot_wings;

 // Cycles through the NavPoint List
@@ -100,7 +100,7 @@ void bm_lock_apng( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort fla
 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 );
+void bm_lock_user( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );

 const size_t BM_BLOCK_SIZE = 4096;

@@ -53,7 +53,6 @@ MONITOR(SizeBitmapPage)
 // --------------------------------------------------------------------------------------------------------------------
 // Definition of public variables (declared as extern in bmpman.h).
 int ENVMAP = -1;
-int IRRMAP = -1;

 size_t bm_texture_ram = 0;
 int Bm_paging = 0;
@@ -425,7 +424,6 @@ DCF(bm_used, "Shows BmpMan Slot Usage") {

 	SCP_stringstream text;
 	text << "BmpMan Used Slots\n";
-	text << "  " << std::dec << std::setw(4) << std::setfill('0') << none << ", NONE\n";
 	text << "  " << std::dec << std::setw(4) << std::setfill('0') << pcx  << ", PCX\n";
 	text << "  " << std::dec << std::setw(4) << std::setfill('0') << user << ", User\n";
 	text << "  " << std::dec << std::setw(4) << std::setfill('0') << tga  << ", TGA\n";
@@ -586,59 +584,6 @@ int bm_create(int bpp, int w, int h, void *data, int flags) {
 	return n;
 }

-int bm_create_3d(int bpp, int w, int h, int d, void* data) {
-	Assert((bpp == 16) || (bpp == 24) || (bpp == 32));
-	
-	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");
-
-	int n = find_block_of(1);
-
-	// Out of bitmap slots
-	if (n == -1)
-		return -1;
-
-	// make sure that we have valid data
-	if (data == nullptr) {
-		UNREACHABLE("No valid data received for 3D Bitmap creation!");
-		return -1;
-	}
-
-	auto entry = bm_get_entry(n);
-
-	memset(entry, 0, sizeof(bitmap_entry));
-
-	sprintf_safe(entry->filename, "TMP%dx%dx%d+%d", w, h, d, bpp);
-	entry->type = BM_TYPE_3D;
-	entry->comp_type = BM_TYPE_NONE;
-
-	entry->bm.w = (short)w;
-	entry->bm.h = (short)h;
-	entry->bm.d = (short)d;
-	entry->bm.rowsize = (short)w;
-	entry->bm.bpp = (ubyte)bpp;
-	entry->bm.true_bpp = (ubyte)bpp;
-	entry->bm.flags = (ubyte)BMP_TEX_XPARENT;
-	entry->bm.data = 0;
-	entry->bm.palette = nullptr;
-
-	entry->info.user.bpp = (ubyte)bpp;
-	entry->info.user.data = data;
-	entry->info.user.flags = (ubyte)BMP_TEX_XPARENT;
-
-	entry->signature = Bm_next_signature++;
-
-	entry->handle = n;
-	entry->mem_taken = (w * h * d * (bpp >> 3));
-
-	entry->load_count++;
-
-	bm_update_memory_used(n, (int)entry->mem_taken);
-
-	gr_bm_create(bm_get_slot(n));
-
-	return n;
-}
-
 void bm_convert_format(bitmap *bmp, ushort flags) {
 	int idx;

@@ -682,7 +627,7 @@ void bm_free_data(bitmap_slot* bs, bool release)

 	// Don't free up memory for user defined bitmaps, since
 	// BmpMan isn't the one in charge of allocating/deallocing them.
-	if (be->type == BM_TYPE_USER || be->type == BM_TYPE_3D) {
+	if (be->type==BM_TYPE_USER) {
 #ifdef BMPMAN_NDEBUG
 		if ( be->data_size != 0 )
 			bm_texture_ram -= be->data_size;
@@ -738,7 +683,7 @@ void bm_free_data_fast(int handle)

 	// Don't free up memory for user defined bitmaps, since
 	// BmpMan isn't the one in charge of allocating/deallocing them.
-	if (be->type == BM_TYPE_USER || be->type == BM_TYPE_3D) {
+	if (be->type == BM_TYPE_USER) {
 #ifdef BMPMAN_NDEBUG
 		if ( be->data_size != 0 )
 			bm_texture_ram -= be->data_size;
@@ -946,27 +891,6 @@ int bm_get_info(int handle, int *w, int * h, ushort* flags, int *nframes, int *f
 	}
 }

-int bm_get_depth(int handle, int* depth) {
-	bitmap* bmp;
-
-	if (!bm_inited) return -1;
-
-	auto entry = bm_get_entry(handle);
-
-	Assertion(entry->handle == handle, "Invalid bitmap handle %d passed to bm_get_info().\nThis might be due to an invalid animation somewhere else.\n", handle);		// INVALID BITMAP HANDLE!
-
-	if (entry->type != BM_TYPE_3D) {
-		*depth = 0;
-		return -1;
-	}
-
-	bmp = &(entry->bm);
-
-	*depth = bmp->d;
-
-	return handle;
-}
-
 int bm_get_num_mipmaps(int num) {
 	auto entry = bm_get_entry(num);

@@ -1027,6 +951,10 @@ int bm_is_compressed(int num) {
 	auto entry = bm_get_entry(num);
 	BM_TYPE type = BM_TYPE_NONE;

+	//duh
+	if (!Use_compressed_textures)
+		return 0;
+
 	type = entry->comp_type;

 	switch (type) {
@@ -1478,10 +1406,6 @@ static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
 			bm_lock_user(handle, bs, bmp, true_bpp, flags);
 			break;

-		case BM_TYPE_3D:
-			bm_lock_user(handle, bs, bmp, true_bpp, flags, false);
-			break;
-
 		default:
 			Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", c_type);
 			return -1;
@@ -1592,13 +1516,10 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 	// MAX_FILENAME_LEN-10 == 5 character frame designator plus '.' plus 3 letter ext plus NULL terminator
 	// we only check for -5 here since the filename should already have the extension on it, and it must have passed the previous check
 	if (strlen(filename) > MAX_FILENAME_LEN - 5) {
-		// Don't check PNGs yet, because a PNG could be a regular non-animated image
-		if (type != BM_TYPE_PNG) {
-			Warning(LOCATION, "Passed filename, '%s', is too long to support an extension and frames!!\n\nMaximum length for an ANI/EFF/APNG, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 10);
-			if (img_cfp != nullptr)
-				cfclose(img_cfp);
-			return -1;
-		}
+		Warning(LOCATION, "Passed filename, '%s', is too long to support an extension and frames!!\n\nMaximum length for an ANI/EFF/APNG, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 10);
+		if (img_cfp != nullptr)
+			cfclose(img_cfp);
+		return -1;
 	}

 	// it's an effect file, any readable image type with eff being txt
@@ -1609,7 +1530,7 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 				cfclose(img_cfp);
 			return -1;
 		} else {
-			nprintf(("BmpMan","BMPMAN: Found EFF (%s) with %d frames at %d fps.\n", filename, anim_frames, anim_fps));
+			mprintf(("BMPMAN: Found EFF (%s) with %d frames at %d fps.\n", filename, anim_frames, anim_fps));
 		}
 		if (anim_fps == 0) {
 			Error(LOCATION, "animation (%s) has invalid fps of 0, fix this!", filename);
@@ -1678,18 +1599,10 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 				throw e;
 			}
 			else {
-				nprintf(("apng","Failed to load apng: %s\n", e.what()));
+				mprintf(("Failed to load apng: %s\n", e.what()));
 				return -1;
 			}
 		}
-
-		// Now do the same filename length check that was deferred for PNGs above
-		if (strlen(filename) > MAX_FILENAME_LEN - 5) {
-			Warning(LOCATION, "Passed filename, '%s', is too long to support an extension and frames!!\n\nMaximum length for an ANI/EFF/APNG, minus the extension, is %i characters.\n", filename, MAX_FILENAME_LEN - 10);
-			if (img_cfp != nullptr)
-				cfclose(img_cfp);
-			return -1;
-		}
 	}
 	else {
 		Warning(LOCATION, "Unsupported image type: %i", type);
@@ -1921,7 +1834,7 @@ int bm_load_sub_fast(const char *real_filename, int *handle, int dir_type, bool
 }

 int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **ext_list, CFILE **img_cfp, int dir_type) {
-	auto res = cf_find_file_location_ext(real_filename, num_ext, ext_list, dir_type);
+	auto res = cf_find_file_location_ext(real_filename, num_ext, ext_list, dir_type, false);

 	// could not be found, or is invalid for some reason
 	if (!res.found)
@@ -2474,7 +2387,7 @@ void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags
 	bm_convert_format(bmp, flags);
 }

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

 	// Unload any existing data
@@ -2514,8 +2427,7 @@ void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort
 		break;
 	}

-	if (convert)
-		bm_convert_format(bmp, flags);
+	bm_convert_format(bmp, flags);
 }

 int bm_make_render_target(int width, int height, int flags) {
@@ -2599,7 +2511,7 @@ void *bm_malloc(int n, size_t size) {
 void bm_page_in_aabitmap(int handle, int nframes) {
 	int i;

-	if (handle < 0)
+	if (handle == -1)
 		return;

 	Assert(bm_get_entry(handle)->handle == handle);
@@ -2710,7 +2622,7 @@ void bm_page_in_stop() {
 		}
 	}

-	nprintf(("BmpMan","BMPMAN: %d/%d bitmap slots in use.\n", total_bitmaps, total_slots));
+	mprintf(("Bmpman: %d/%d bitmap slots in use.\n", total_bitmaps, total_slots));
 #endif

 	Bm_paging = 0;
@@ -3218,7 +3130,7 @@ int bm_unload_fast(int handle, int clear_render_targets) {
 		return -1;		// Already been released
 	}

-	if (be->type == BM_TYPE_USER || be->type == BM_TYPE_3D) {
+	if (be->type == BM_TYPE_USER) {
 		return -1;
 	}

@@ -79,9 +79,7 @@ enum BM_TYPE
 	BM_TYPE_CUBEMAP_DDS,    //!< generic DDS cubemap (uncompressed cubemap surface)
 	BM_TYPE_CUBEMAP_DXT1,   //!< 24-bit cubemap        (compressed cubemap surface)
 	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_CUBEMAP_DXT5    //!< 32-bit cubemap        (compressed cubemap surface)
 };

 /**
@@ -92,7 +90,6 @@ struct bitmap
 {
 	short	w;          //!< Width, in number of pixels
 	short	h;          //!< Height, in number of pixels
-	short	d;			//!< Depth, in number of pixels
 	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
@@ -119,7 +116,6 @@ extern const char *bm_ani_ext_list[];    //!< List of extensions for those types
 extern const int BM_ANI_NUM_TYPES;       //!< Calculated number of bitmap animation types

 extern int ENVMAP;      //!< References a map that is for environment mapping -Bobboau
-extern int IRRMAP;		//!< References a filtered envmap for diffuse environment lighting - qazwsxal

 /**
 * @brief Initilizes the bitmap manager
@@ -220,19 +216,6 @@ int bm_load_duplicate(const char *filename);
 */
 int bm_create(int bpp, int w, int h, void *data = NULL, int flags = 0);

-/**
- * Loads a 3D bitmap which exists somewhere in the RAM.
- *
- * @param bpp The bitdepth of the bitmap
- * @param w The width of the bitmap
- * @param h The height of the bitmap
- * @param d The depth of the bitmap
- * @param[in] data The bitmap's data glob
- *
- * @note The used RAM cannot be freed until bm_release is called on the created bitmap
- */
-int bm_create_3d(int bpp, int w, int h, int d, void* data = nullptr);
-
 /**
 * @brief Unloads a bitmap's data, but not the bitmap info
 *
@@ -389,16 +372,6 @@ int bm_is_valid(int handle);
 */
 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.
- *
- * @param[out] depth      If non-null, gets the depth
- *
- * @returns The handle on success
- * @returns -1 on failure
- */
-int bm_get_depth(int handle, int* depth);
-
 /**
 * @brief Gets the filename of the bitmap indexed by handle
 *
@@ -573,6 +546,7 @@ void bm_set_components_argb_32_tex(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, u
 */
 void bm_get_components(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);

+extern int ENVMAP;	//this holds a reference to a map that is for environment mapping -Bobboau

 /**
 * @brief Returns the compression type of the bitmap indexed by handle
@@ -14,8 +14,8 @@
 #include "ship/ship.h"        //compute_slew_matrix

 //*************************IMPORTANT GLOBALS*************************
-fov_t VIEWER_ZOOM_DEFAULT = DEFAULT_FOV;
-fov_t COCKPIT_ZOOM_DEFAULT = DEFAULT_FOV;
+float VIEWER_ZOOM_DEFAULT = 0.75f;			//	Default viewer zoom, 0.625 as per multi-lateral agreement on 3/24/97
+float COCKPIT_ZOOM_DEFAULT = 0.75f;
 float Sexp_fov = 0.0f;
 warp_camera Warp_camera;

@@ -27,36 +27,6 @@ SCP_vector<camera*> Cameras;
 camid Current_camera;
 camid Main_camera;

-asymmetric_fov operator* (const asymmetric_fov& left, const float& right) {
-	return asymmetric_fov{ left.left * right, left.right * right, left.up * right, left.down * right };
-}
-asymmetric_fov operator+ (const asymmetric_fov& left, const float& right) {
-	float ar = (left.up - left.down) / (left.right - left.left);
-	return asymmetric_fov{ left.left - right * 0.5f, left.right + right * 0.5f, left.up + right * 0.5f * ar, left.down - right * 0.5f * ar };
-}
-asymmetric_fov operator- (const asymmetric_fov& left, const float& right) {
-	float ar = (left.up - left.down) / (left.right - left.left);
-	return asymmetric_fov{ left.left + right * 0.5f, left.right - right * 0.5f, left.up - right * 0.5f * ar, left.down + right * 0.5f * ar };
-}
-
-#define APPLY_TO_FOV_T(op, name) \
-struct apply_##name##_to_fov { \
-	float r; \
-	template<typename T> \
-	fov_t operator()(const T& l) { \
-		return fov_t(l op r); \
-	} \
-}; \
-fov_t operator op (const fov_t& zoom, const float& scale) { \
-	return std::visit(apply_##name##_to_fov{scale}, zoom); \
-}
-APPLY_TO_FOV_T(*, mul)
-APPLY_TO_FOV_T(+, add)
-APPLY_TO_FOV_T(-, sub)
-
-// Used to set the default value for in-game options
-static float fov_default = DEFAULT_FOV;
-
 static SCP_string fov_display(float val)
 {
 	auto degrees = fl_degrees(val);
@@ -64,67 +34,15 @@ static SCP_string fov_display(float val)
 	sprintf(out, u8"%.1f\u00B0", degrees);
 	return out;
 }
-
-static void parse_fov_func()
-{
-	float value;
-	stuff_float(&value);
-	CLAMP(value, 0.436332f, 1.5708f);
-	fov_default = value;
-}
-
-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})
-					 .category(std::make_pair("Graphics", 1825))
-					 .range(0.436332f, 1.5708f)
-					 .change_listener([](const float& val, bool) {
-					      VIEWER_ZOOM_DEFAULT = val;
-					      return true;
-					 })
-					 .display(fov_display)
-					 .default_func([]() { return fov_default; })
-					 .level(options::ExpertLevel::Advanced)
-					 .importance(60)
-					 .parser(parse_fov_func)
-					 .finish();
-
-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) {
-					      if (Use_cockpit_fov){
-					           COCKPIT_ZOOM_DEFAULT = val;
-						  } else {
-							  COCKPIT_ZOOM_DEFAULT = VIEWER_ZOOM_DEFAULT;
-						  }
-					      return true;
-					 })
-					 .display(fov_display)
-					 .default_val(fov_default)
-					 .level(options::ExpertLevel::Advanced)
-					 .importance(62)
-					 .finish();
+auto FovOption = options::OptionBuilder<float>("Graphics.FOV", "Field Of View", "The vertical field of view.")
+                     .category("Graphics")
+                     .range(0.436332f, 1.5708f)
+                     .bind_to(&VIEWER_ZOOM_DEFAULT)
+                     .display(fov_display)
+                     .default_val(0.75f)
+                     .level(options::ExpertLevel::Advanced)
+                     .importance(60)
+                     .finish();

 //*************************CLASS: camera*************************
 //This is where the camera class begins! :D
@@ -167,7 +85,7 @@ void camera::reset()
 	func_custom_orientation = NULL;

 	fov.clear();
-	fov.set(g3_get_hfov(VIEWER_ZOOM_DEFAULT));
+	fov.set(VIEWER_ZOOM_DEFAULT);

 	pos_x.clear();
 	pos_y.clear();
@@ -186,7 +104,7 @@ void camera::set_name(const char *in_name)
 		strncpy(name, in_name, NAME_LENGTH-1);
 }

-void camera::set_fov(fov_t in_fov, float in_fov_time, float in_fov_acceleration_time, float in_fov_deceleration_time)
+void camera::set_fov(float in_fov, float in_fov_time, float in_fov_acceleration_time, float in_fov_deceleration_time)
 {
 	if(in_fov_time == 0.0f && in_fov_acceleration_time == 0.0f && in_fov_deceleration_time == 0.0f)
 	{
@@ -196,49 +114,42 @@ void camera::set_fov(fov_t in_fov, float in_fov_time, float in_fov_acceleration_
 	}

 	flags &= ~CAM_STATIONARY_FOV;
-	if(g3_get_hfov(in_fov) <= 0.0f)
+	if(in_fov <= 0.0f)
 	{
 		fov.setVD(in_fov_time, in_fov_acceleration_time, 0.0f);
 	}

-	fov.setAVD(g3_get_hfov(in_fov), in_fov_time, in_fov_acceleration_time, in_fov_deceleration_time, 0.0f);
+	fov.setAVD(in_fov, in_fov_time, in_fov_acceleration_time, in_fov_deceleration_time, 0.0f);
 }

 void camera::set_object_host(object *objp, int n_object_host_submodel)
 {
+	if(objp == NULL)
+		object_host = object_h();
+
 	object_host = object_h(objp);
 	object_host_submodel = n_object_host_submodel;
 	set_custom_position_function(NULL);
 	set_custom_orientation_function(NULL);
-
-	if (n_object_host_submodel >= 0 && objp != nullptr && objp->type == OBJ_SHIP) 
+	if(n_object_host_submodel > 0)
 	{
-		ship_subsys* ssp = GET_FIRST(&Ships[objp->instance].subsys_list);
-		while (ssp != END_OF_LIST(&Ships[objp->instance].subsys_list)) 
+		if(objp->type == OBJ_SHIP)
 		{
-			if (ssp->system_info->subobj_num == n_object_host_submodel) 
+			ship_subsys* ssp = GET_FIRST(&Ships[objp->instance].subsys_list);
+			while ( ssp != END_OF_LIST( &Ships[objp->instance].subsys_list ) )
 			{
-				if (ssp->system_info->type == SUBSYSTEM_TURRET) 
+				if(ssp->system_info->subobj_num == n_object_host_submodel)
 				{
-					set_custom_position_function(get_turret_cam_pos);
-					set_custom_orientation_function(get_turret_cam_orient);
+					if(ssp->system_info->type == SUBSYSTEM_TURRET)
+					{
+						set_custom_position_function(get_turret_cam_pos);
+						set_custom_orientation_function(get_turret_cam_orient);
+					}
 				}
+				ssp = GET_NEXT( ssp );
 			}
-			ssp = GET_NEXT(ssp);
 		}
 	}
-	else if (Use_model_eyepoint_for_set_camera_host && object_host.isValid()) 
-	{
-		const object* host = object_host.objp();
-
-		vec3d eye_pos;
-		matrix eye_orient;
-
-		object_get_eye(&eye_pos, &eye_orient, host, false, true, true);
-
-		set_position(&eye_pos);
-		set_rotation(&eye_orient);
-	}
 }

 void camera::set_object_target(object *objp, int n_object_target_submodel)
@@ -357,11 +268,11 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 		if (Use_host_orientation_for_set_camera_facing)
 		{
 			// point along the target vector, but using the host orient's roll
-			vm_vector_2_matrix_norm(&temp_matrix, &targetvec, &orient->vec.uvec, nullptr);
+			vm_vector_2_matrix(&temp_matrix, &targetvec, &orient->vec.uvec, nullptr);

 			// if we have a host, we need the difference between the camera's current orient and the orient we want
 			// if not, we will later set the absolute orientation, rather than the orientation relative to the host
-			if (object_host.isValid())
+			if (object_host.IsValid())
 			{
 				vm_transpose(orient);
 				temp_matrix = temp_matrix * *orient;
@@ -370,7 +281,7 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 		else
 		{
 			// point directly along the target vector
-			vm_vector_2_matrix_norm(&temp_matrix, &targetvec, nullptr, nullptr);
+			vm_vector_2_matrix(&temp_matrix, &targetvec, nullptr, nullptr);
 		}
 	}

@@ -384,7 +295,10 @@ void camera::do_frame(float  /*in_frametime*/)

 object *camera::get_object_host()
 {
-	return object_host.objp_or_null();
+	if(object_host.IsValid())
+		return object_host.objp;
+	else
+		return NULL;
 }

 int camera::get_object_host_submodel()
@@ -394,7 +308,10 @@ int camera::get_object_host_submodel()

 object *camera::get_object_target()
 {
-	return object_target.objp_or_null();
+	if(object_target.IsValid())
+		return object_target.objp;
+	else
+		return NULL;
 }

 int camera::get_object_target_submodel()
@@ -402,14 +319,11 @@ int camera::get_object_target_submodel()
 	return object_target_submodel;
 }

-fov_t camera::get_fov()
+float camera::get_fov()
 {
 	if(!(flags & CAM_STATIONARY_FOV))
 	{
-		float fov_now;
-		fov.get(&fov_now, nullptr);
-		return fov_now;
-		//TODO enable moving asymmetric fov
+		fov.get(&c_fov, NULL);
 	}

 	return c_fov;
@@ -427,7 +341,7 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 	bool use_host_orient = false;

 	//POSITION
-	if(!(flags & CAM_STATIONARY_POS) || object_host.isValid())
+	if(!(flags & CAM_STATIONARY_POS) || object_host.IsValid())
 	{
 		c_pos = vmd_zero_vector;

@@ -436,16 +350,24 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 		pos_y.get(&pt.xyz.y, NULL);
 		pos_z.get(&pt.xyz.z, NULL);

-		if(object_host.isValid())
+		if(object_host.IsValid())
 		{
-			object *objp = object_host.objp();
-			polymodel *pm = object_get_model(objp);
-			polymodel_instance *pmi = object_get_model_instance(objp);
+			object *objp = object_host.objp;
+			int model_num = object_get_model(objp);
+			polymodel *pm = nullptr;
+			polymodel_instance *pmi = nullptr;
+			
+			if(model_num >= 0)
+			{
+				pm = model_get(model_num);
+				if (objp->type == OBJ_SHIP)
+					pmi = model_get_instance(Ships[objp->instance].model_instance_num);
+			}

 			if(object_host_submodel < 0 || pm == NULL)
 			{
-				vm_vec_unrotate(&c_pos, &pt, &object_host.objp()->orient);
-				vm_vec_add2(&c_pos, &object_host.objp()->pos);
+				vm_vec_unrotate(&c_pos, &pt, &object_host.objp->orient);
+				vm_vec_add2(&c_pos, &object_host.objp->pos);
 			}
 			else
 			{
@@ -490,14 +412,23 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 	if(orientation != NULL)
 	{
 		bool target_set = false;
-		if(!(flags & CAM_STATIONARY_ORI) || object_target.isValid() || object_host.isValid())
+		if(!(flags & CAM_STATIONARY_ORI) || object_target.IsValid() || object_host.IsValid())
 		{
-			if(object_target.isValid())
+			if(object_target.IsValid())
 			{
-				object *target_objp = object_target.objp();
-				polymodel *target_pm = object_get_model(target_objp);
-				polymodel_instance *target_pmi = object_get_model_instance(target_objp);
+				object *target_objp = object_target.objp;
+				int model_num = object_get_model(target_objp);
+				polymodel *target_pm = nullptr;
+				polymodel_instance *target_pmi = nullptr;
 				vec3d target_pos = vmd_zero_vector;
+				
+				//See if we can get the model
+				if(model_num >= 0)
+				{
+					target_pm = model_get(model_num);
+					if (target_objp->type == OBJ_SHIP)
+						target_pmi = model_get_instance(Ships[target_objp->instance].model_instance_num);
+				}

 				//If we don't have a submodel or don't have the model use object pos
 				//Otherwise, find the submodel pos as it is rotated
@@ -515,14 +446,14 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or

 				vec3d targetvec;
 				vm_vec_normalized_dir(&targetvec, &target_pos, &c_pos);
-				vm_vector_2_matrix_norm(&c_ori, &targetvec, nullptr, nullptr);
+				vm_vector_2_matrix(&c_ori, &targetvec, NULL, NULL);
 				target_set = true;
 			}
-			else if(object_host.isValid())
+			else if(object_host.IsValid())
 			{
 				if(eyep)
 				{
-					vm_vector_2_matrix_norm(&c_ori, &host_normal, vm_vec_same(&host_normal, &object_host.objp()->orient.vec.uvec) ? nullptr : &object_host.objp()->orient.vec.uvec, nullptr);
+					vm_vector_2_matrix(&c_ori, &host_normal, vm_vec_same(&host_normal, &object_host.objp->orient.vec.uvec)?NULL:&object_host.objp->orient.vec.uvec, NULL);
 					target_set = true;
 				}
 				else if (use_host_orient)
@@ -531,7 +462,7 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 				}
 				else
 				{
-					c_ori = object_host.objp()->orient;
+					c_ori = object_host.objp->orient;
 				}
 			}
 			else
@@ -578,7 +509,7 @@ warp_camera::warp_camera(object *objp)

 	vec3d object_pos = objp->pos;
 	matrix tmp;
-	object_get_eye(&object_pos, &tmp, objp);
+	ship_get_eye(&object_pos, &tmp, objp);

 	vm_vec_scale_add2( &object_pos, &Player_obj->orient.vec.rvec, 0.0f );
 	vm_vec_scale_add2( &object_pos, &Player_obj->orient.vec.uvec, 0.952f );
@@ -791,7 +722,7 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 		//Get text size
 		for(int i = 0; i < num_text_lines; i++)
 		{
-			gr_get_string_size(&w, &h, text_line_ptrs[i], 1.0f, static_cast<size_t>(text_line_lens[i]));
+			gr_get_string_size(&w, &h, text_line_ptrs[i], text_line_lens[i]);

 			if(w > tw)
 				tw = w;
@@ -900,10 +831,7 @@ void subtitle::do_frame(float frametime)

 	auto sizing_mode = do_screen_scaling ? GR_RESIZE_FULL : GR_RESIZE_NONE;
 	if (do_screen_scaling)
-	{
 		gr_set_screen_scale(Show_subtitle_screen_adjusted_res[0], Show_subtitle_screen_adjusted_res[1]);
-		gr_set_clip(0, 0, Show_subtitle_screen_adjusted_res[0], Show_subtitle_screen_adjusted_res[1]);
-	}

 	// do the actual drawing ---------------------

@@ -951,10 +879,7 @@ void subtitle::do_frame(float frametime)
 	// finished the actual drawing ---------------

 	if (do_screen_scaling)
-	{
 		gr_reset_screen_scale();
-		gr_reset_clip();
-	}

 	// restore old font
 	if (old_fontnum >= 0)
@@ -1048,7 +973,7 @@ int camid::getSignature()
 	return sig;
 }

-bool camid::isValid() const
+bool camid::isValid()
 {
 	if(idx >= Cameras.size())
 		return false;
@@ -1085,6 +1010,13 @@ int cam_get_next_sig()
 	return next_sig++;
 }

+camid cam_create(const char *n_name, vec3d *n_pos, vec3d *n_norm, object *n_object, int n_object_host_submodel)
+{
+	matrix ori;
+	vm_vector_2_matrix_norm(&ori, n_norm);
+	return cam_create(n_name, n_pos, &ori, n_object, n_object_host_submodel);
+}
+
 camid cam_create(const char *n_name, vec3d *n_pos, matrix *n_ori, object *n_object, int n_object_host_submodel)
 {
 	camera *cam = NULL;
@@ -1228,12 +1160,12 @@ void subtitles_do_frame_post_shaded(float frametime)
 	}
 }

-static vec3d normal_cache;
+vec3d normal_cache;

 void get_turret_cam_pos(camera *cam, vec3d *pos)
 {
 	object_h obj(cam->get_object_host());
-	if(!obj.isValid())
+	if(!obj.IsValid())
 		return;
 	ship* shipp = &Ships[cam->get_object_host()->instance];
 	ship_subsys* ssp = GET_FIRST(&shipp->subsys_list);
@@ -1241,7 +1173,7 @@ void get_turret_cam_pos(camera *cam, vec3d *pos)
 	{
 		if(ssp->system_info->subobj_num == cam->get_object_host_submodel())
 		{
-			ship_get_global_turret_gun_info(cam->get_object_host(), ssp, pos, true, &normal_cache, true, nullptr);
+			ship_get_global_turret_gun_info(cam->get_object_host(), ssp, pos, &normal_cache, 1, NULL);
 			vec3d offset = vmd_zero_vector;
 			offset.xyz.x = 0.0001f;
 			vm_vec_add2(pos, &offset); // prevent beam turrets from crashing with a nullvec
@@ -1254,9 +1186,9 @@ void get_turret_cam_pos(camera *cam, vec3d *pos)
 void get_turret_cam_orient(camera *cam, matrix *ori)
 {
 	object_h obj(cam->get_object_host());
-	if(!obj.isValid())
+	if(!obj.IsValid())
 		return;
-	vm_vector_2_matrix_norm(ori, &normal_cache, vm_vec_same(&normal_cache, &cam->get_object_host()->orient.vec.uvec) ? nullptr : &cam->get_object_host()->orient.vec.uvec, nullptr);
+	vm_vector_2_matrix(ori, &normal_cache, vm_vec_same(&normal_cache, &cam->get_object_host()->orient.vec.uvec)?NULL:&cam->get_object_host()->orient.vec.uvec, NULL);
 }

 eye* get_submodel_eye(polymodel *pm, int submodel_num)
@@ -1293,7 +1225,8 @@ float cam_get_bbox_dist(const object* viewer_obj, float preferred_distance, cons
 	if (preferred_distance > (viewer_obj->radius * EXTERN_CAM_BBOX_MULTIPLIER_PADDING + EXTERN_CAM_BBOX_CONSTANT_PADDING) * 1.5f) 
 		return preferred_distance;
 	
-	polymodel* pm = object_get_model(viewer_obj);
+	int modelnum = object_get_model(viewer_obj);
+	polymodel* pm = model_get(modelnum);
 	vec3d adjusted_bbox;
 	const vec3d* cam_vec = &cam_orient->vec.fvec;

@@ -10,8 +10,6 @@

 #include <string>

-#include <variant>
-
 #define CAM_STATIONARY_FOV			(1<<0)
 #define CAM_STATIONARY_ORI			(1<<1)
 #define CAM_STATIONARY_POS			(1<<2)
@@ -20,19 +18,6 @@
 #define	EXTERN_CAM_BBOX_CONSTANT_PADDING			5.0f
 #define	EXTERN_CAM_BBOX_MULTIPLIER_PADDING			1.5f

-#define DEFAULT_FOV 0.75f;
-
-struct asymmetric_fov {
-	float left, right, up, down;
-	friend asymmetric_fov operator* (const asymmetric_fov&, const float&);
-	friend asymmetric_fov operator+ (const asymmetric_fov&, const float&);
-	friend asymmetric_fov operator- (const asymmetric_fov&, const float&);
-};
-using fov_t = std::variant<float, asymmetric_fov>;
-fov_t operator* (const fov_t&, const float&);
-fov_t operator+ (const fov_t&, const float&);
-fov_t operator- (const fov_t&, const float&);
-
 class camera
 {
 protected:
@@ -56,7 +41,7 @@ protected:
 	avd_movement ori[9];

 	//Cache stuff
-	fov_t c_fov;
+	float c_fov;
 	vec3d c_pos;
 	matrix c_ori;
 public:
@@ -74,7 +59,7 @@ public:
 	void set_custom_position_function(void (*n_func_custom_position)(camera *cam, vec3d *pos));
 	void set_custom_orientation_function(void (*n_func_custom_orientation)(camera *cam, matrix *ori));

-	void set_fov(fov_t in_fov, float in_fov_time = 0.0f, float in_fov_acceleration_time = 0.0f, float in_deceleration_time = 0.0f);
+	void set_fov(float in_fov, float in_fov_time = 0.0f, float in_fov_acceleration_time = 0.0f, float in_deceleration_time = 0.0f);

 	void set_position(vec3d *in_position = NULL, float in_translation_time = 0.0f, float in_translation_acceleration_time = 0.0f, float in_translation_deceleration_time = 0.0f, float in_end_velocity = 0.0f);

@@ -89,7 +74,7 @@ public:
 	int get_object_host_submodel();
 	object *get_object_target();
 	int get_object_target_submodel();
-	fov_t get_fov();
+	float get_fov();
 	void get_info(vec3d *position, matrix *orientation, bool apply_camera_orientation = true);

 	//Is
@@ -170,8 +155,8 @@ public:

 //Some global stuff
 extern SCP_vector<subtitle> Subtitles;
-extern fov_t VIEWER_ZOOM_DEFAULT;
-extern fov_t COCKPIT_ZOOM_DEFAULT;
+extern float VIEWER_ZOOM_DEFAULT;
+extern float COCKPIT_ZOOM_DEFAULT;
 extern float Sexp_fov;

 //Helpful functions
@@ -179,6 +164,7 @@ void cam_init();
 void cam_close();
 void cam_do_frame(float frametime);
 camid cam_create(const char *n_name=NULL, vec3d *n_pos=NULL, matrix *n_ori=NULL, object *n_object=NULL, int n_submodel_parent=-1);
+camid cam_create(const char *n_name, vec3d *n_pos, vec3d *n_norm, object *n_object=NULL, int n_submodel_parent=-1);
 void cam_delete(camid cid);
 bool cam_set_camera(camid cid);
 void cam_reset_camera();
@@ -20,10 +20,12 @@
 #include <io.h>
 #include <direct.h>
 #include <windows.h>
+#include <winbase.h>		/* needed for memory mapping of file functions */
 #endif

 #ifdef SCP_UNIX
 #include <glob.h>
+#include <sys/mman.h>
 #endif

 #include "cfile/cfile.h"
@@ -57,6 +59,8 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ 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	},
 	{ CF_TYPE_SOUNDS,				"data" DIR_SEPARATOR_STR "sounds",											".wav .ogg",						CF_TYPE_DATA	},
+	{ CF_TYPE_SOUNDS_8B22K,			"data" DIR_SEPARATOR_STR "sounds" DIR_SEPARATOR_STR "8b22k",				".wav .ogg",						CF_TYPE_SOUNDS	},
+	{ CF_TYPE_SOUNDS_16B11K,		"data" DIR_SEPARATOR_STR "sounds" DIR_SEPARATOR_STR "16b11k",				".wav .ogg",						CF_TYPE_SOUNDS	},
 	{ CF_TYPE_VOICE,				"data" DIR_SEPARATOR_STR "voice",											"",									CF_TYPE_DATA	},
 	{ CF_TYPE_VOICE_BRIEFINGS,		"data" DIR_SEPARATOR_STR "voice" DIR_SEPARATOR_STR "briefing",				".wav .ogg",						CF_TYPE_VOICE	},
 	{ CF_TYPE_VOICE_CMD_BRIEF,		"data" DIR_SEPARATOR_STR "voice" DIR_SEPARATOR_STR "command_briefings",		".wav .ogg",						CF_TYPE_VOICE	},
@@ -66,7 +70,7 @@ 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",	CF_TYPE_DATA	},
+	{ CF_TYPE_INTERFACE,			"data" DIR_SEPARATOR_STR "interface",										".pcx .ani .dds .tga .eff .png .jpg",	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 .sdr",	CF_TYPE_DATA	},
 	{ CF_TYPE_HUD,					"data" DIR_SEPARATOR_STR "hud",												".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
@@ -75,7 +79,6 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ 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",		CF_TYPE_DATA	},
 	{ CF_TYPE_MISSIONS,				"data" DIR_SEPARATOR_STR "missions",										".fs2 .fc2 .ntl .ssv",				CF_TYPE_DATA	},
@@ -85,14 +88,19 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ 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",							CF_TYPE_DATA	}
+	{ CF_TYPE_FREDDOCS,				"data" DIR_SEPARATOR_STR "freddocs",										".html",							CF_TYPE_DATA	},
+	{ CF_TYPE_INTERFACE_MARKUP,		"data" DIR_SEPARATOR_STR "interface" DIR_SEPARATOR_STR "markup",			".rml",								CF_TYPE_INTERFACE	},
+	{ CF_TYPE_INTERFACE_CSS,		"data" DIR_SEPARATOR_STR "interface" DIR_SEPARATOR_STR "css",				".rcss",							CF_TYPE_INTERFACE	},
+	{ CF_TYPE_PLAYER_BINDS,			"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "presets",				".json",							CF_TYPE_PLAYERS	},
 };
 // clang-format on

+#define CFILE_STACK_MAX	8

 int cfile_inited = 0;
+static int Cfile_stack_pos = 0;

-static SCP_vector<SCP_string> Cfile_stack;
+static char Cfile_stack[CFILE_STACK_MAX][CFILE_ROOT_DIRECTORY_LEN];

 std::array<CFILE, MAX_CFILE_BLOCKS> Cfile_block_list;

@@ -106,6 +114,12 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* original_filename, FILE *fp, int type, size_t offset, size_t size);
 static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const char* original_filename, const void* data, size_t size, int dir_type);

+#if defined _WIN32
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const char* original_filename, HANDLE hFile, int type);
+#elif defined SCP_UNIX
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const char* original_filename, FILE *fp, int type);
+#endif
+
 static void cf_chksum_long_init();

 static void dump_opened_files()
@@ -315,21 +329,22 @@ static int _cfile_chdir(const char *new_dir, const char *cur_dir __UNUSED)
 */
 int cfile_push_chdir(int type)
 {
-	SCP_string dir;
+	char dir[CFILE_ROOT_DIRECTORY_LEN];
 	char OriginalDirectory[CFILE_ROOT_DIRECTORY_LEN];

 	_getcwd(OriginalDirectory, CFILE_ROOT_DIRECTORY_LEN - 1);

-	cf_create_default_path_string(dir, type, NULL);
+	Assert(Cfile_stack_pos < CFILE_STACK_MAX);

-	int rc = _cfile_chdir(dir.c_str(), OriginalDirectory);
-
-	// if success then push the original directory on to the stack
-	if (rc == 0) {
-		Cfile_stack.push_back(OriginalDirectory);
+	if (Cfile_stack_pos >= CFILE_STACK_MAX) {
+		return -1;
 	}

-	return rc;
+	strcpy_s(Cfile_stack[Cfile_stack_pos++], OriginalDirectory);
+
+	cf_create_default_path_string(dir, sizeof(dir) - 1, type, NULL);
+
+	return _cfile_chdir(dir, OriginalDirectory);
 }

 /**
@@ -352,16 +367,13 @@ int cfile_chdir(const char *dir)

 int cfile_pop_dir()
 {
-	if (Cfile_stack.empty())
+	Assert(Cfile_stack_pos);
+
+	if ( !Cfile_stack_pos )
 		return -1;

-	int rc = cfile_chdir(Cfile_stack.back().c_str());
-
-	Assertion(rc == 0, "Failed to chdir() to previous directory (%s)!", Cfile_stack.back().c_str());
-
-	Cfile_stack.pop_back();
-
-	return rc;
+	Cfile_stack_pos--;
+	return cfile_chdir(Cfile_stack[Cfile_stack_pos]);
 }

 // flush (delete all files in) the passed directory (by type), return the # of files deleted
@@ -430,7 +442,7 @@ int cfile_flush_dir(int dir_type)
 //    filename = name of filename or filepath to process
 //    ext = extension to add.  Must start with the period
 //    Returns: new filename or filepath with extension.
-const char *cf_add_ext(const char *filename, const char *ext)
+char *cf_add_ext(const char *filename, const char *ext)
 {
 	static char path[MAX_PATH_LEN];

@@ -457,26 +469,26 @@ const char *cf_add_ext(const char *filename, const char *ext)
 */
 int cf_delete(const char *filename, int path_type, uint32_t location_flags)
 {
-	SCP_string longname;
+	char longname[MAX_PATH_LEN];

 	Assert(CF_TYPE_SPECIFIED(path_type));

-	cf_create_default_path_string(longname, path_type, filename, location_flags);
+	cf_create_default_path_string(longname, sizeof(longname) - 1, path_type, filename, false, location_flags);

-	return (_unlink(longname.c_str()) != -1);
+	return (_unlink(longname) != -1);
 }


 // Same as _access function to read a file's access bits
 int cf_access(const char *filename, int dir_type, int mode)
 {
-	SCP_string longname;
+	char longname[MAX_PATH_LEN];

 	Assert( CF_TYPE_SPECIFIED(dir_type) );

-	cf_create_default_path_string(longname, dir_type, filename);
+	cf_create_default_path_string( longname, sizeof(longname)-1, dir_type, filename );

-	return access(longname.c_str(), mode);
+	return access(longname,mode);
 }


@@ -521,18 +533,18 @@ int cf_exists_full_ext(const char *filename, int dir_type, const int num_ext, co
 #ifdef _WIN32
 void cf_attrib(const char *filename, int set, int clear, int dir_type)
 {
-	SCP_string longname;
+	char longname[MAX_PATH_LEN];

 	Assert( CF_TYPE_SPECIFIED(dir_type) );

-	cf_create_default_path_string(longname, dir_type, filename);
+	cf_create_default_path_string( longname, sizeof(longname)-1, dir_type, filename );

-	FILE *fp = fopen(longname.c_str(), "rb");
+	FILE *fp = fopen(longname, "rb");
 	if (fp) {
 		fclose(fp);

-		DWORD z = GetFileAttributes(longname.c_str());
-		SetFileAttributes(longname.c_str(), z | (set & ~clear));
+		DWORD z = GetFileAttributes(longname);
+		SetFileAttributes(longname, z | (set & ~clear));
 	}

 }
@@ -543,13 +555,13 @@ int cf_rename(const char *old_name, const char *name, int dir_type)
 	Assert( CF_TYPE_SPECIFIED(dir_type) );

 	int ret_code;
-	SCP_string old_longname;
-	SCP_string new_longname;
+	char old_longname[_MAX_PATH];
+	char new_longname[_MAX_PATH];
 	
-	cf_create_default_path_string(old_longname, dir_type, old_name);
-	cf_create_default_path_string(new_longname, dir_type, name);
+	cf_create_default_path_string( old_longname, sizeof(old_longname)-1, dir_type, old_name );
+	cf_create_default_path_string( new_longname, sizeof(old_longname)-1, dir_type, name );

-	ret_code = rename(old_longname.c_str(), new_longname.c_str());
+	ret_code = rename(old_longname, new_longname );		
 	if(ret_code != 0){
 		switch(errno){
 		case EACCES :
@@ -593,7 +605,7 @@ void cf_create_directory(int dir_type, uint32_t location_flags)
 {
 	int num_dirs = 0;
 	int dir_tree[CF_MAX_PATH_TYPES];
-	SCP_string longname;
+	char longname[MAX_PATH_LEN];
 	struct stat statbuf;

 	Assertion( CF_TYPE_SPECIFIED(dir_type), "Invalid dir_type passed to cf_create_directory." );
@@ -611,10 +623,10 @@ void cf_create_directory(int dir_type, uint32_t location_flags)
 	int i;

 	for (i=num_dirs-1; i>=0; i-- )	{
-		cf_create_default_path_string(longname, dir_tree[i], nullptr, location_flags);
-		if (stat(longname.c_str(), &statbuf) != 0) {
-			mprintf(( "CFILE: Creating new directory '%s'\n", longname.c_str() ));
-			mkdir_recursive(longname.c_str());
+		cf_create_default_path_string(longname, sizeof(longname) - 1, dir_tree[i], nullptr, false, location_flags);
+		if (stat(longname, &statbuf) != 0) {
+			mprintf(( "CFILE: Creating new directory '%s'\n", longname ));
+			mkdir_recursive(longname);
 		}
 	}
 }
@@ -624,14 +636,19 @@ void cf_create_directory(int dir_type, uint32_t location_flags)
 // parameters:  *filepath ==> name of file to open (may be path+name)
 //              *mode     ==> specifies how file should be opened (eg "rb" for read binary)
 //                            passing NULL to mode triggers an assert and returns NULL
+//               type     ==> one of:    CFILE_NORMAL
+//                                       CFILE_MEMORY_MAPPED
 //					  dir_type	=>	override extension check, value is one of CF_TYPE* #defines
 //
+//               NOTE: type parameter is an optional parameter.  The default value is CFILE_NORMAL
+//
+//
 // returns:		success ==> address of CFILE structure
 //					error   ==> NULL
 //

-CFILE* _cfopen(const char* source, int line, const char* file_path, const char* mode, int dir_type,
-               bool /* localize */, uint32_t location_flags)
+CFILE* _cfopen(const char* source, int line, const char* file_path, const char* mode, int type, int dir_type,
+               bool localize, uint32_t location_flags)
 {
 	/* Bobboau, what is this doing here? 31 is way too short... - Goober5000
 	if( strlen(file_path) > 31 )
@@ -646,30 +663,35 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 	// Check that all the parameters make sense
 	Assert(file_path && strlen(file_path));
 	Assert( mode != NULL );
+	
+	// Can only open read-only binary files in memory mapped mode.
+	if ( (type & CFILE_MEMORY_MAPPED) && strcmp(mode,"rb") != 0 ) {
+		Int3();				
+		return NULL;
+	}

 	//===========================================================
 	// If in write mode, just try to open the file straight off
 	// the harddisk.  No fancy packfile stuff here!
 	
 	if ( strchr(mode,'w') || strchr(mode,'+') || strchr(mode,'a') )	{
-		SCP_string longname;
+		char longname[_MAX_PATH];
 		auto last_separator = strrchr(file_path, DIR_SEPARATOR_CHAR);

 		// For write-only files, require a full path or a path type
 		if ( last_separator ) {
 			// Full path given?
-			longname = file_path;
+			strcpy_s(longname, file_path );
 		} else {
 			// Path type given?
 			Assert( dir_type != CF_TYPE_ANY );
-			if (dir_type == CF_TYPE_ANY)
-				return NULL;

 			// Create the directory if necessary
 			cf_create_directory(dir_type, location_flags);

-			cf_create_default_path_string(longname, dir_type, file_path, location_flags);
+			cf_create_default_path_string(longname, sizeof(longname) - 1, dir_type, file_path, false, location_flags);
 		}
+		Assert( !(type & CFILE_MEMORY_MAPPED) );

 		// JOHN: TODO, you should create the path if it doesn't exist.
 		
@@ -706,7 +728,7 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 			strcpy_s(happy_mode, mode);
 		}

-		FILE *fp = fopen(longname.c_str(), happy_mode);
+		FILE *fp = fopen(longname, happy_mode);
 		if (fp)	{
 			return cf_open_fill_cfblock(source, line, last_separator ? (last_separator + 1) : file_path, fp, dir_type);
 		}
@@ -717,14 +739,40 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 	//================================================
 	// Search for file on disk, on cdrom, or in a packfile

-	auto find_res = cf_find_file_location(file_path, dir_type, location_flags);
+	char copy_file_path[MAX_PATH_LEN];  // FIX change in memory from cf_find_file_location
+	strcpy_s(copy_file_path, file_path);

+	auto find_res = cf_find_file_location( copy_file_path, dir_type, localize, location_flags );
 	if ( find_res.found ) {
+
 		// Fount it, now create a cfile out of it
 		nprintf(("CFileDebug", "Requested file %s found at: %s\n", file_path, find_res.full_name.c_str()));

-		// since cfopen_special already has all the code to handle the opening we can just use that here
-		return _cfopen_special(source, line, find_res, mode, dir_type);
+		if ( type & CFILE_MEMORY_MAPPED ) {
+		
+			// Can't open memory mapped files out of pack or memory files
+			if ( find_res.offset == 0 && find_res.data_ptr != nullptr )	{
+#if defined _WIN32
+				HANDLE hFile;
+
+				hFile = CreateFile(find_res.full_name.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+				if (hFile != INVALID_HANDLE_VALUE)	{
+					return cf_open_mapped_fill_cfblock(source, line, file_path, hFile, dir_type);
+				}
+#elif defined SCP_UNIX
+				FILE* fp = fopen(find_res.full_name.c_str(), "rb");
+				if (fp) {
+					return cf_open_mapped_fill_cfblock(source, line, file_path, fp, dir_type);
+				}
+#endif
+			} 
+
+		} else {
+			// since cfopen_special already has all the code to handle the opening we can just use that here
+			return _cfopen_special(source, line, find_res, mode, dir_type);
+		}
+
 	}

 	return NULL;
@@ -849,7 +897,27 @@ int cfclose( CFILE * cfile )
 	Assert(cfile != NULL);

 	result = 0;
-	if ( cfile->fp != nullptr )	{
+	if ( cfile->data && cfile->mem_mapped ) {
+		// close memory mapped file
+#if defined _WIN32
+		result = UnmapViewOfFile((void*)cfile->data);
+		Assert(result);
+		result = CloseHandle(cfile->hInFile);
+		Assert(result);	// Ensure file handle is closed properly
+		result = CloseHandle(cfile->hMapFile);
+		Assert(result);	// Ensure file handle is closed properly
+		result = 0;
+#elif defined SCP_UNIX
+		// FIXME: result is wrong after munmap() but it is successful
+		//result = munmap(cfile->data, cfile->data_length);
+		//Assert(result);
+		// This const_cast is safe since the pointer returned by mmap was also non-const
+		munmap(const_cast<void*>(cfile->data), cfile->data_length);
+		if ( cfile->fp != nullptr)
+			result = fclose(cfile->fp);
+#endif
+
+	} else if ( cfile->fp != nullptr )	{
 		Assert(cfile->fp != nullptr);
 		result = fclose(cfile->fp);
 	} else {
@@ -894,6 +962,7 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 	} else {
 		CFILE *cfp = &Cfile_block_list[cfile_block_index];
 		cfp->data = nullptr;
+		cfp->mem_mapped = false;
 		cfp->fp = fp;
 		cfp->dir_type = type;
 		cfp->max_read_len = 0;
@@ -932,6 +1001,7 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* o

 		cfp->data = nullptr;
 		cfp->fp = fp;
+		cfp->mem_mapped = false;
 		cfp->dir_type = type;
 		cfp->max_read_len = 0;

@@ -946,6 +1016,70 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* o

 }

+
+
+// cf_open_mapped_fill_cfblock() will fill up a Cfile_block element in the Cfile_block_list[] array
+// for the case of a file being opened by cf_open_mapped();
+//
+// returns:   ptr CFILE structure.  
+//
+#if defined _WIN32
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const char* original_filename, HANDLE hFile, int type)
+#elif defined SCP_UNIX
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const char* original_filename, FILE *fp, int type)
+#endif
+{
+	int cfile_block_index;
+
+	cfile_block_index = cfget_cfile_block();
+	if ( cfile_block_index == -1 ) {
+#ifdef SCP_UNIX
+		fclose(fp);
+#endif
+		return NULL;
+	}
+	else {
+		CFILE *cfp = &Cfile_block_list[cfile_block_index];
+
+		cfp->max_read_len = 0;
+		cfp->fp = nullptr;
+		cfp->mem_mapped = true;
+#if defined _WIN32
+		cfp->hInFile = hFile;
+#endif
+		cfp->dir_type = type;
+
+		cfp->original_filename = original_filename;
+		cfp->source_file = source;
+		cfp->line_num = line;
+
+		cf_init_lowlevel_read_code(cfp, 0, 0, 0 );
+		
+#if defined _WIN32
+		cfp->hMapFile = CreateFileMapping(cfp->hInFile, NULL, PAGE_READONLY, 0, 0, NULL);
+		if (cfp->hMapFile == NULL) {
+			nprintf(("Error", "Could not create file-mapping object.\n")); 
+			return NULL;
+		} 
+	
+		cfp->data = (ubyte*)MapViewOfFile(cfp->hMapFile, FILE_MAP_READ, 0, 0, 0);
+		Assert( cfp->data != NULL );
+#elif defined SCP_UNIX
+		cfp->fp = fp;
+		cfp->data_length = filelength(fileno(fp));
+		cfp->data = mmap(nullptr,                        // start
+		                 cfp->data_length,    // length
+		                 PROT_READ,                // prot
+		                 MAP_SHARED,                // flags
+		                 fileno(fp),                // fd
+		                 0);                        // offset
+		Assert(cfp->data != nullptr);
+#endif
+
+		return cfp;
+	}
+}
+
 static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const char* original_filename, const void* data, size_t size, int dir_type)
 {
 	int cfile_block_index;
@@ -959,6 +1093,7 @@ static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const ch

 		cfp->max_read_len = 0;
 		cfp->fp = nullptr;
+		cfp->mem_mapped = false;
 		cfp->dir_type = dir_type;

 		cfp->original_filename = original_filename;
@@ -1104,17 +1239,15 @@ void cfread_string(char *buf, int n, CFILE *file)
 	} while (c != 0 );
 }

-void cfread_string_len(char *buf, int buffer_size, CFILE *file)
+void cfread_string_len(char *buf,int n, CFILE *file)
 {
 	int len;
 	len = cfread_int(file);
-	Assertion( (len <= buffer_size), "String cannot fit in buffer, len: %i, buffer: %i", len, buffer_size);
-	if (len) {
+	Assertion( (len < n), "len: %i, n: %i", len, n );
+	if (len)
 		cfread(buf, len, 1, file);
-		Assertion(len != buffer_size || buf[len - 1] == 0, "Unterminated string does not fit in buffer");
-	}

-	buf[MIN(len, buffer_size - 1)] = 0;
+	buf[len] = 0;
 }

 SCP_string cfread_string_len(CFILE *file)
@@ -1202,6 +1335,9 @@ int cfwrite_string_len(const char *buf, CFILE *file)
 int cfilelength(CFILE* cfile) {
 	Assert(cfile != NULL);

+	// TODO: return length of memory mapped file
+	Assert(!cfile->mem_mapped);
+
 	// cfile->size gets set at cfopen

 	// The rest of the code still uses ints, do an overflow check to detect cases where this fails
@@ -1594,7 +1730,7 @@ int cf_chksum_short(const char *filename, ushort *chksum, int max_size, int cf_t
 	*chksum = 0;

 	// attempt to open the file
-	cfile = cfopen(filename,"rt",cf_type);
+	cfile = cfopen(filename,"rt",CFILE_NORMAL,cf_type);
 	if(cfile == NULL){		
 		return 0;
 	}
@@ -1644,7 +1780,7 @@ int cf_chksum_long(const char *filename, uint *chksum, int max_size, int cf_type
 	*chksum = 0;

 	// attempt to open the file
-	cfile = cfopen(filename,"rt",cf_type);
+	cfile = cfopen(filename,"rt",CFILE_NORMAL,cf_type);
 	if(cfile == NULL){		
 		return 0;
 	}
@@ -1710,53 +1846,28 @@ int cfile_get_path_type(const SCP_string& dir)
 {
 	SCP_string buf = dir;

-	// remove leading and trailing slashes
-	if ( !buf.empty() ) {
-		auto start = buf.find_first_not_of("\\/");
-		auto end = buf.find_last_not_of("\\/");
-
-		if (start == SCP_string::npos) {
-			buf = "";
-		} else if ( (start > 0) || (end < buf.length()-1) ) {
-			buf = buf.substr(start, end-start+1);
-		}
+	// Remove trailing slashes; avoid buffer overflow on 1-char strings
+	while (buf.size() > 0 && (buf[buf.size() - 1] == '\\' || buf[buf.size() - 1] == '/')) {
+		buf.resize(buf.size() - 1);
 	}

-	if (buf.empty()) {
-		return CF_TYPE_ROOT;
+	// Remove leading slashes
+	while (buf.size() > 0 && (buf[0] == '\\' || buf[0] == '/')) {
+		buf = buf.substr(1);
 	}

 	// Use official DIR_SEPARATOR_CHAR
-	extern void normalize_directory_separators(SCP_string &str);
-	normalize_directory_separators(buf);
-
-	// identify path type
-	auto best_match = CF_TYPE_INVALID;
-
-	for (auto& Pathtype : Pathtypes) {
-		if ( !Pathtype.path ) {
-			continue;
-		}
-
-		// skip root, it should have been detected before getting here
-		if (Pathtype.index == CF_TYPE_ROOT) {
-			continue;
-		}
-
-		// don't allow unknown subdirs directly under data
-		if (Pathtype.index == CF_TYPE_DATA) {
-			if (buf == Pathtype.path) {
-				best_match = CF_TYPE_DATA;
-			}
-
-			continue;
-		}
-
-		// for everything else just find closest match, allowing for unknown subdirectories
-		if ( !strnicmp(buf.c_str(), Pathtype.path, strlen(Pathtype.path)) ) {
-			best_match = Pathtype.index;
+	for (char& c : buf) {
+		if (c == '\\' || c == '/') {
+			c = DIR_SEPARATOR_CHAR;
 		}
 	}

-	return best_match;
+	for (auto& Pathtype : Pathtypes) {
+		if (Pathtype.path != nullptr && buf == Pathtype.path) {
+			return Pathtype.index;
+		}
+	}
+
+	return CF_TYPE_INVALID;
 }
@@ -49,42 +49,50 @@ typedef struct {
 #define CF_TYPE_MODELS				5
 #define CF_TYPE_TABLES				6
 #define CF_TYPE_SOUNDS				7
-#define CF_TYPE_VOICE				8
-#define CF_TYPE_VOICE_BRIEFINGS		9
-#define CF_TYPE_VOICE_CMD_BRIEF		10
-#define CF_TYPE_VOICE_DEBRIEFINGS	11
-#define CF_TYPE_VOICE_PERSONAS		12
-#define CF_TYPE_VOICE_SPECIAL		13
-#define CF_TYPE_VOICE_TRAINING		14
-#define CF_TYPE_MUSIC				15
-#define CF_TYPE_MOVIES				16
-#define CF_TYPE_INTERFACE			17
-#define CF_TYPE_FONT				18
-#define CF_TYPE_EFFECTS				19
-#define CF_TYPE_HUD					20
-#define CF_TYPE_PLAYERS				21
-#define CF_TYPE_PLAYER_IMAGES		22
-#define CF_TYPE_SQUAD_IMAGES		23
-#define CF_TYPE_SINGLE_PLAYERS		24
-#define CF_TYPE_MULTI_PLAYERS		25
-#define CF_TYPE_PLAYER_BINDS		26
-#define CF_TYPE_CACHE				27
-#define CF_TYPE_MULTI_CACHE			28
-#define CF_TYPE_MISSIONS			29
-#define CF_TYPE_CONFIG				30
-#define CF_TYPE_DEMOS				31
-#define CF_TYPE_CBANIMS				32
-#define CF_TYPE_INTEL_ANIMS			33
-#define CF_TYPE_SCRIPTS				34
-#define CF_TYPE_FICTION				35
-#define CF_TYPE_FREDDOCS			36
+#define CF_TYPE_SOUNDS_8B22K		8
+#define CF_TYPE_SOUNDS_16B11K		9
+#define CF_TYPE_VOICE				10
+#define CF_TYPE_VOICE_BRIEFINGS		11
+#define CF_TYPE_VOICE_CMD_BRIEF		12
+#define CF_TYPE_VOICE_DEBRIEFINGS	13
+#define CF_TYPE_VOICE_PERSONAS		14
+#define CF_TYPE_VOICE_SPECIAL		15
+#define CF_TYPE_VOICE_TRAINING		16
+#define CF_TYPE_MUSIC				17
+#define CF_TYPE_MOVIES				18
+#define CF_TYPE_INTERFACE			19
+#define CF_TYPE_FONT				20
+#define CF_TYPE_EFFECTS				21
+#define CF_TYPE_HUD					22
+#define CF_TYPE_PLAYERS				23
+#define CF_TYPE_PLAYER_IMAGES		24
+#define CF_TYPE_SQUAD_IMAGES		25
+#define CF_TYPE_SINGLE_PLAYERS		26
+#define CF_TYPE_MULTI_PLAYERS		27
+#define CF_TYPE_CACHE				28
+#define CF_TYPE_MULTI_CACHE			29
+#define CF_TYPE_MISSIONS			30
+#define CF_TYPE_CONFIG				31
+#define CF_TYPE_DEMOS				32
+#define CF_TYPE_CBANIMS				33
+#define CF_TYPE_INTEL_ANIMS			34
+#define CF_TYPE_SCRIPTS				35
+#define CF_TYPE_FICTION				36
+#define CF_TYPE_FREDDOCS			37
+#define CF_TYPE_INTERFACE_MARKUP 38
+#define CF_TYPE_INTERFACE_CSS 39
+#define CF_TYPE_PLAYER_BINDS 40

 #define CF_MAX_PATH_TYPES                                                                                              \
-	37 // Can be as high as you'd like //DTP; yeah but beware alot of things uses CF_MAX_PATH_TYPES
+	41 // Can be as high as you'd like //DTP; yeah but beware alot of things uses CF_MAX_PATH_TYPES

 // TRUE if type is specified and valid
 #define CF_TYPE_SPECIFIED(path_type) (((path_type)>CF_TYPE_INVALID) && ((path_type)<CF_MAX_PATH_TYPES))

+// #define's for the type parameter in cfopen.  
+#define CFILE_NORMAL				0			// open file normally
+#define CFILE_MEMORY_MAPPED	(1<<0)	//	open file as a memory-mapped file
+
 #define CF_SORT_NONE	0
 #define CF_SORT_NAME 1
 #define CF_SORT_TIME 2
@@ -167,7 +175,7 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir=NULL);
 void cfile_close();

 // add an extension to a filename if it doesn't already have it
-const char *cf_add_ext(const char *filename, const char *ext);
+char *cf_add_ext(const char *filename, const char *ext);

 // return filename of a CFILE you called cfopen() successfully on.
 const char *cf_get_filename(const CFILE *cfile);
@@ -177,7 +185,7 @@ int cf_get_dir_type(const CFILE *cfile);

 // Opens the file.  If no path is given, use the extension to look into the
 // default path.  If mode is NULL, delete the file.
-CFILE* _cfopen(const char* source_file, int line, const char* filename, const char* mode,
+CFILE* _cfopen(const char* source_file, int line, const char* filename, const char* mode, int type = CFILE_NORMAL,
               int dir_type = CF_TYPE_ANY, bool localize = false, uint32_t location_flags = CF_LOCATION_ALL);
 #define cfopen(...) _cfopen(LOCATION, __VA_ARGS__) // Pass source location to the function

@@ -318,17 +326,15 @@ void cfread_vector(vec3d* vec, CFILE* file, vec3d* deflt = nullptr);
 // to n characters.
 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.
+ * @brief Read a fixed length string that is not null-terminated, with the length stored in file
 *
- * 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 n Size of pre-allocated array
 * @param file File to read from
 *
 * @note Appends NULL character to string (buf)
 */
-void cfread_string_len(char *buf,int buffer_size, CFILE *file);
+void cfread_string_len(char *buf,int n, CFILE *file);

 /**
 * @brief Read a string from the file where the length is stored in the file
@@ -373,7 +379,6 @@ struct CFileLocation {
 	SCP_string full_name;
 	size_t size          = 0;
 	size_t offset        = 0;
-	time_t m_time        = 0;
 	const void* data_ptr = nullptr;

 	explicit CFileLocation(bool found_in = false) : found(found_in) {}
@@ -388,7 +393,7 @@ struct CFileLocation {
 //         size        - File size
 //         offset      - Offset into pack file.  0 if not a packfile.
 // Returns: If not found returns 0.
-CFileLocation cf_find_file_location(const char* filespec, int pathtype,
+CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool localize = false,
                                    uint32_t location_flags = CF_LOCATION_ALL);

 struct CFileLocationExt : public CFileLocation {
@@ -412,7 +417,8 @@ struct CFileLocationExt : public CFileLocation {
 //         offset      - Offset into pack file.  0 if not a packfile.
 // Returns: If not found returns -1, else returns offset into ext_list.
 // (NOTE: This function is exponentially slow, so don't use it unless truely needed!!)
-CFileLocationExt cf_find_file_location_ext(const char* filename, const int ext_num, const char** ext_list, int pathtype);
+CFileLocationExt cf_find_file_location_ext(const char* filename, const int ext_num, const char** ext_list, int pathtype,
+                                           bool localize = false);

 // Functions to change directories
 int cfile_chdir(const char *dir);
@@ -149,6 +149,9 @@ int cfseek( CFILE *cfile, int offset, int where )
 	if (cfile->compression_info.header != 0)
 		return comp_fseek(cfile, offset, where);

+	// TODO: seek to offset in memory mapped file
+	Assert( !cfile->mem_mapped );
+	
 	size_t goal_position;

 	switch( where )	{
@@ -38,6 +38,13 @@ struct CFILE {
 	int dir_type;        // directory location
 	FILE* fp;                // File pointer if opening an individual file
 	const void* data;            // Pointer for memory-mapped file access.  NULL if not mem-mapped.
+	bool mem_mapped; // Flag for memory mapped files (if data is not null and this is false it means that it's an embedded file)
+#ifdef _WIN32
+	HANDLE	hInFile;			// Handle from CreateFile()
+	HANDLE	hMapFile;		// Handle from CreateFileMapping()
+#else
+	size_t data_length;    // length of data for mmap
+#endif
 	size_t lib_offset;
 	size_t raw_position;
 	size_t size;                // for packed files
@@ -42,8 +42,8 @@ bool cf_check_location_flags(uint32_t check_flags, uint32_t desired_flags);
 // Output:  path      - Fully qualified pathname.
 //Returns 0 if result would be too long (invalid result)
 int cf_create_default_path_string(char* path, uint path_max, int pathtype, const char* filename = nullptr,
-                                  uint32_t location_flags = CF_LOCATION_ALL);
-int cf_create_default_path_string(SCP_string& path, int pathtype, const char* filename = nullptr,
+                                  bool localize = false, uint32_t location_flags = CF_LOCATION_ALL);
+int cf_create_default_path_string(SCP_string& path, int pathtype, const char* filename = nullptr, bool localize = false,
                                  uint32_t location_flags = CF_LOCATION_ALL);

 #endif	//_CFILESYSTEM_H
@@ -1,186 +0,0 @@
-#include "cheats_table.h"
-#include "parse/parselo.h"
-
-void cheat_table_init() {
-	customCheats.clear();
-
-	if (cf_exists_full("cheats.tbl", CF_TYPE_TABLES)) {
-		parse_cheat_table("cheats.tbl");
-	}
-	parse_modular_table("*-cht.tbm", parse_cheat_table);
-}
-
-bool CustomCheat::canUseCheat() {
-	return !requireCheatsEnabled || Cheats_enabled;
-}
-
-void CustomCheat::runCheat() {
-	if (!canUseCheat()) return;
-
-	//Only try to send the message if we actually have one to send and are in a mission
-	if (!cheatMsg.empty() && (Game_mode & GM_IN_MISSION))
-		HUD_printf("%s", cheatMsg.c_str());
-
-	scripting::hooks::OnCheat->run(scripting::hook_param_list(scripting::hook_param("Cheat", 's', cheatCode)));
-	CheatUsed = cheatCode;
-}
-
-void SpawnShipCheat::runCheat() {
-		CustomCheat::runCheat();
-
-		if (canUseCheat() && (Game_mode & GM_IN_MISSION) && Player_obj != nullptr) {
-			extern void prevent_spawning_collision(object *new_obj);
-			ship_subsys *ptr;
-			char name[NAME_LENGTH];
-			int ship_idx, ship_class; 
-
-			// if not found, then don't create it :(
-			ship_class = ship_info_lookup(shipClassName.c_str());
-			if (ship_class < 0)
-				return;
-
-			vec3d pos = Player_obj->pos;
-			matrix orient = Player_obj->orient;
-			pos.xyz.x += frand_range(-700.0f, 700.0f);
-			pos.xyz.y += frand_range(-700.0f, 700.0f);
-			pos.xyz.z += frand_range(-700.0f, 700.0f);
-
-			int objnum = ship_create(&orient, &pos, ship_class);
-			if (objnum < 0)
-				return;
-			
-			ship *shipp = &Ships[Objects[objnum].instance];
-			shipp->ship_name[0] = '\0';
-			shipp->display_name.clear();
-			for (size_t j = 0; j < Player_orders.size(); j++)
-				shipp->orders_accepted.insert(j);
-
-			// Goober5000 - stolen from support ship creation
-			// create a name for the ship with a number. look for collisions until one isn't found anymore
-			ship_idx = 1;
-			do {
-				sprintf(name, "%s %d", shipName.c_str(), ship_idx);
-				if ( (ship_name_lookup(name) == -1) && (ship_find_exited_ship_by_name(name) == -1) )
-				{
-					strcpy_s(shipp->ship_name, name);
-					break;
-				}
-
-				ship_idx++;
-			} while(1);
-
-			shipp->flags.set(Ship::Ship_Flags::Escort);
-			shipp->escort_priority = 1000 - ship_idx;
-
-			// now make sure we're not colliding with anyone
-			prevent_spawning_collision(&Objects[objnum]);
-
-			// Goober5000 - beam free
-			for (ptr = GET_FIRST(&shipp->subsys_list); ptr != END_OF_LIST(&shipp->subsys_list); ptr = GET_NEXT(ptr))
-			{
-				// mark all turrets as beam free
-				if (ptr->system_info->type == SUBSYSTEM_TURRET)
-				{
-					ptr->weapons.flags.set(Ship::Weapon_Flags::Beam_Free);
-					ptr->turret_next_fire_stamp = timestamp(Random::next(50, 4000));
-				}
-			}
-
-			// Cyborg17 to prevent a nullptr...
-			ship_set_warp_effects(&Objects[objnum]);
-			// warpin
-			shipfx_warpin_start(&Objects[objnum]);
-		}
-}
-
-void parse_cheat_table(const char* filename) {
-	try {
-		read_file_text(filename, CF_TYPE_TABLES);
-		reset_parse();
-		optional_string("#CUSTOM CHEATS");
-
-		while (optional_string("$Cheat:")) {
-			SCP_string code, msg, shipClass, shipName;
-			bool requireCheats = false;
-			bool shipSpawn = false;
-			required_string("+Code:");
-			stuff_string(code, F_RAW);
-
-			//We are limited to the buffer size used for the traditional cheats. We can still use short cheats, though.
-			if (code.length() > CHEAT_BUFFER_LEN) {
-				Warning(LOCATION, "Cheat code %s is too long. It will be cut off to maximum length (%i characters).", code.c_str(), CHEAT_BUFFER_LEN);
-				code = code.substr(0, CHEAT_BUFFER_LEN);
-			}
-
-			if (optional_string("+Message:")) {
-				stuff_string(msg, F_MESSAGE);
-			}
-
-			if (optional_string("+RequireCheats:")) {
-				stuff_boolean(&requireCheats);
-			}
-
-			if (optional_string("+SpawnShip:")) {
-				shipSpawn = true;
-				required_string("+Name:");
-				stuff_string(shipName, F_NAME);
-				required_string("+Class:");
-				stuff_string(shipClass, F_NAME);
-
-				int shipClassInfo = ship_info_lookup(shipClass.c_str());
-				if (shipClassInfo < 0) {
-					shipSpawn = false;
-					Warning(LOCATION, "There is no ship class named '%s'. The '%s' cheat won't summon a ship.", shipClass.c_str(), code.c_str());
-				}
-			}
-			
-			if (shipSpawn) {
-				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());
-					customCheats[code] = std::move(shipCheat);
-				} else {
-					customCheats.emplace(code, std::move(shipCheat));
-				}
-			} else {
-				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());
-					customCheats[code] = std::move(cheat);
-				} else {
-					customCheats.emplace(code, std::move(cheat));
-				}
-			}
-		}
-		required_string("#END");
-	}
-	catch (const parse::ParseException& e) {
-		mprintf(("TABLES: Unable to parse '%s'!  Error message = %s.\n", filename, e.what()));
-		return;
-	}
-}
-
-bool checkForCustomCheats(const char* buffer, int buffer_length) {
-	const char* check_buffer = buffer;
-	for (int i = 0; i < buffer_length; i++) {
-		if (*check_buffer == '\0') {
-			check_buffer++;
-		}
-		else {
-			break;
-		}
-	}
-
-	// Loop through our map of custom cheats and check if the code is within the buffer.
-	// We don't just check for equality, as the player may have typed other characters before the cheat.
-	for (auto &ccheat : customCheats) {
-		auto found = std::strstr(check_buffer, ccheat.first.c_str());
-		if (found != nullptr) {
-			ccheat.second->runCheat();
-			return true;
-		}
-	}
-	return false;
-}
@@ -1,49 +0,0 @@
-#include "globalincs/globals.h"
-#include "globalincs/pstypes.h"
-#include "globalincs/systemvars.h"
-#include "io/key.h"
-#include "hud/hudmessage.h"
-#include "hud/hudsquadmsg.h"
-#include "scripting/global_hooks.h"
-#include "scripting/hook_api.h"
-#include "ship/ship.h"
-#include "ship/shipfx.h"
-
-#define CHEAT_BUFFER_LEN	17
-
-class CustomCheat {
-	public:
-		SCP_string cheatCode;
-		SCP_string cheatMsg;
-		bool requireCheatsEnabled;
-
-		CustomCheat(SCP_string cheat_code, SCP_string cheat_msg, bool require_cheats_enabled) : 
-			cheatCode(std::move(cheat_code)),
-			cheatMsg(std::move(cheat_msg)),
-			requireCheatsEnabled(require_cheats_enabled) { }
-
-		virtual ~CustomCheat() = default;
-
-		virtual void runCheat();
-
-		bool canUseCheat();
-};
-
-class SpawnShipCheat : public CustomCheat {
-	protected:
-	SCP_string shipClassName;
-	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(cheat_code, cheat_msg, require_cheats_enabled),
-		shipClassName(std::move(class_name)),
-		shipName(std::move(ship_name)) { }
-
-	void runCheat() override;
-};
-
-static SCP_map<SCP_string, std::unique_ptr<CustomCheat>> customCheats;
-
-void cheat_table_init();
-void parse_cheat_table(const char* filename);
-bool checkForCustomCheats(const char* converted_buffer, int buffer_length);