Add system for reading flags from stdin

This adds support for reading flags from the standard input stream instead of from the command line. This allows more complex formats to be used such as JSON which is implemented in this first version. This can be used for implementing much more sophisticated ways of expressing complex data structures such as the mod command line.
2026-11-08 07:28:22 -10:00 · 2019-06-07 18:31:33 +02:00
1366 changed files with 38971 additions and 214651 deletions
@@ -1,28 +1,25 @@
 ---
 Language:        Cpp
-Standard: Cpp11
 # BasedOnStyle:  LLVM
 AccessModifierOffset: -2
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: true
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
+AlignEscapedNewlinesLeft: false
 AlignOperands:   true
 AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowAllArgumentsOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: Never
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
 BraceWrapping:   
  AfterClass:      false
  AfterControlStatement: false
@@ -53,17 +50,15 @@ ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
 IncludeBlocks: Regroup
 IncludeCategories:
  - Regex:           '^(<.*\.(h|hh|hpp)>)$' # Includes of external libraries
-    Priority:        5
-  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
-    Priority:        6
-  - Regex:           '^"globalincs\/.*\.h"$' # globalincs always come first
-    Priority:        1
-  - Regex:           '^"[^/]*\.(h)"$' # Local includes
-    Priority:        2
-  - Regex:           '^".*\.(h)"$' # standard engine includes
-    Priority:        3
-  - Regex:           '.*' # Catch all in case something is unhandled above
    Priority:        4
+  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
+    Priority:        5
+  - Regex:           '^"[^/]*\.(h)"$' # Local includes
+    Priority:        1
+  - Regex:           '^".*\.(h)"$' # standard engine includes
+    Priority:        2
+  - Regex:           '.*' # Catch all in case something is unhandled above
+    Priority:        3
 IncludeIsMainRegex: '$'
 IndentCaseLabels: false
 IndentWidth:     4
@@ -98,7 +93,8 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
+Standard:        Cpp11
 TabWidth:        4
-UseTab:          ForContinuationAndIndentation
+UseTab:          ForIndentation
 ...

@@ -1,31 +1,16 @@
 ---
 Checks: "-*,\
 modernize-*,\
-modernize-avoid-c-arrays,\
-modernize-make-unique,\
 -modernize-raw-string-literal,\
-modernize-use-trailing-return-type,\
 -modernize-use-using,\
+-modernize-make-unique,\
 performance-*,\
 -performance-type-promotion-in-math-fn,\
 misc-*,\
 -misc-macro-parentheses,\
 -misc-misplaced-widening-cast,\
-misc-non-private-member-variables-in-classes,\
 -misc-static-assert,\
-misc-unused-parameters,\
-readability-*,\
-readability-avoid-const-params-in-decls,\
-readability-else-after-return,\
-readability-function-size,\
-readability-identifier-naming,\
-readability-implicit-bool-conversion,\
-readability-inconsistent-declaration-parameter-name,\
-readability-isolate-declaration,\
-readability-magic-numbers,\
-readability-named-parameter,\
-readability-qualified-auto,\
-readability-uppercase-literal-suffix,\
+-modernize-make-unique,\
 "
 WarningsAsErrors: ''
 HeaderFilterRegex: 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$'
@@ -35,7 +20,5 @@ CheckOptions:
    value:        'assert,Assert,Assertion'
  - key:          'modernize-use-emplace.ContainersWithPushBack'
    value:        'std::vector;std::deque;std::list;SCP_vector;SCP_deque;SCP_list'
-  - key:          'readability-braces-around-statements.ShortStatementLines'
-    value:        '4' # Avoid flagging simple if (...) return false; statements
 ...

@@ -1,2 +0,0 @@
-/build
-/.git
@@ -5,11 +5,3 @@ indent_style = tab

 [*.sdr]
 indent_style = tab
-
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-[*.sh]
-indent_style = space
-indent_size = 4
@@ -1,7 +0,0 @@
-# Default for everything
-# * text=auto
-
-# For the test data and built-in files to make them consistent on all platforms
-*.tbl text eol=lf
-*.tbm text eol=lf
-*.sdr text eol=lf
@@ -1,8 +0,0 @@
-
-cmake/ @asarium
-
-code/executor/ @asarium
-
-code/scpui/ @asarium
-
-code/scripting/ @asarium
@@ -1,210 +0,0 @@
-name: Build Nightly package
-
-on:
-  push:
-    tags:
-      - 'nightly_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    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 }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          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-dd9d8cf
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    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: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          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:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
@@ -1,266 +0,0 @@
-name: Build Release package
-
-on:
-  push:
-    tags:
-      - 'release_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  create_release:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-      - name: Store upload URL
-        run: |
-          echo -n "${{ steps.create_release.outputs.upload_url }}" > upload_url
-      - name: Persist upload URL
-        uses: actions/upload-artifact@v2
-        with:
-          name: upload_url
-          path: ${{ github.workspace }}/upload_url
-
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    needs: create_release
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    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 }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          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-dd9d8cf
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download upload URL
-        uses: actions/download-artifact@v1
-        with:
-          name: upload_url
-          path: .
-      - name: Extract upload URL
-        id: extractUploadUrl
-        run: echo "::set-output name=upload_url::$(cat upload_url)"
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2, AVX]
-    needs: create_release
-    name: Windows
-    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: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          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:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2, AVX]
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download upload URL
-        uses: actions/download-artifact@v1
-        with:
-          name: upload_url
-          path: .
-      - name: Extract upload URL
-        id: extractUploadUrl
-        run: echo "::set-output name=upload_url::$(cat upload_url)"
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
-      - name: Upload debug symbols
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.debug_path }}
-          asset_name: ${{ steps.generate_package.outputs.debug_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
@@ -1,224 +0,0 @@
-name: Build Test package
-
-on:
-  push:
-    branches:
-      - 'test/*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
-    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 }}
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          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-dd9d8cf
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: 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: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          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:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
@@ -1,152 +0,0 @@
-name: Check a pull request
-
-on: [pull_request]
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        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-10
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          - configuration: Release
-            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-e977d36
-    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'
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        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: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang-')
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang-')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [MSVC]
-        arch: [Win32, x64]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - name: Prepare Environment
-        run: choco install ninja
-      - 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.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 }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-                  -DFSO_BUILD_FRED2="OFF" -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
-          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 "Visual Studio 16 2019" \
-                  -DFSO_BUILD_QTFRED=ON -T "v142" -A "$ARCHITECTURE" ..
-          fi
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake --build . --config "$CONFIGURATION"
-          else
-              cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          fi
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-             ./bin/unittests --gtest_shuffle
-          else
-              "./bin/$CONFIGURATION/unittests" --gtest_shuffle
-          fi
@@ -1,48 +0,0 @@
-name: Publish Standalone docker image
-
-on:
-  push:
-    tags:
-    - '*'
-
-jobs:
-  build_images:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        include:
-        - configuration: FastDebug
-          latest_tag: latest_debug
-          nightly_tag: nightly_debug
-          release_tag: release_debug
-        - configuration: Release
-          latest_tag: latest
-          nightly_tag: nightly
-          release_tag: release
-      fail-fast: false
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-      name: Checkout
-      with:
-        submodules: true
-    - name: Docker login
-      run: echo ${{ secrets.DOCKER_ACCESSTOKEN }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
-    - name: Docker build
-      run: docker build --build-arg build_type=${{ matrix.configuration }} -f docker/standalone/Dockerfile -t ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} .
-
-    - name: Push latest tag
-      run: |
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }}
-
-    - name: Push nightly tag
-      if: contains(github.ref, 'refs/tags/nightly_')
-      run: |
-        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
-
-    - name: Push release tag
-      if: contains(github.ref, 'refs/tags/release_')
-      run: |
-        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}
-        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}
@@ -257,4 +257,3 @@ CMakeSettings.json
 # This gets ignored by one of the rules above for some reason...
 !/code/scripting/lua/LuaConvert.h
 !/code/debugconsole/
-!/docker/build
@@ -1,6 +1,6 @@
 language: bash
 sudo: required
-dist: xenial
+dist: trusty
 cache:
  directories:
    - $HOME/cmake-3.8
@@ -18,6 +18,7 @@ addons:
      - libjansson-dev
      - libsdl2-dev
      - libfreetype6-dev
+      - valgrind
      - qt57base
  coverity_scan:
    project:
@@ -36,13 +37,13 @@ env:
    # 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="
+    # These declarations set FS2DOWNLOADS_USER and FS2DOWNLOADS_PASSWORD
+    - secure: "h6GbMX2jLsW1bS9fCM9fthOSJ1nfQQIRWi6EUH2p8u4NFLD5Bfi/C8JhQPKHUzyo3wvKkSHl+PsW7bgr1oXLusRwAur/dtv2N3imqvtbfIz305b00hZlsvbcYmQmUzQFSAdOGShK57JJ5aKQKccaUBP25KqB7Q+JaqBRdaMBS54="
+    - secure: "fUDAPAUUaaYZy8I4zU3SJ0JcK7aw4eb6eTdaEr7LyNyTMSfPgwY6P1MrbSQC0lJNQIUQ5ffjdxE5g7D7OYpoJF9L14ni4UY8t2QASt7kmpgcYihmjeuYy8FQXgmFG8CTxiWBPKTybZJ7voQcvIvRaNG7b2wM9PMfc5lRIondB6c="
 deploy:
  - provider: releases
    api_key:
-      secure: "q619+eQTe7lv8UVphK4OIzU8Jw84KBbVkuprN2sWIubRcV3IbZr2+WahJoUMt+nyhiy3YjDYtstO2ZgkxupwnZgwGUBVIiD1c4SPuyy+HTjNMOtiVsEUHT2hf+xPAemWpTlK5HcwhMmHAOh6rt6dEj57QOg0gcmGiwD/tCbEriA="
+      secure: "Wdt4Ccefo7a0ZDjEJQJgpghh7n72FtNJuKSAPUvoz4gtEX6Ct9J8yJI1t9V3jE3CTbbLJ21/Q6eZRDfT7UfNJe5DdepoJsP9DeFhKMWqQCq+AChqQWlm0KeZAffJoJreL8vXYhnRYcLT9ceZHEH6AqwN9TPV+xJziGPISAkYNZ8="
    skip_cleanup: true
    file_glob: true
    file: "/tmp/builds/*"
@@ -72,30 +73,33 @@ matrix:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
            - *global_deps
            - g++-5
    - os: linux
-      env: CONFIGURATION="Debug" CC=gcc-9 CXX=g++-9
+      env: CONFIGURATION="Debug" CC=gcc-8 CXX=g++-8
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
-            - g++-9
+            - g++-8
            - *global_deps
    - os: linux
-      env: CONFIGURATION="Debug" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      env: CONFIGURATION="Debug" CC=clang-4.0 CXX=clang++-4.0 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - llvm-toolchain-trusty-4.0
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
            - *global_deps
-            - g++-9
+            - clang-4.0
+            - clang-tidy-4.0
+            - libc++-dev
      script:
        - ./ci/travis/script.sh
        - ./ci/travis/clang_tidy.sh
@@ -103,7 +107,7 @@ matrix:
      env: CONFIGURATION="Debug"

    - os: windows
-      env: CONFIGURATION="Debug" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
+      env: CONFIGURATION="Debug" CMAKE_TOOLSET=v141_xp CMAKE_GENERATOR="Visual Studio 15 2017"
    - os: windows
      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"

@@ -113,44 +117,47 @@ matrix:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
            - *global_deps
            - g++-5
    - os: linux
-      env: CONFIGURATION="Release" CC=gcc-9 CXX=g++-9
+      env: CONFIGURATION="Release" CC=gcc-8 CXX=g++-8
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
-            - g++-9
+            - g++-8
            - *global_deps
    - os: linux
-      env: CONFIGURATION="Release" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      env: CONFIGURATION="Release" CC=clang-4.0 CXX=clang++-4.0
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+            - llvm-toolchain-trusty-4.0
+            - sourceline: 'ppa:beineri/opt-qt571-trusty'
          packages:
            - *global_deps
-            - g++-9
-      script:
-        - ./ci/travis/script.sh
-        - ./ci/travis/clang_tidy.sh
+            - clang-4.0
+            - libc++-dev
    - os: osx
      env: CONFIGURATION="Release"

    - os: windows
-      env: CONFIGURATION="Release" CMAKE_TOOLSET=v141 CMAKE_GENERATOR="Visual Studio 15 2017"
+      env: CONFIGURATION="Release" CMAKE_TOOLSET=v141_xp 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
+  # As long as Windows is still experimental on Travis CI, allow failures
  allow_failures:
+    - os: windows
+      env: CONFIGURATION="Debug" CMAKE_TOOLSET=v141_xp CMAKE_GENERATOR="Visual Studio 15 2017"
    - os: windows
      env: CONFIGURATION="Debug" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
+    - os: windows
+      env: CONFIGURATION="Release" CMAKE_TOOLSET=v141_xp CMAKE_GENERATOR="Visual Studio 15 2017"
    - os: windows
      env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
  fast_finish: true
@@ -0,0 +1,29 @@
+Original source (Freespace 2) by Volition, Inc.; see "credits.tbl"
+
+Modifications by the FreeSpace Source Code Project (FSSCP)
+http://fs2source.warpcore.org
+
+FS2_OPEN STAFF:
+
+Project leader:
+Edward "Inquisitor" Gardner
+
+Programmers:
+"Bobboau"
+Dennis "DTP" Pedersen
+Ian "Goober5000" Warfield
+Joe "Righteous1" Dowd
+Mike "penguin" Harris
+"Mysterial"
+"PhReAk"
+Thomas "Random Tiger" Whittaker
+Will "Unknown PLayer" Rousnel
+"WMCoolmon"
+
+Web support:
+Icefire and the staff at Volitionwatch.com
+Alex "Thunder" Avery and the staff at Hard Light Productions
+
+Special thanks to:
+Volition for making FS2 such a great game
+Dave Baranec for giving us the code and keeping us sanity checked
@@ -1,41 +0,0 @@
-## FreeSpace
-FreeSpace: The Great War (Released 1998) and FreeSpace 2 (1999) are mission-based space combat simulators, like X-Wing/TIE Fighter and Wing Commander. Among the greatest games of the genre, they were also effectively the last.
-
-The FreeSpace series follows humanity and their Vasudan allies as they fight to withstand the xenocidal, enigmatic Shivans, a species of unknown origin, vast technological capability, and seemingly limitless malice.
-
-## FreeSpace Open
-Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-
-## Hard-Light Productions
-HLP is a fan community built on love and open-source code. We're dedicated to bringing modders together and giving them a place to share their own hard work and draw inspiration from the work of others. Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-Find us at:
- - Our [website](http://www.hard-light.net/) and [forums](http://www.hard-light.net/forums/)
- - [Discord](https://discord.gg/YNVP3WR)
- - [Facebook](https://www.facebook.com/groups/Hardlightproductions/)
- - [Youtube](https://www.youtube.com/channel/UCxKkd609hDtY6yNetR1iT4w)
- - [Reddit](https://www.reddit.com/r/freespace/)
- - [Twitter](https://twitter.com/hardlightpro)
- - [IRC](irc://irc.esper.net/hard-light)
-
-
-## How to get the game
-FreeSpace Open requires a retail installation of FreeSpace 2, which is available at the following stores: 
- - [GOG.com](https://www.gog.com/game/freespace_2)
- - [Steam](https://store.steampowered.com/app/273620/Freespace_2/)  
-After installing retail FS2, use [Knossos](https://fsnebula.org/knossos/) to upgrade to the most recent release of FSO. Knossos is an advanced mod manager and launcher for FSO.
-
-## Improvements
-The new open source game engine has several distingushing features including:
- - Linux and Mac OS X support
- - OpenGL support
- - OpenAL audio support
- - Easy mod installation
- - OGG support
- - Hardware transform, clipping, and lighting
-
-## The FreeSpace Upgrade Project
-While the SCP improves the code of the game engine to enable new and exciting features, the FreeSpace Upgrade Project (FSU) creates material that takes advantage of the improved game engine.  
-The FSU improves the ships, effects, and background elements of FreeSpace 2. Every now and then these improvements are released as a pack called MediaVPs. These assorted improvements enhance the graphics of the game.  
-While the best way to experience the FSU is by playing the game with it, you can watch this [comparison video](https://www.youtube.com/watch?v=RM1YC_gK-qo) between 1999 and 2019 to have an idea of how much more beautiful FSU makes the game.
-
-^(Much of this content was pulled from existing sources, such as InsaneBaron's "What Is Hard Light Productions" [thread](https://www.hard-light.net/forums/index.php?topic=86650.0), the Wiki's [Getting Started article](https://wiki.hard-light.net/index.php/Getting_started) and more.) 
@@ -1,8 +0,0 @@
-Original source (Freespace 2) by Volition, Inc.; see "`credits.tbl`"
-
-Modifications by the FreeSpace 2 Source Code Project [(FSO SCP)](https://www.hard-light.net/forums/index.php?board=50.0)   
-[Project Contributors](https://github.com/scp-fs2open/fs2open.github.com/graphs/contributors)
-
-Special thanks to:
-Volition for making FS2 such a great game
-Dave Baranec for giving us the code and keeping us sanity checked
@@ -8,10 +8,9 @@ if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
 endif()

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

 # Set a few policies
-set_policy(CMP0051 NEW)
+set_policy(CMP0051 OLD)
 set_policy(CMP0053 NEW)
 set_policy(CMP0054 NEW)

@@ -118,14 +117,6 @@ option(FSO_INSTALL_DEBUG_FILES "Install some debug files (currently only PDB fil

 option(ENABLE_COTIRE "Enable cotire for faster compilation. Enabled by default." ON)

-option(FSO_RELEASE_LOGGING "Enable logging output for release builds" OFF)
-
-OPTION(FSO_BUILD_WITH_FFMPEG "Enable the usage of FFmpeg for sound and custscenes" ON)
-
-OPTION(FSO_BUILD_WITH_OPENGL "Enable compilation of the OpenGL renderer" 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)
 MARK_AS_ADVANCED(FORCE FSO_USE_OPENALSOFT)
@@ -134,10 +125,6 @@ MARK_AS_ADVANCED(FORCE FSO_DEVELOPMENT_MODE)
 MARK_AS_ADVANCED(FORCE FSO_FATAL_WARNINGS)
 mark_as_advanced(FORCE FSO_INSTALL_DEBUG_FILES)
 mark_as_advanced(FORCE ENABLE_COTIRE)
-mark_as_advanced(FORCE FSO_RELEASE_LOGGING)
-mark_as_advanced(FORCE FSO_BUILD_WITH_FFMPEG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL)
-mark_as_advanced(FORCE FSO_BUILD_WITH_VULKAN)

 # Include cotire file from https://github.com/sakra/cotire/
 include(cotire)
@@ -164,8 +151,6 @@ ADD_SUBDIRECTORY(tools)

 ADD_SUBDIRECTORY(lib)

-ADD_SUBDIRECTORY(parsers)
-
 ADD_SUBDIRECTORY(code)

 ADD_SUBDIRECTORY(freespace2)
@@ -212,7 +197,3 @@ ENDIF()
 message(STATUS "Building FSO tools: ${FSO_BUILD_TOOLS}")
 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 OpenGL: ${FSO_BUILD_WITH_OPENGL}")
-message(STATUS "With Vulkan: ${FSO_BUILD_WITH_VULKAN}")
@@ -0,0 +1,14 @@
+Volition Copyright (applies to original FreeSpace2 source code
+developed and released by Volition):
+
+"Copyright (C) Volition, Inc. 1999.  All rights reserved.
+
+All source code herein is the property of Volition, Inc. You may not
+sell or otherwise commercially exploit the source or things you
+created based on the source."
+
+
+Modifications by members of the FreeSpace Source Code Project are
+released under whatever terms the individual authors choose, but the
+above notice continues to apply to all fs2_open code.
+
@@ -1,131 +1,23 @@
-# Changelog
-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/).
-
-## [19.0.0] - 2020-01-25 ([Thread](https://www.hard-light.net/forums/index.php?topic=96226.0))
-### Meta
- With this release we decided to drop the "`3.Major_revision.Minor_revision`" versioning scheme in favor of a year based scheme since the Major and Minor versions did not have much meaning anymore. Instead the scheme will now be "`<year>.<number that is incremented every release>.0`". The last 0 is still there because some of our systems expect that. It will be gone at some point.
-### Added
- Full Unicode text support: You can now use non-ASCII characters without having to worry about special fonts and special characters. This is an opt-in mod flag.
- Translation features for making it easier to only distribute one version of a mod which includes all languages.
- OpenAL Soft is included by default in binary distributions of FSO now.
- System for dynamically adding new SEXPs. With this a Lua script can expose functionality to the mission which can be used exactly the same as a standard SEXP with all the usual editing features in FRED.   
- Support for displaying decals on the surface of an object.
- Integrated support for the [Discord Rich Presence API](https://discordapp.com/rich-presence). 
- New markup based user interface system using [libRocket](https://github.com/libRocket/libRocket).
-### Changed
- Exposed the movie player to the scripting API for advanced display features
- Various OpenGL optimizations for better graphics performance:
-  - Animations now use texture arrays
-  - Model uniforms get sent to the GPU using uniform buffers for less overhead
-  - Various other minor changes
- Converted pilot files from custom binary format to JSON
- Replaced Blinn-Phong BRDF with GGX BRDF
-### Fixed
- Refactored bitmap slot handling and removed the fixed upper limit on the number of bitmaps. No more bmpman corruption!
-
-## [3.8.0] - 2017-08-22 ([Release Thread](https://www.hard-light.net/forums/index.php?topic=93812.0))
-### Added
- Support for APNG animations: [APNG](https://en.wikipedia.org/wiki/APNG) is a variant of the established PNG format which allows to store animations instead of single frames in a PNG file. This change allows to use these animation files in FSO which significantly improves usability for modders since they no longer have to store all individual frames as separate images.
- Physically-Based Rendering (PBR): This upgrade of our rendering engine allows to use [PBR](https://en.wikipedia.org/wiki/Physically_based_rendering) assets to make models look more realistic and allow more artistic freedom for modders since they have more control over how a model looks. This also added support for HDR lighting which should improve the overall graphics experience.
- Native particle systems: Particles have always been supported by FSO but the effects that could be created by them were very limited. There were some attempts to fix this by using Lua scripting for more advanced features but that suffered from performance issues. With these new particle systems that feature has been integrated directly into the engine which should improve performance and allow for better effects in the future.
- TrueType Font support: [TrueType](https://en.wikipedia.org/wiki/TrueType) fonts improve the text rendering capabilities of FSO by allowing to use freely scaleable font faces instead of the previous bitmap fonts.
-### Changed
- We now use SDL2 on all platforms: SDL is a library for abstracting away the differences between different platforms. We now use SDL2 for all platforms which reduces the amount of platform-specific code tremendously and should result in better usability on all platforms. This was a major change that has been in development for several years. Here are a few key features that were added:
-  - Pilot and configuration data is now stored in the correct location across all platforms (this allows to run FSO on Windows from the Program Files directory without administrator rights)
-  - All platforms now use the ini files for storing settings. This fixes a lot of issues with the registry on Windows.
-  - Better support for input devices. Since SDL handles keyboard, mouse and joystick input we now have better support on newer OS versions. Note: This does not mean that we support multiple joysticks (yet). There is ongoing development effort to support this but this release does not have that yet.
- CMake build system generation: This isn't relevant for players but we are now using [CMake](https://en.wikipedia.org/wiki/CMake) for handling compiling our builds. This improves cross-platform support and allows to implement advanced compilation features across multiple platforms. Modders will like the new "FastDebug" builds which are like the previous "Debug" builds but are compiled with all the optimizations of normal Release builds. That should make modding a lot easier since you can now debug your mod with almost the same performance as a Release build.
- Improved shield effects: Rendering of the shields is now handled by special shaders which improves the overall quality of the effects and allows more freedom for future effects.
- Use OpenGL Core Profile for rendering: This is another major graphical upgrade which adds support for the OpenGL Core profile across all platforms (this was also made possible by the SDL2 integration). This upgrade allows us to use more modern rendering techniques and is especially useful for our Linux users who use the open-source Mesa drivers since our shaders failed to compile with those drivers. Now everyone will be able to enjoy the new graphical features added in this and previous releases. This also made some internal changes to how we handle rendering which improves the usability of our rendering engine within our code.
- Use FFmpeg for video & audio decoding: [FFmpeg](https://www.ffmpeg.org/) is a multi-media library which exposes functionality for decoding video and audio files to their raw form so that we can use that data. Thanks to this library we can now play 1080p cutscenes without any stuttering or frame-timing issues. It also allows to use more advanced audio and video codecs such as H.264 for video or Opus for audio.
-
-
-## [3.7.4] - 2016-07-04 ([Release thread](http://www.hard-light.net/forums/index.php?topic=92181.0))
-### Changed
- Major graphics update including deferred lighting and shadows
- Enhanced sound (up to 128 channels)
-### Fixed
- "Tons" of bugfixes
-
-## [3.7.2] - 2015-04-23 ([Release thread](http://www.hard-light.net/forums/index.php?topic=89597.0))
-### Added
- MediaVPS 2014 Support
- Autospread on model point shields
- WebUI based multiplayer standalone server (for non-Windows platforms)
- Toggle subsytem scanning, scannable, cargo revealed, hidden from sensors, stealth and friendly stealth added to the `alter-ship-flag` SEXP
- Support added to add more languages besides English, French, German and Polish, leading the way to better localization!
- `player-is-cheating` SEXP
- New ship flag to enable smarter AI use of afterburners. Now it can use them while flying waypoints or attacking capital ships (use the `free-afterburner-use` flag with `alter-ship-flag`)
- Experimental configurations to make AVX builds (see [this post](http://www.hard-light.net/forums/index.php?topic=85566.0) for more explanations)
- Frame profiling code, see what exactly is slowing down FreeSpace. (Mostly for devs or coders)
-### Changed
- Unstretched interface screens
- Automatically non stretched HUD gauges and simpler modder options for placing HUD gauges
- `show-subtitle-text` can now display messages as well as raw text
- Allow a user-specified number of credit images
- event.log can now snapshot events checked in a frame and record the status of an event the previous time it was checked as well as the current state
- Allow the specification of the positions of medals, callsigns and labels on the medal screen. 
- The number of medals is now dynamic!
- `is-facing` now works for things that aren't ships (like waypoints!) 
- allowing `fade-in` and `fade-out` sexps to use any color, not just black, white and red.
-
-
-## [3.7.0] - 2013-08-31 ([Release thread](http://www.hard-light.net/forums/index.php?topic=85435.0))
-### Major Change
- New Flexible Pilot Save File Code (combines single/multi pilots & allows safe switching between unfinished campaigns)
-### Changed
- Raised the per-model debris limit to 48 (previously 32).
- Increased the per-frame debris limit to 96 (previously 64)
-
-## [3.6.18] - 2013-03-01 ([Release thread](http://www.hard-light.net/forums/index.php?topic=83889.0))
-### Fixed
- Critical damage bug which caused heavy balance issues in the game
-
-## [3.6.16] - 2013-01-31 ([Release thread](http://www.hard-light.net/forums/index.php?topic=83577.0))
-### Added
- Diaspora TC support
-### Changed
- Performance Improvements
-
-## [3.6.14] - 2012-10-23 - ([Release thread](https://www.hard-light.net/forums/index.php?topic=82648.0))
-### Added
- Objecttype tables support for deciding how enemies respond to ship classes when disabled
- Allow modders to set a [mood](http://www.hard-light.net/forums/index.php?topic=81991.msg1639770#msg1639770) for builtin messages and then switch the mood for the mission on the fly using a SEXP
- Allow modders to set the chance of builtin messages being sent, how many will be sent per mission and how long is the delay between two messages
- Allow campaigns to be hidden in the campaign and tech rooms ([Game settings.tbl](https://wiki.hard-light.net/index.php/Game_settings.tbl#.23Ignored_Campaign_File_Names))
- Allow mods to set a default campaign ([Game settings.tbl](https://wiki.hard-light.net/index.php/Game_settings.tbl#.24Default_Campaign_File_Name:))
- New SEXPs
-  - `set-player-orders`
-  - `is-event\goal-true\false-msecs-delay`
-  - `get\set-num-countermeasures`
-  - `directive-value`
-  - `invalidate-all-arguments`
-  - `validate-all-arguments`
-  - `has-primary-weapon`
-  - `has-secondary-weapon`
-  - [`hud-display-gauge`](http://www.hard-light.net/forums/index.php?topic=68837.msg1361711#msg1361711)
-  - `get-object-speed-x`
-  - `get-object-speed-y`
-  - `get-object-speed-z`
-### Changed
- Major HUD gauges overhaul
- Split the Locked flag so that you can lock Ships or Weapons on the game loadout screen independently
- Mixed ammo for primary and secondary weapons - [`$Substitute`](http://www.hard-light.net/wiki/index.php/Weapons.tbl#.24Substitute:) - Allows you to have a weapon that fires other weapon ammo in a specific pattern (say a Gatling gun with tracers).
- [`show-subtitle`](https://wiki.hard-light.net/index.php/SCP_SEXPs#show-subtitle) SEXP supports custom fonts
- The active support ship limit per side is now dynamic.  See [`set-support-ship`](https://wiki.hard-light.net/index.php/SCP_SEXPs#set-support-ship) for more info.
-### Fixed
- Various multiplayer SEXP fixes
- `rotating-subsys-set-time` now accelerates properly
- [Fixed a whole heap of memory, logic and coding errors](http://www.hard-light.net/forums/index.php?topic=78044.0) -- using PVS-Studio: C/C++ source code analysis and checking tool
-
----
-
-## [Older Changes] - Unformatted
-```
 ChangeLog for fs2_open.  All times are UTC.  

+Features: September 2013
+http://www.hard-light.net/forums/index.php?topic=85700.0
+
+- show-subtitle-text can now display messages as well as raw text - Goober5000
+- toggle subsytem scanning, scannable, cargo revealed, hidden from sensors, stealth and friendly stealth added to the alter-ship-flag sexp - karajorma
+- Support added to add more languages besides English, French, German and Polish, leading the way to better localization! - karajorma
+- event.log can now snapshot events checked in a frame and record the status of an event the previous time it was checked as well as the current state - karajorma
+- added a player-is-cheating sexp - The E
+- allow a user-specified number of credit images - Goober5000
+- allow the specification of the positions of medals, callsigns and labels on the medal screen. - Goober5000
+- lua function to check if a ship is warp capable, and access to a ship's auto-aim FOV - zookeeper
+- is-facing now works for things that aren't ships (like waypoints!) - zookeeper
+- experimental configurations to make AVX builds (see this post for more explainations) - The E
+- new ship flag to enable smarter AI use of afterburners. Now it can use them while flying waypoints or attacking capital ships (use the free-afterburner-use flag with alter-ship-flag) - Admiral MS
+- the number of medals is now dynamic! - Goober5000
+- frame profiling code, see what exactly is slowing down FreeSpace. (Mostly for devs or coders) - Swifty + The E
+- allowing fade-in and fade-out sexps to use any color, not just black, white and red. - Goober5000
+
 ==================================================================
 ( massive gap in updates, maybe this will be filled in someday...)
 ==================================================================
@@ -459,7 +351,7 @@ ChangeLog for fs2_open.  All times are UTC.
 	(2.1.2.4), weapon/weapons.cpp (2.1.2.2):
 	
 	Sorted out some bits and pieces. The background nebula blends now
-	which is nice. – RT
+	which is nice. – RT

 2002-09-28 12:20  randomtiger

@@ -1994,4 +1886,3 @@ NOTE:

 # generated by cvs2cl.pl
 # cvs2cl.pl -r -S --utc -f ChangeLog2
-```
@@ -1,22 +0,0 @@
-Volition Copyright (applies to original FreeSpace2 source code
-developed and released by Volition):
-
->Copyright (C) Volition, Inc. 1999.  All rights reserved.
->
->All source code herein is the property of Volition, Inc. You may not
-sell or otherwise commercially exploit the source or things you
-created based on the source.
-
-
-Modifications by members of the FreeSpace Source Code Project are
-released under whatever terms the individual authors choose, but the
-above notice continues to apply to all fs2_open code.
-
-All modifications made on or after November 1, 2020, shall be released under 
-the terms within [Unlicense](Unlicense.md). Modifications made before said date are released 
-under the previous terms with the exception of modifications made by members 
-of the FreeSpace Source Code Project that opt-in to the terms of Unlicense. Additionally, 
-a list of contributors who have opted in to the Unlicense terms can be found 
-in [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing).
-
-See [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing) for more information.
@@ -0,0 +1,29 @@
+This is still in pretty rough form.
+
+
+=== for people building fs2_open:
+
+Win32-MSVC:
+Use the Freespace2.dsw workspace and build within the IDE.
+
+
+Win32-MinGW:
+  make
+
+
+Linux and other unix variants (NOT YET COMPLETE)
+  ./configure [options]
+  make
+
+
+
+=== for the project maintainers (people who need to 
+=== keep the makefiles up to date) and those building
+=== from CVS:
+
+./autogen.sh (should only has to be done once)
+./configure [options]
+make
+
+automake v1.6.1+ and
+autoconf v2.54+ are required
@@ -7,5 +7,36 @@ FreeSpace2 *S*ource *C*ode *P*roject
 Building
 --
 Before you do anything, make sure you have updated your git submodules, either by running `git submodule update --init --recursive` or by cloning the repository with the `--recursive` flag.<br/>
+<br/>
+For building you will need [CMake](http://www.cmake.org/cmake/resources/software.html). Version 3.4 is required. Once you have installed CMake you should create a build directory where the project/make files should be created, **do not create them inside the source tree!**<br>
+<br>
+On Windows you can use the `cmake-gui` executable to get a nice GUI, on Unix just use `cmake`. Use the newly created directory as build directory (change to this directory on Unix) and run cmake. On Windows this can be done by clicking the `Configure` button. Choose your compiler version and hit `Generate` when configuring is done. <br>
+Depending on the makefile generator used build the `all` or `ALL_BUILD` target to compile the project.<br>

-The main instructions for building can be found at our github wiki, on the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) page.
+### Available variables to control the build
+* `FSO_BUILD_WXFRED2`: Build the wxfred2 project, requires wxWidgets
+* `FSO_FREESPACE_PATH`: Sets the path of your FreeSpace install, can be used to automatically run the generated executables with the correct working directory, this is an optional variable. By default this will use the value of the `FS2PATH` environment variable.
+* `FSO_BUILD_TOOLS`: Build some tools related to FSO
+* `CMAKE_BUILD_TYPE`: Sets the binary build type between `Debug` and `Release` (default)
+
+#### Windows only variables
+* `FSO_BUILD_FRED2`: Build FRED2, requires a Visual Studio version that ships with MFC
+* `FSO_USE_SPEECH`: Build a binary with text-to-speech support
+* `FSO_USE_VOICEREC`: Build a binary with voice recognition support
+
+#### Advanced variables
+You should only use these variables if you know what you're doing
+* `FSO_CMAKE_DEBUG`: Print CMake debugging informations
+* `FSO_BUILD_INCLUDED_LIBS`: Build libraries from the included source
+* `FSO_USE_OPENALSOFT`: Use [OpenALSoft](http://kcat.strangesoft.net/openal.html) for OpenAL support
+* `FSO_USE_LUAJIT`: Use [luajit](http://luajit.org/) as a replacement for lua
+* `FSO_DEVELOPMENT_MODE`: Toggles some development behavior, only use if you really need it.
+* `FSO_RUN_ARGUMENTS`: If you run an executable from within the project, these arguments will also be passed to the executable
+* `FSO_BUILD_POSTFIX`: Sets a postfix to be added to the executable name, may be useful for release candidates.
+
+#### Visual Studio specific variables
+* `MSVC_USE_RUNTIME_DLL`: Use the DLL version of the runtime, experimental and not well tested.
+* `MSVC_SIMD_INSTRUCTIONS`: The instruction set the executables will be optimized for.
+
+### Generating an installation package
+CMake can automatically generate installation packages of the project. To do this you will just need to run the `package` target of the build system and the package will be placed inside your build directory. On Windows you will have to install [NSIS](http://nsis.sourceforge.net/Main_Page) to use this.
@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to [**Unlicense**](https://unlicense.org).
@@ -1,18 +0,0 @@
-#Updating Documentation
-####The goal of this file is simply to offer a comprehensive checklist of things we must check when updating the documentation.
-
-1. Changelog: 
- - Is [Changelog.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Changelog.md) up-to-date with the latest release?
- - Is it in the proper [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format? 
-2. Build instructions:  
- - If a programmer who never built FSO before read the build instruction at [Readme.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Readme.md), would they manage to build FSO? 
- - Is the information in the file up-to-date regarding other matters (such as versions of tools mentioned, links to other guides, etc.)?
- - Is the information in the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) article, and its sub-articles, still up-to-date?
-3. Forums: 
- - Does the [Forum](https://www.hard-light.net/forums/index.php?board=50.0) contain enough clear information to help a new developer find their way into the up-to-date instructions?
- - Is there anything that might mislead a new developer to stumble onto old tools, dead links and/or old versions of the project?
-4. General documentation files: 
- - Is the information in the following files up-to-date? 
-   - [About.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/About.md) (Should contain general information about FS, FS2, HLP, FSO and FSU)
-   - [Authors.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Authors.md) (Should contain information about the original developers, a way to see FSO's contributors, and special thanks to Volition and Dave Baranec)
-   - [Copying.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Copying.md) (Should contain Volition's Copyright terms and a way to check FSO's Licensing info)
@@ -8,11 +8,11 @@ environment:
  matrix:
    - BuildID: 0
      CMAKE_GENERATOR: Visual Studio 14 2015
-      PlatformToolset: v140
+      PlatformToolset: v140_xp
      QT_DIR: C:\Qt\5.9\msvc2015
    - BuildID: 1
      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
-      PlatformToolset: v140
+      PlatformToolset: v140_xp
      QT_DIR: C:\Qt\5.9\msvc2015_64
 before_build:
  - git submodule update --init --recursive
@@ -24,7 +24,7 @@ test_script:
 deploy:
    - provider: GitHub
      auth_token:
-          secure: h55Scpy+3vmo1Yb7WlSIGA4d9DRnsbzUYc2LYsQdByQHZHbqrqjBpicH0D2FFLEO
+          secure: 3kV4efHXwRnfXzmJPRAOs8D7+MhwXUXYeayI/P5y114L09kJa6b6L70beXdW7yYr
      on:
          ReleaseBuild: true        # deploy on release push only

@@ -40,23 +40,25 @@ deploy:
          NightlyBuild: true        # deploy on nightly push only

    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
+      protocol: ftp
+      host: swc.fs2downloads.com
+      username: 
+        secure: EXg2ADoKzMduZF90ip2Q0g==
      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$(VersionName)
+        secure: x0LL0uY9yBAQ7JTARhQ6AA==
+      folder: swc.fs2downloads.com/builds/nightly/$(VersionName)
+      beta: true
      on:
          NightlyBuild: true        # deploy on nightly push only

    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
+      protocol: ftp
+      host: swc.fs2downloads.com
+      username: 
+        secure: EXg2ADoKzMduZF90ip2Q0g==
      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$(VersionName)
+        secure: x0LL0uY9yBAQ7JTARhQ6AA==
+      folder: swc.fs2downloads.com/builds/test/$(VersionName)
+      beta: true
      on:
          TestBuild: true        # deploy on test build push only
@@ -9,56 +9,56 @@ class BuildConfig {
 }

 $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;
-#	}
+	[BuildConfig]@{ 
+		Generator="Visual Studio 14 2015 Win64";
+		PackageType="Win64";
+		Toolset="v140_xp";
+		SimdType="SSE2";
+		QtDir="C:\Qt\5.9\msvc2015_64";
+		SourcePackage=$false;
+	},
+	[BuildConfig]@{ 
+		Generator="Visual Studio 14 2015";
+		PackageType="Win32";
+		Toolset="v140_xp";
+		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;
-#	}
+	[BuildConfig]@{
+		Generator="Visual Studio 14 2015";
+		PackageType="Win32";
+		Toolset="v140_xp";
+		SimdType="SSE2";
+		QtDir="C:\Qt\5.9\msvc2015";
+		SourcePackage=$true;
+	}
+	[BuildConfig]@{
+		Generator="Visual Studio 14 2015";
+		PackageType="Win32-AVX";
+		Toolset="v140_xp";
+		SimdType="AVX";
+		QtDir="C:\Qt\5.9\msvc2015";
+		SourcePackage=$false;
+	}
+	[BuildConfig]@{
+		Generator="Visual Studio 14 2015 Win64";
+		PackageType="Win64";
+		Toolset="v140_xp";
+		SimdType="SSE2";
+		QtDir="C:\Qt\5.9\msvc2015_64";
+		SourcePackage=$false;
+	}
+	[BuildConfig]@{
+		Generator="Visual Studio 14 2015 Win64";
+		PackageType="Win64-AVX";
+		Toolset="v140_xp";
+		SimdType="AVX";
+		QtDir="C:\Qt\5.9\msvc2015_64";
+		SourcePackage=$false;
+	}
 )

 $BuildConfigurations = $null
@@ -134,7 +134,6 @@ if ($DeployBuild) {
 	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")
@@ -146,11 +145,8 @@ if ($DeployBuild) {
    	}
 	}

-    7z a -xr'!*.pdb' "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
+    7z a "$($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" `
@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-#
-#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-ClangTidy Diff Checker
-======================
-
-This script reads input from a unified diff, runs clang-tidy on all changed
-files and outputs clang-tidy warnings in changed lines only. This is useful to
-detect clang-tidy regressions in the lines touched by a specific patch.
-Example usage for git/svn users:
-
-  git diff -U0 HEAD^ | clang-tidy-diff.py -p1
-  svn diff --diff-cmd=diff -x-U0 | \
-      clang-tidy-diff.py -fix -checks=-*,modernize-use-override
-
-"""
-
-import argparse
-import glob
-import json
-import multiprocessing
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import threading
-import traceback
-
-try:
-    import yaml
-except ImportError:
-    yaml = None
-
-is_py2 = sys.version[0] == '2'
-
-if is_py2:
-    import Queue as queue
-else:
-    import queue as queue
-
-
-def run_tidy(task_queue, lock, timeout):
-    watchdog = None
-    while True:
-        command = task_queue.get()
-        try:
-            proc = subprocess.Popen(command,
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE)
-
-            if timeout is not None:
-                watchdog = threading.Timer(timeout, proc.kill)
-                watchdog.start()
-
-            stdout, stderr = proc.communicate()
-
-            with lock:
-                sys.stdout.write(stdout.decode('utf-8'))
-                sys.stdout.flush()
-                if stderr:
-                    sys.stderr.write(stderr.decode('utf-8'))
-                    sys.stderr.flush()
-        except Exception as e:
-            with lock:
-                sys.stderr.write('Failed: ' + str(e) + ': '.join(command) + '\n')
-        finally:
-            with lock:
-                if (not timeout is None) and (not watchdog is None):
-                    if not watchdog.is_alive():
-                        sys.stderr.write('Terminated by timeout: ' +
-                                         ' '.join(command) + '\n')
-                    watchdog.cancel()
-            task_queue.task_done()
-
-
-def start_workers(max_tasks, tidy_caller, task_queue, lock, timeout):
-    for _ in range(max_tasks):
-        t = threading.Thread(target=tidy_caller, args=(task_queue, lock, timeout))
-        t.daemon = True
-        t.start()
-
-def merge_replacement_files(tmpdir, mergefile):
-    """Merge all replacement files in a directory into a single file"""
-    # The fixes suggested by clang-tidy >= 4.0.0 are given under
-    # the top level key 'Diagnostics' in the output yaml files
-    mergekey = "Diagnostics"
-    merged = []
-    for replacefile in glob.iglob(os.path.join(tmpdir, '*.yaml')):
-        content = yaml.safe_load(open(replacefile, 'r'))
-        if not content:
-            continue # Skip empty files.
-        merged.extend(content.get(mergekey, []))
-
-    if merged:
-        # MainSourceFile: The key is required by the definition inside
-        # include/clang/Tooling/ReplacementsYaml.h, but the value
-        # is actually never used inside clang-apply-replacements,
-        # so we set it to '' here.
-        output = { 'MainSourceFile': '', mergekey: merged }
-        with open(mergefile, 'w') as out:
-            yaml.safe_dump(output, out)
-    else:
-        # Empty the file:
-        open(mergefile, 'w').close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=
-                                     'Run clang-tidy against changed files, and '
-                                     'output diagnostics only for modified '
-                                     'lines.')
-    parser.add_argument('-clang-tidy-binary', metavar='PATH',
-                        default='clang-tidy',
-                        help='path to clang-tidy binary')
-    parser.add_argument('-p', metavar='NUM', default=0,
-                        help='strip the smallest prefix containing P slashes')
-    parser.add_argument('-regex', metavar='PATTERN', default=None,
-                        help='custom pattern selecting file paths to check '
-                             '(case sensitive, overrides -iregex)')
-    parser.add_argument('-iregex', metavar='PATTERN', default=
-    r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
-                        help='custom pattern selecting file paths to check '
-                             '(case insensitive, overridden by -regex)')
-    parser.add_argument('-j', type=int, default=1,
-                        help='number of tidy instances to be run in parallel.')
-    parser.add_argument('-timeout', type=int, default=None,
-                        help='timeout per each file in seconds.')
-    parser.add_argument('-fix', action='store_true', default=False,
-                        help='apply suggested fixes')
-    parser.add_argument('-checks',
-                        help='checks filter, when not specified, use clang-tidy '
-                             'default',
-                        default='')
-    parser.add_argument('-path', dest='build_path',
-                        help='Path used to read a compile command database.')
-    if yaml:
-        parser.add_argument('-export-fixes', metavar='FILE', dest='export_fixes',
-                            help='Create a yaml file to store suggested fixes in, '
-                                 'which can be applied with clang-apply-replacements.')
-    parser.add_argument('-extra-arg', dest='extra_arg',
-                        action='append', default=[],
-                        help='Additional argument to append to the compiler '
-                             'command line.')
-    parser.add_argument('-extra-arg-before', dest='extra_arg_before',
-                        action='append', default=[],
-                        help='Additional argument to prepend to the compiler '
-                             'command line.')
-    parser.add_argument('-quiet', action='store_true', default=False,
-                        help='Run clang-tidy in quiet mode')
-    clang_tidy_args = []
-    argv = sys.argv[1:]
-    if '--' in argv:
-        clang_tidy_args.extend(argv[argv.index('--'):])
-        argv = argv[:argv.index('--')]
-
-    args = parser.parse_args(argv)
-
-    # Extract changed lines for each file.
-    filename = None
-    lines_by_file = {}
-    for line in sys.stdin:
-        match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
-        if match:
-            filename = match.group(2)
-        if filename is None:
-            continue
-
-        if args.regex is not None:
-            if not re.match('^%s$' % args.regex, filename):
-                continue
-        else:
-            if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
-                continue
-
-        match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
-        if match:
-            start_line = int(match.group(1))
-            line_count = 1
-            if match.group(3):
-                line_count = int(match.group(3))
-            if line_count == 0:
-                continue
-            end_line = start_line + line_count - 1
-            lines_by_file.setdefault(filename, []).append([start_line, end_line])
-
-    if not any(lines_by_file):
-        print("No relevant changes found.")
-        sys.exit(0)
-
-    max_task_count = args.j
-    if max_task_count == 0:
-        max_task_count = multiprocessing.cpu_count()
-    max_task_count = min(len(lines_by_file), max_task_count)
-
-    tmpdir = None
-    if yaml and args.export_fixes:
-        tmpdir = tempfile.mkdtemp()
-
-    # Tasks for clang-tidy.
-    task_queue = queue.Queue(max_task_count)
-    # A lock for console output.
-    lock = threading.Lock()
-
-    # Run a pool of clang-tidy workers.
-    start_workers(max_task_count, run_tidy, task_queue, lock, args.timeout)
-
-    # Form the common args list.
-    common_clang_tidy_args = []
-    if args.fix:
-        common_clang_tidy_args.append('-fix')
-    if args.checks != '':
-        common_clang_tidy_args.append('-checks=' + args.checks)
-    if args.quiet:
-        common_clang_tidy_args.append('-quiet')
-    if args.build_path is not None:
-        common_clang_tidy_args.append('-p=%s' % args.build_path)
-    for arg in args.extra_arg:
-        common_clang_tidy_args.append('-extra-arg=%s' % arg)
-    for arg in args.extra_arg_before:
-        common_clang_tidy_args.append('-extra-arg-before=%s' % arg)
-
-    for name in lines_by_file:
-        line_filter_json = json.dumps(
-            [{"name": name, "lines": lines_by_file[name]}],
-            separators=(',', ':'))
-
-        # Run clang-tidy on files containing changes.
-        command = [args.clang_tidy_binary]
-        command.append('-line-filter=' + line_filter_json)
-        if yaml and args.export_fixes:
-            # Get a temporary file. We immediately close the handle so clang-tidy can
-            # overwrite it.
-            (handle, tmp_name) = tempfile.mkstemp(suffix='.yaml', dir=tmpdir)
-            os.close(handle)
-            command.append('-export-fixes=' + tmp_name)
-        command.extend(common_clang_tidy_args)
-        command.append(name)
-        command.extend(clang_tidy_args)
-
-        task_queue.put(command)
-
-    # Wait for all threads to be done.
-    task_queue.join()
-
-    if yaml and args.export_fixes:
-        print('Writing fixes to ' + args.export_fixes + ' ...')
-        try:
-            merge_replacement_files(tmpdir, args.export_fixes)
-        except:
-            sys.stderr.write('Error exporting fixes.\n')
-            traceback.print_exc()
-
-    if tmpdir:
-        shutil.rmtree(tmpdir)
-
-
-if __name__ == '__main__':
-    main()
@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-COMMIT_RANGE=$1..$2
-
-if ! git rev-list $COMMIT_RANGE 2>&1 >/dev/null; then
-    echo "\$COMMIT_RANGE ($COMMIT_RANGE) is not valid for this build (probably caused by a rebase)."
-    exit 0
-fi
-
-# In order to get a proper diff without irrelevant changes, we need to determine where we branched off from the base
-# branch
-BASE_COMMIT=$(git merge-base $1 $2)
-
-echo "Running clang-tidy on changed files"
-git diff -U0 --no-color "$BASE_COMMIT..$2" | \
-    $HERE/clang-tidy-diff.py -path "$(pwd)/build" -p1 \
-    -regex '(code(?!\/graphics\/shaders\/compiled)|freespace2|qtfred|test|build|tools)\/.*\.(cpp|h)' \
-    -clang-tidy-binary /usr/bin/clang-tidy-9 -j$(nproc) -export-fixes "$(pwd)/clang-fixes.yaml"
@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-if [ "$COMPILER" = "gcc-5" ]; then
-    export CC=gcc-5
-    export CXX=g++-5
-fi
-if [ "$COMPILER" = "gcc-10" ]; then
-    export CC=gcc-10
-    export CXX=g++-10
-fi
-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
-CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
-if [[ "$COMPILER" =~ ^clang.*$ ]]; then
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=ON"
-fi
-
-mkdir build
-cd build
-
-export CXXFLAGS
-export CFLAGS
-export LD_LIBRARY_PATH
-
-cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS \
-    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_BUILD_APPIMAGE=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-OS="$1"
-
-source $HERE/dist_functions.sh
-
-if [ "$OS" = "Linux" ]; then
-    tar -cvzf "$(get_package_name)-builds-Linux.tar.gz" *
-
-    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"
-elif [ "$OS" = "Windows" ]; then
-    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"
-
-    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"
-
-    7z a "$(get_package_name)-debug-$ARCH-$SIMD.7z" "*.pdb"
-
-    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.zip"
-    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.zip"
-else
-    echo "Invalid OS: $OS"
-fi
@@ -1,70 +0,0 @@
-function get_package_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "nightly_*" --exact-match)"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "release_*" --exact-match | sed 's/release_/fs2_open_/i')"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "test_${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function get_version_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "nightly_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^nightly_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "release_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^release_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function upload_files_to_sftp() {
-  # We need empty glob patterns to "disappear" in the for loop below since this will be run for different configurations
-  # where it may be possible that some of the file patterns will not be present
-  shopt -s nullglob
-
-  echo "cd $2/" > sftp_batch
-  echo "mkdir $(get_version_name)" >> sftp_batch
-  # Create directory but do not cause an error if it already exists
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1 || true
-
-  echo "cd $2/$(get_version_name)/" > sftp_batch
-  for file in *.tar.gz *.7z *.zip; do
-    echo "put $file" >> sftp_batch
-  done
-
-  echo "bye" >> sftp_batch
-
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1
-
-  rm sftp_batch
-}
-
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-INSTALL_FOLDER=$1
-
-# Install Freespace2 targets
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Unspecified -P cmake_install.cmake
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-FILENAME="$(find $INSTALL_FOLDER/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
-appimagetool -n $INSTALL_FOLDER "$INSTALL_FOLDER/$FILENAME"
-chmod +x "$INSTALL_FOLDER/$FILENAME"
-
-ls -al $INSTALL_FOLDER
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-export LD_LIBRARY_PATH=$(pwd)/bin/lib:$LD_LIBRARY_PATH
-
-if [ "$CONFIGURATION" = "Debug" ]; then
-    valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-        --suppressions="$HERE/valgrind.supp" ./bin/unittests --gtest_shuffle
-else
-    ./bin/unittests --gtest_shuffle
-fi
@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-UPLOAD_TYPE=$1
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-source $HERE/dist_functions.sh
-
-if [ "$UPLOAD_TYPE" = "nightly" ]; then
-    SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"
-
-    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@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/test"
-else
-    echo "Unknown upload type $UPLOAD_TYPE"
-    exit 1
-fi
@@ -1,163 +0,0 @@
-{
-   liblsan Invalid read
-   Memcheck:Addr8
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:*
-   obj:*
-   obj:*
-}
-{
-    Travis memleak
-    Memcheck:Leak
-    match-leak-kinds: definite
-    fun:malloc
-    fun:_dl_signal_error
-    fun:_dl_open
-    fun:dlopen_doit
-    fun:_dl_catch_error
-    fun:_dlerror_run
-    fun:dlopen@@GLIBC_2.2.5
-    obj:/usr/lib/x86_64-linux-gnu/libmirclient.so.7
-    fun:call_init.part.0
-    fun:call_init
-    fun:_dl_init
-    fun:dl_open_worker
-    fun:_dl_catch_error
-}
-{
-   CLang Lua unitialized value error
-   Memcheck:Cond
-   ...
-   fun:luaH_get
-   fun:lua_rawget
-   fun:_ZN12_GLOBAL__N_117ade_index_handlerEP9lua_State
-}
-{
-   False-positive uninitialized variable warning
-   Memcheck:Cond
-   fun:_Z23cf_check_location_flagsjj
-   fun:_Z29cf_create_default_path_stringPcjiPKcbj
-   ...
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing4Test3RunEv
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_signal_error
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-   obj:*
-   obj:*
-   fun:call_init.part.0
-   fun:call_init
-   fun:_dl_init
-   fun:dl_open_worker
-}
-{
-   dlopen leak
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_exception_create
-   fun:_dl_signal_error
-   fun:_dl_map_object
-   fun:dl_open_worker
-   fun:_dl_catch_exception
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_exception
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-}
@@ -3,14 +3,8 @@
 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
+    # Nothing to do here
+    :
 elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
    # Nothing to do here
    :
@@ -18,6 +18,10 @@ 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"

+    if [[ "$CC" =~ ^clang.*$ ]]; then
+        CXXFLAGS="$CXXFLAGS -stdlib=libc++"
+    fi
+
    export CXXFLAGS
    export CFLAGS
    CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+#
+#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+r"""
+ClangTidy Diff Checker
+======================
+
+This script reads input from a unified diff, runs clang-tidy on all changed
+files and outputs clang-tidy warnings in changed lines only. This is useful to
+detect clang-tidy regressions in the lines touched by a specific patch.
+Example usage for git/svn users:
+
+  git diff -U0 HEAD^ | clang-tidy-diff.py -p1
+  svn diff --diff-cmd=diff -x-U0 | \
+      clang-tidy-diff.py -fix -checks=-*,modernize-use-override
+
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+
+
+def main():
+  parser = argparse.ArgumentParser(description=
+                                   'Run clang-tidy against changed files, and '
+                                   'output diagnostics only for modified '
+                                   'lines.')
+  parser.add_argument('-clang-tidy-binary', metavar='PATH',
+                      default='clang-tidy',
+                      help='path to clang-tidy binary')
+  parser.add_argument('-p', metavar='NUM', default=0,
+                      help='strip the smallest prefix containing P slashes')
+  parser.add_argument('-regex', metavar='PATTERN', default=None,
+                      help='custom pattern selecting file paths to check '
+                      '(case sensitive, overrides -iregex)')
+  parser.add_argument('-iregex', metavar='PATTERN', default=
+                      r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
+                      help='custom pattern selecting file paths to check '
+                      '(case insensitive, overridden by -regex)')
+
+  parser.add_argument('-fix', action='store_true', default=False,
+                      help='apply suggested fixes')
+  parser.add_argument('-checks',
+                      help='checks filter, when not specified, use clang-tidy '
+                      'default',
+                      default='')
+  parser.add_argument('-path', dest='build_path',
+                      help='Path used to read a compile command database.')
+  parser.add_argument('-extra-arg', dest='extra_arg',
+                      action='append', default=[],
+                      help='Additional argument to append to the compiler '
+                      'command line.')
+  parser.add_argument('-extra-arg-before', dest='extra_arg_before',
+                      action='append', default=[],
+                      help='Additional argument to prepend to the compiler '
+                      'command line.')
+  parser.add_argument('-quiet', action='store_true', default=False,
+                      help='Run clang-tidy in quiet mode')
+  clang_tidy_args = []
+  argv = sys.argv[1:]
+  if '--' in argv:
+    clang_tidy_args.extend(argv[argv.index('--'):])
+    argv = argv[:argv.index('--')]
+
+  args = parser.parse_args(argv)
+
+  # Extract changed lines for each file.
+  filename = None
+  lines_by_file = {}
+  for line in sys.stdin:
+    match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
+    if match:
+      filename = match.group(2)
+    if filename == None:
+      continue
+
+    if args.regex is not None:
+      if not re.match('^%s$' % args.regex, filename):
+        continue
+    else:
+      if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
+        continue
+
+    match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
+    if match:
+      start_line = int(match.group(1))
+      line_count = 1
+      if match.group(3):
+        line_count = int(match.group(3))
+      if line_count == 0:
+        continue
+      end_line = start_line + line_count - 1;
+      lines_by_file.setdefault(filename, []).append([start_line, end_line])
+
+  if len(lines_by_file) == 0:
+    print("No relevant changes found.")
+    sys.exit(0)
+
+  line_filter_json = json.dumps(
+    [{"name" : name, "lines" : lines_by_file[name]} for name in lines_by_file],
+    separators = (',', ':'))
+
+  quote = "";
+  if sys.platform == 'win32':
+    line_filter_json=re.sub(r'"', r'"""', line_filter_json)
+  else:
+    quote = "'";
+
+  # Run clang-tidy on files containing changes.
+  command = [args.clang_tidy_binary]
+  command.append('-line-filter=' + quote + line_filter_json + quote)
+  if args.fix:
+    command.append('-fix')
+  if args.checks != '':
+    command.append('-checks=' + quote + args.checks + quote)
+  if args.quiet:
+    command.append('-quiet')
+  if args.build_path is not None:
+    command.append('-p=%s' % args.build_path)
+  command.extend(lines_by_file.keys())
+  for arg in args.extra_arg:
+      command.append('-extra-arg=%s' % arg)
+  for arg in args.extra_arg_before:
+      command.append('-extra-arg-before=%s' % arg)
+  command.extend(clang_tidy_args)
+
+  sys.exit(subprocess.call(' '.join(command), shell=True))
+
+if __name__ == '__main__':
+  main()
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -e
+
+if ! git rev-list $TRAVIS_COMMIT_RANGE 2>1 >/dev/null; then
+    echo "\$TRAVIS_COMMIT_RANGE ($TRAVIS_COMMIT_RANGE) is not valid for this build (probably caused by a rebase)."
+    exit 0
+fi
+
+cd "$TRAVIS_BUILD_DIR"
+
+echo "Running clang-tidy on changed files"
+git diff -U0 --no-color $TRAVIS_COMMIT_RANGE | \
+    $TRAVIS_BUILD_DIR/ci/travis/clang-tidy-diff.py -path "$TRAVIS_BUILD_DIR/build" -p1 \
+    -regex 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$|tools/.*' \
+    -clang-tidy-binary /usr/bin/clang-tidy-4.0 2>/dev/null | \
+    tee clang-tidy-output.txt
+
+if [[ -n $(grep "warning: " clang-tidy-output.txt) ]] || [[ -n $(grep "error: " clang-tidy-output.txt) ]]; then
+    echo "Errors or warnings were detected in the clang-tidy output!"
+    exit 1
+else
+    echo -e "\033[1;32m\xE2\x9C\x93 passed:\033[0m clang-tidy test succeeded";
+fi
@@ -77,13 +77,13 @@ 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
+        # Upload to fs2downloads
+        curl -k "ftp://swc.fs2downloads.com/swc.fs2downloads.com/builds/test/$VERSION_NAME/" --user "$FS2DOWNLOADS_USER:$FS2DOWNLOADS_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
+        # Upload to fs2downloads
+        curl -k "ftp://swc.fs2downloads.com/swc.fs2downloads.com/builds/nightly/$VERSION_NAME/" --user "$FS2DOWNLOADS_USER:$FS2DOWNLOADS_PASSWORD" -T "$file" --ftp-create-dirs
    fi
 done
@@ -1,11 +1,9 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh

 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/
@@ -13,7 +11,7 @@ if [ "$TRAVIS_OS_NAME" = "linux" ]; then
    	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
+	export PATH=$HOME/cmake-3.8/bin:$PATH
    
    cd $HOME
    
@@ -24,17 +22,6 @@ if [ "$TRAVIS_OS_NAME" = "linux" ]; then
        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
    
@@ -7,6 +7,7 @@ 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
@@ -18,7 +19,7 @@ elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
    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"
+        curl --upload-file build.log.tar.gz "https://transfer.sh/build.log.tar.gz"
        exit $XCODE_RET
    fi
 elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
@@ -0,0 +1,43 @@
+{
+   liblsan Invalid read
+   Memcheck:Addr8
+   obj:/usr/lib64/liblsan.so.0.0.0
+   obj:/usr/lib64/liblsan.so.0.0.0
+   obj:/usr/lib64/liblsan.so.0.0.0
+   obj:*
+   obj:*
+   obj:*
+}
+{
+    Travis memleak
+    Memcheck:Leak
+    match-leak-kinds: definite
+    fun:malloc
+    fun:_dl_signal_error
+    fun:_dl_open
+    fun:dlopen_doit
+    fun:_dl_catch_error
+    fun:_dlerror_run
+    fun:dlopen@@GLIBC_2.2.5
+    obj:/usr/lib/x86_64-linux-gnu/libmirclient.so.7
+    fun:call_init.part.0
+    fun:call_init
+    fun:_dl_init
+    fun:dl_open_worker
+    fun:_dl_catch_error
+}
+{
+   CLang Lua unitialized value error
+   Memcheck:Cond
+   ...
+   fun:luaH_get
+   fun:lua_rawget
+   fun:_ZN12_GLOBAL__N_117ade_index_handlerEP9lua_State
+}
+{
+   False-positive uninitialized variable warning
+   Memcheck:Cond
+   fun:_Z23cf_check_location_flagsjj
+   fun:_Z29cf_create_default_path_stringPcjiPKcbj
+   ...
+}
@@ -1,4 +1,4 @@
 #!/bin/sh
 HERE=$(dirname $(readlink -f "${0}"))
 export LD_LIBRARY_PATH="${HERE}"/lib:"$LD_LIBRARY_PATH"
-exec "${HERE}"/bin/$<TARGET_FILE_NAME:Freespace2> $@
+"${HERE}"/bin/$<TARGET_FILE_NAME:Freespace2> $@
@@ -4,6 +4,8 @@ include(WriteCompilerDetectionHeader)
 set(CMAKE_CXX_STANDARD_REQUIRED 11)
 set(CMAKE_CXX_STANDARD 11)

+set(REQUIRED_CXX_FEATURES cxx_rvalue_references cxx_nullptr)
+
 get_property(CMAKE_CXX_KNOWN_FEATURES GLOBAL PROPERTY CMAKE_CXX_KNOWN_FEATURES)

 write_compiler_detection_header(
@@ -1,114 +0,0 @@
-
-set(_EMBEDD_FILE_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
-
-function(target_embed_files _target)
-    set(options)
-    set(oneValueArgs RELATIVE_TO PATH_TYPE_PREFIX)
-    set(multiValueArgs FILES)
-    cmake_parse_arguments(EMBED "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if (NOT DEFINED EMBED_RELATIVE_TO)
-        set(EMBED_RELATIVE_TO "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-    if (NOT IS_ABSOLUTE "${EMBED_RELATIVE_TO}")
-        get_filename_component(EMBED_RELATIVE_TO "${EMBED_RELATIVE_TO}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-
-    foreach (file ${EMBED_FILES})
-        get_filename_component(_absoluteFile "${file}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-
-        file(RELATIVE_PATH _pathType "${EMBED_RELATIVE_TO}" "${_absoluteFile}")
-        get_filename_component(_pathType ${_pathType} DIRECTORY)
-        if (DEFINED EMBED_PATH_TYPE_PREFIX)
-            if (_pathType)
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}/${_pathType}")
-            else()
-                # Avoid trailing / when we are in the same directory
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}")
-            endif()
-        endif()
-
-        if (NOT _pathType)
-            # If it is still empty then we need to work around yet another annoying CMake behavior where it ignores
-            # "empty" property strings
-            set(_pathType ".")
-        endif()
-
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES "${_absoluteFile}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_BASE_DIR "${EMBED_RELATIVE_TO}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_PATH_TYPE "${_pathType}")
-    endforeach()
-endfunction()
-
-function(handle_embedded_files _target)
-    get_target_property(_filesToEmbed ${_target} EMBEDDED_FILES)
-    get_target_property(_baseDirs ${_target} EMBEDDED_FILES_BASE_DIR)
-    get_target_property(_pathTypes ${_target} EMBEDDED_FILES_PATH_TYPE)
-
-    SET(DEF_OUT_FILES)
-
-    set(INCLUDE_LIST)
-    set(ARRAY_ELEMENTS)
-
-    list(LENGTH _filesToEmbed _numFiles)
-
-    FOREACH(i RANGE ${_numFiles})
-        # Why must CMake always do the unexpected thing? The foreach variant includes the last index as opposed to every
-        # other sensible language which does not include it...
-        if (i GREATER_EQUAL _numFiles)
-            break()
-        endif()
-
-        list(GET _filesToEmbed ${i} _filePath)
-        list(GET _baseDirs ${i} _baseDir)
-        list(GET _pathTypes ${i} _pathType)
-
-        if (_pathType STREQUAL ".")
-            # Handle the workaround we had to do for empty path types
-            set(_pathType "")
-        endif()
-
-        file(RELATIVE_PATH _relativeFilePath "${_baseDir}" "${_filePath}")
-        SET(_outputBasePath "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/${_relativeFilePath}")
-
-        # For some reason this is needed...
-        get_filename_component(_outputDirectory ${_outputBasePath} DIRECTORY)
-        file(MAKE_DIRECTORY ${_outputDirectory})
-
-        # Retrieve the path type name from the relative path
-        file(TO_NATIVE_PATH "${_pathType}" _pathType)
-        if (MINGW)
-            # There is a bug in CMake where it thinks MinGW uses forward slashes for paths but we need backslashes for Windows builds
-            string(REPLACE "/" "\\" _pathType "${_pathType}")
-        endif()
-        # Properly escape back slashes in strings
-        string(REPLACE "\\" "\\\\" _pathType "${_pathType}")
-
-        get_filename_component(FILE_NAME "${_relativeFilePath}" NAME)
-
-        string(MAKE_C_IDENTIFIER "${_relativeFilePath}" FIELD_NAME)
-
-        set(HEADER_FILE "${_outputBasePath}.h")
-        set(SOURCE_FILE "${_outputBasePath}.cpp")
-
-        set(ALL_OUTPUTS "${HEADER_FILE}" "${SOURCE_FILE}")
-        set(FIELD_NAME "Embedded_${FIELD_NAME}")
-
-        set(INCLUDE_LIST "${INCLUDE_LIST}\n#include \"${HEADER_FILE}\"")
-        set(ARRAY_ELEMENTS "${ARRAY_ELEMENTS}\n\t{ \"${_pathType}\", \"${FILE_NAME}\" , ${FIELD_NAME} , ${FIELD_NAME}_size },")
-
-        add_custom_command(
-            OUTPUT ${ALL_OUTPUTS}
-            COMMAND embedfile "${_filePath}" "${_outputBasePath}" "${FIELD_NAME}"
-            MAIN_DEPENDENCY "${_filePath}"
-            COMMENT "Generating string file for ${_filePath}"
-        )
-
-        list(APPEND DEF_OUT_FILES ${ALL_OUTPUTS})
-    ENDFOREACH()
-
-    configure_file("${_EMBEDD_FILE_BASE_DIR}/embedded_files.inc.in" "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/embedded_files.inc")
-    target_include_directories(${_target} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/embedded_files")
-    target_sources(${_target} PRIVATE ${DEF_OUT_FILES})
-    source_group("Generated Files\\Embedded Files" FILES ${DEF_OUT_FILES})
-endfunction()
@@ -3,7 +3,7 @@ INCLUDE(util)

 MESSAGE(STATUS "Configuring UNIX specific things and stuff...")

-target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL _REENTRANT)
+target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL)

 # Set RPATH
 set(CMAKE_SKIP_BUILD_RPATH TRUE)
@@ -8,7 +8,7 @@ SET(WIN32_LIBS
 	odbccp32
 	vfw32
 	winmm
-	ws2_32
+	wsock32
 	psapi
 )

@@ -20,8 +20,8 @@ target_link_libraries(platform INTERFACE ${WIN32_LIBS})

 target_compile_definitions(platform INTERFACE WIN32 USE_OPENAL _WINDOWS)

-# Specify minimum Windows version for the headers (currently this is Vista)
-target_compile_definitions(platform INTERFACE NTDDI_VERSION=0x06000000 _WIN32_WINNT=0x0600)
+# Specify minimum Windows version for the headers (currently this is XP)
+target_compile_definitions(platform INTERFACE NTDDI_VERSION=0x05010000 _WIN32_WINNT=0x0501)

 SET(EXE_GUI_TYPE WIN32)
 set(PLATFORM_WINDOWS TRUE CACHE INTERNAL "" FORCE)
@@ -10,8 +10,8 @@ include(CheckSymbolExists)
 include(CheckCXXSymbolExists)
 include(CheckTypeSize)

-CHECK_INCLUDE_FILE("execinfo.h" SCP_HAVE_EXECINFO_H)
-CHECK_INCLUDE_FILE_CXX("cxxabi.h" SCP_HAVE_CXXAPI_H)
+CHECK_INCLUDE_FILE("execinfo.h" HAVE_EXECINFO_H)
+CHECK_INCLUDE_FILE_CXX("cxxabi.h" HAVE_CXXAPI_H)

 CHECK_TYPE_SIZE("max_align_t" MAX_ALIGN_T)

@@ -31,17 +31,18 @@ CHECK_TYPE_SIZE("U'b'" UNICODE_CHAR_LITERAL LANGUAGE CXX)
 set(CMAKE_REQUIRED_FLAGS)


-CHECK_FUNCTION_EXISTS(strcasecmp SCP_HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strncasecmp SCP_HAVE_STRNCASECMP)
+CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
+CHECK_FUNCTION_EXISTS(strncasecmp HAVE_STRNCASECMP)

-CHECK_FUNCTION_EXISTS(_stricmp SCP_HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strnicmp SCP_HAVE__STRNICMP)
+CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
+CHECK_FUNCTION_EXISTS(_strnicmp HAVE__STRNICMP)

-CHECK_FUNCTION_EXISTS(strlwr SCP_HAVE_STRLWR)
+CHECK_FUNCTION_EXISTS(strlwr HAVE_STRLWR)

-CHECK_INCLUDE_FILE("strings.h" SCP_HAVE_STRINGS_H)
+CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)

-check_symbol_exists(snprintf "stdio.h" SCP_HAVE_SNPRINTF)
+check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
+check_symbol_exists(_snprintf "stdio.h" HAVE__SNPRINTF)

 set(PLATFORM_CHECK_HEADER "${GENERATED_SOURCE_DIR}/platformChecks.h")
 CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/platformChecks.h.in "${PLATFORM_CHECK_HEADER}")
@@ -3,28 +3,29 @@
 #define __PLATFORM_CHECKS_H__
 #pragma once

-#cmakedefine SCP_HAVE_EXECINFO_H
-#cmakedefine SCP_HAVE_CXXAPI_H
-#cmakedefine SCP_HAVE_MAX_ALIGN_T
-#cmakedefine SCP_HAVE_STD_MAX_ALIGN_T
+#cmakedefine HAVE_EXECINFO_H
+#cmakedefine HAVE_CXXAPI_H
+#cmakedefine HAVE_MAX_ALIGN_T
+#cmakedefine HAVE_STD_MAX_ALIGN_T

-#cmakedefine01 HAVE_STD_IS_TRIVIALLY_COPYABLE
+#cmakedefine HAVE_STD_IS_TRIVIALLY_COPYABLE
+#cmakedefine HAVE_STD_IS_TRIVIALLY_COPYABLE_ARRAY

 #cmakedefine01 IS_64BIT

-#cmakedefine01 SCP_HAVE_STRCASECMP
-#cmakedefine01 SCP_HAVE_STRNCASECMP
-#cmakedefine01 SCP_HAVE__STRICMP
-#cmakedefine01 SCP_HAVE__STRNICMP
+#cmakedefine01 HAVE_STRCASECMP
+#cmakedefine01 HAVE_STRNCASECMP
+#cmakedefine01 HAVE__STRICMP
+#cmakedefine01 HAVE__STRNICMP

-#cmakedefine01 SCP_HAVE_STRLWR
+#cmakedefine01 HAVE_STRLWR

-#cmakedefine01 SCP_HAVE_STRINGS_H
+#cmakedefine01 HAVE_STRINGS_H

 #cmakedefine01 HAVE_CHAR32_T
 #cmakedefine01 HAVE_UNICODE_CHAR_LITERAL

-#cmakedefine01 SCP_HAVE_SNPRINTF
-#cmakedefine01 SCP_HAVE__SNPRINTF
+#cmakedefine01 HAVE_SNPRINTF
+#cmakedefine01 HAVE__SNPRINTF

 #endif // __PLATFORM_CHECKS_H__
@@ -7,8 +7,6 @@ MESSAGE(STATUS "Doing configuration specific to clang...")
 option(CLANG_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
 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 "-march=native -pipe")
 set(CXX_BASE_FLAGS "-march=native -pipe")
@@ -21,11 +19,6 @@ if(DEFINED ENV{CFLAGS})
 	set(C_BASE_FLAGS $ENV{CFLAGS})
 endif()

-if (CLANG_USE_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -stdlib=libc++")
-	target_link_libraries(compiler INTERFACE "c++" "c++abi")
-endif()
-
 # Initialize with an empty string to make sure we always get a clean start
 set(COMPILER_FLAGS "")

@@ -100,10 +93,6 @@ set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})

 set(CMAKE_EXE_LINKER_FLAGS "")

-if (CLANG_USE_LIBCXX)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
-endif()
-
 if (SANITIZE_FLAGS)
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}")
 endif()
@@ -118,14 +107,3 @@ endif()

 # 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)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()
-
-target_link_libraries(compiler INTERFACE m)
@@ -8,8 +8,6 @@ MESSAGE(STATUS "Doing configuration specific to gcc...")
 option(GCC_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
 option(GCC_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
 option(GCC_ENABLE_SANITIZE_UNDEFINED "Enable -fsanitize=undefined" OFF)
-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 "-march=native -pipe")
@@ -25,16 +23,6 @@ endif()

 # Initialize with an empty string to make sure we always get a clean start
 set(COMPILER_FLAGS "")
-set(LINKER_FLAGS "")
-
-if (GCC_USE_GOLD)
-	OPTION(GCC_INCREMENTAL_LINKING "Use incremental linking" OFF)
-	set(LINKER_FLAGS "${LINKER_FLAGS} -fuse-ld=gold")
-
-	if (GCC_INCREMENTAL_LINKING)
-		set(LINKER_FLAGS "${LINKER_FLAGS} -fno-use-linker-plugin -Wl,-z,norelro -Wl,--incremental")
-	endif()
-endif()

 # This is a slight hack since our flag setup is a bit more complicated
 _enable_extra_compiler_warnings_flags()
@@ -42,11 +30,9 @@ set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")

 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
-	# perform dead code elimination
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdata-sections -ffunction-sections")
-endif()
+# Place each function and data in its own section so the linker can
+# perform dead code elimination
+set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdata-sections -ffunction-sections")

 if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
 	# Force color diagnostics for Ninja generator
@@ -112,7 +98,7 @@ set(COMPILER_FLAGS_RELEASE "-O2 -Wno-unused-variable -Wno-unused-but-set-variabl

 set(COMPILER_FLAGS_DEBUG "-O0 -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}")

@@ -122,7 +108,7 @@ 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_EXE_LINKER_FLAGS "${LINKER_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "")

 IF (MINGW)
 	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static -static-libgcc -static-libstdc++ -Wl,--enable-auto-import")
@@ -135,25 +121,17 @@ endif()

 set(CMAKE_EXE_LINKER_FLAGS_RELEASE "")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-g")
-
-if (GCC_GENERATE_GDB_INDEX)
-	# For pure debug binaries, generate a gdb index for better debugging
-	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -Wl,--gdb-index")
-endif()
-
 IF(NOT MINGW)
 	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -rdynamic")
 	# Allow the linker to perform dead code elimination; this is considered
 	# experimental for COFF and PE formats and thus disabled for Windows builds
 	# (https://sourceware.org/binutils/docs/ld/Options.html)
-	if (NOT GCC_INCREMENTAL_LINKING AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
-	endif()
+	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
 ENDIF(NOT MINGW)

 IF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-zignore")
-ENDIF()
+	SET(CMAKE_EXE_LINKER_FLAGS "-Wl,-zignore")
+ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")

 if (FSO_FATAL_WARNINGS)
 	# Make warnings fatal if the right variable is set
@@ -162,12 +140,3 @@ endif()

 # 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)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()
@@ -37,23 +37,21 @@ set(WARNING_FLAGS
 	$<$<CONFIG:Release>:/wd4101> # In release mode there are unreferenced variables because debug needs them
 	/wd4995 # "'vsprintf': name was marked as #pragma deprecated" is being caused by our custom definition of vsprintf. I have no idea what causes this or how to fix it - m!m
 	/wd4723 # "potential divide by 0" is caused by some code that definitely will not divide by zero - m!m
-	/wd4121 # "alignment of a member was sensitive to packing" happens in a Windows header - m!m
 )

 target_compile_options(compiler INTERFACE ${WARNING_FLAGS})

 # Base
-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_C_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /WX- /Zc:forScope /Gd /EHsc /nologo /Zm200")
+set(CMAKE_CXX_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /WX- /Zc:forScope /Gd /EHsc /nologo /Zm200")

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

 # 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")
-# /DEBUG:FULL so that we get PDBs which is needed for debugging crashdumps
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/OPT:REF /LTCG /INCREMENTAL:NO /DEBUG:FULL")
+set(CMAKE_C_FLAGS_RELEASE "/GL /W2 /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
+set(CMAKE_CXX_FLAGS_RELEASE "/GL /W2 /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
+set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/OPT:REF /LTCG /INCREMENTAL:NO")
 set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "/LTCG")

 globally_enable_extra_compiler_warnings()
@@ -65,6 +63,8 @@ if (MSVC_RELEASE_DEBUGGING)
 		set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zo")
 		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zo")
 	endif()
+	
+	set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG")
 endif()

 IF(MSVC_USE_RUNTIME_DLL)
@@ -17,9 +17,6 @@ ELSE("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 	MESSAGE(STATUS "No special handling for this compiler present, good luck!")
 ENDIF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")

-find_package(Threads REQUIRED)
-target_link_libraries(compiler INTERFACE Threads::Threads)
-
 # Copy release settings to FastDebug
 set(CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_RELEASE}")
 set(CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_RELEASE}")
@@ -140,34 +140,14 @@ macro(set_if_not_defined VAR VALUE)
    endif()
 endmacro(set_if_not_defined)

-function(set_precompiled_header _target _headerPath)
-	if (COMMAND target_precompile_headers)
-		target_compile_definitions(${_target} PRIVATE CMAKE_PCH)
-		target_precompile_headers(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${_headerPath}>")
-	else()
-		if (ENABLE_COTIRE)
-			message("${_headerPath}")
-			set_target_properties(${_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${_headerPath}")
+macro(configure_cotire target)
+	if(ENABLE_COTIRE)
+		# Disable unity build as it doesn't work well for us
+		set_target_properties(${target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)

-			# Disable unity build as it doesn't work well for us
-			set_target_properties(${_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
-
-			cotire(${_target})
-		else()
-			if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/FI ${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-				target_compile_options(${_target} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${_headerPath}>")
-			ELSE()
-				MESSAGE("Unknown compiler for global includes. This will probably break the build.")
-			ENDIF()
-		endif()
+		cotire(${target})
 	endif()
-endfunction()
+endmacro(configure_cotire)

 macro(add_target_copy_files)
 	foreach(file ${ARGN})
@@ -204,7 +184,7 @@ function(detect_simd_instructions _out_var)
 endfunction()

 function (check_linker_flag _flag _out_var)
-	SET(CMAKE_REQUIRED_LINK_OPTIONS "${_flag}")
+	SET(CMAKE_REQUIRED_FLAGS "${_flag}")
 	CHECK_C_COMPILER_FLAG("" ${_out_var})
 endfunction(check_linker_flag)

@@ -218,22 +198,6 @@ function(suppress_warnings _target)
    endif()
 endfunction(suppress_warnings)

-# Suppresses warnings for the specified files
-function(suppress_file_warnings)
-	if (MSVC)
-		set_source_files_properties(
-				${ARGN}
-			PROPERTIES
-				COMPILE_FLAGS "/W0")
-	else()
-		# Assume everything else uses GCC style options
-		set_source_files_properties(
-				${ARGN}
-			PROPERTIES
-				COMPILE_FLAGS "-w")
-	endif()
-endfunction(suppress_file_warnings)
-

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

-set_if_not_defined(FSO_VERSION_MAJOR 20)
-set_if_not_defined(FSO_VERSION_MINOR 1)
-set_if_not_defined(FSO_VERSION_BUILD 0)
+set_if_not_defined(FSO_VERSION_MAJOR 3)
+set_if_not_defined(FSO_VERSION_MINOR 8)
+set_if_not_defined(FSO_VERSION_BUILD 1)

 # A numeric revision e.g. the CI build number
 set_if_not_defined(FSO_VERSION_REVISION 0)
@@ -49,4 +49,4 @@ IF (NOT "${FSO_BUILD_POSTFIX}" STREQUAL "")
 ENDIF()

 set(CONFIG_POSTFIX "$<$<CONFIG:Release>:>$<$<CONFIG:Debug>:-DEBUG>$<$<CONFIG:FastDebug>:-FASTDBG>")
-set(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}${CONFIG_POSTFIX}")
+set(FSO_BINARY_SUFFIX "${FSO_BINARY_SUFFIX}${CONFIG_POSTFIX}")
@@ -1,12 +1,13 @@

-include(util)
-
 INCLUDE(source_groups.cmake)
+
 INCLUDE(voice_rec.cmake)

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

-target_compile_features(code PUBLIC cxx_std_11)
+target_compile_features(code PUBLIC ${REQUIRED_CXX_FEATURES})
+
+INCLUDE(default_files.cmake)

 if (MSVC)
 	target_compile_definitions(code PUBLIC "PDB_DEBUGGING=1")
@@ -18,9 +19,7 @@ TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${FREESPACE_HEADERS})
 TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${GENERATED_SOURCE_DIR})
 TARGET_INCLUDE_DIRECTORIES(code PUBLIC ${GENERATED_SOURCE_DIR}/code)

-if (FSO_BUILD_WITH_OPENGL)
-	target_link_libraries(code PUBLIC OpenGL)
-endif()
+target_link_libraries(code PUBLIC OpenGL)

 TARGET_LINK_LIBRARIES(code PUBLIC openal)
 TARGET_LINK_LIBRARIES(code PUBLIC ${LUA_LIBS})
@@ -29,9 +28,7 @@ TARGET_LINK_LIBRARIES(code PUBLIC ${JPEG_LIBS})

 TARGET_LINK_LIBRARIES(code PUBLIC sdl2)

-if (FSO_BUILD_WITH_FFMPEG)
-	TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)
-endif()
+TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)

 TARGET_LINK_LIBRARIES(code PUBLIC utfcpp)

@@ -44,16 +41,6 @@ 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)
-
 enable_clang_tidy(code)

 IF (FSO_USE_SPEECH)
@@ -74,27 +61,24 @@ IF(FSO_BUILD_TOOLS)
 	ADD_SUBDIRECTORY(cfileextractor)
 ENDIF(FSO_BUILD_TOOLS)

-if (FSO_RELEASE_LOGGING)
-	target_compile_definitions(code PUBLIC SCP_RELEASE_LOGGING)
+if (ENABLE_COTIRE)
+	set_target_properties(code PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h")
+else()
+	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+		target_compile_options(code PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h>")
+	elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+		target_compile_options(code PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/FI ${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h>")
+	elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+		target_compile_options(code PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h>")
+	elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
+		target_compile_options(code PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-include${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h>")
+	ELSE()
+		MESSAGE("Unknown compiler for global includes. This will probably break the build.")
+	ENDIF()
 endif()

-if (FSO_BUILD_WITH_FFMPEG)
-	target_compile_definitions(code PUBLIC WITH_FFMPEG)
-endif()
-if (FSO_BUILD_WITH_OPENGL)
-	target_compile_definitions(code PUBLIC WITH_OPENGL)
-endif()
-if (FSO_BUILD_WITH_VULKAN)
-	target_compile_definitions(code PUBLIC WITH_VULKAN)
-endif()
-
-include(shaders.cmake)
-
-target_embed_files(code FILES ${default_files_files} RELATIVE_TO "def_files")
-
-handle_embedded_files(code)
-
-set_precompiled_header(code "${CMAKE_CURRENT_SOURCE_DIR}/prefix_header.h")
+include(util)
+configure_cotire(code)

 # Ensure that Xcode generates debug symbols on macOS for Debug builds
 set_target_properties(code PROPERTIES XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS[variant=Debug] "YES")
@@ -18,7 +18,8 @@
 #include "ship/ship.h"


-SCP_vector<char *> Goal_target_names;
+int Total_goal_target_names = 0;
+char Goal_target_names[MAX_GOAL_TARGET_NAMES][NAME_LENGTH];
 ai_info Ai_info[MAX_AI_INFO];
 ai_info *Player_ai;

@@ -36,7 +37,8 @@ int ai_get_slot(int shipnum)
 			return i;
 		}

-	Error( LOCATION, "Couldn't get AI slot, please tell a coder!");
+	Warning( LOCATION, "Couldn't get AI slot" );
+	Int3();

 	return -1;
 }
@@ -80,25 +82,22 @@ void set_wingnum(int objnum, int wingnum)
 	Ai_info[ai_index].wing = wingnum;
 }

-const char *ai_get_goal_target_name(const char *name, int *index)
+char *ai_get_goal_target_name(const char *name, int *index)
 {
-	Assertion(name != nullptr && index != nullptr, "Arguments cannot be null!");
+	Assert(name != NULL);
+	Assert(index != NULL);
+	int i;

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

-	*index = static_cast<int>(Goal_target_names.size());
-	Goal_target_names.push_back(vm_strdup(name));
-	return Goal_target_names[*index];
-}
-
-void ai_clear_goal_target_names()
-{
-	for (auto ptr : Goal_target_names)
-		vm_free(ptr);
-	Goal_target_names.clear();
+	Assert(Total_goal_target_names < MAX_GOAL_TARGET_NAMES);
+	Assertion(strlen(name) <= NAME_LENGTH - 1, "Goal target name %s is too long. Needs to be 31 characters or less.", name);
+	i = Total_goal_target_names++;
+	strcpy_s(Goal_target_names[i], name);
+	*index = i;
+	return Goal_target_names[i];
 }
@@ -70,7 +70,6 @@ extern ai_flag_name Ai_flag_names[];
 #define	AITTV_FAST					(1<<0)	//	Turn fast, not slowed down based on skill level.
 #define AITTV_VIA_SEXP				(1<<1)	//	Goober5000 - via sexp
 #define AITTV_IGNORE_BANK			(1<<2)	//	Goober5000 - ignore bank when turning
-#define AITTV_SLOW_BANK_ACCEL		(1<<3)  //  Asteroth - used by formation flying

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

@@ -84,7 +83,7 @@ typedef struct ai_goal {
 	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
+	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!)
@@ -94,17 +93,19 @@ typedef struct ai_goal {
 	// (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;
+		char	*name;
 		int	index;
 	} docker;
 	
 	union {
-		const char *name;
+		char	*name;
 		int	index;
 	} dockee;

 } ai_goal;

+#define	MAX_GOAL_TARGET_NAMES	100
+
 #define	AIM_CHASE				0
 #define	AIM_EVADE				1
 #define	AIM_GET_BEHIND			2
@@ -183,7 +184,6 @@ typedef struct ai_class {

 //	Submode definitions.
 //	Note: These need to be renamed to be of the form: AIS_mode_xxxx
-// Cyborg17 -- If you add submodes for AI_CHASE, you *have to* add entries to Submode_text[] in aicode.cpp
 #define	SM_CONTINUOUS_TURN	1	// takes parm: vector_id {0..3 = right, -right, up, -up}
 #define	SM_ATTACK				2
 #define	SM_EVADE_SQUIGGLE		3
@@ -472,8 +472,8 @@ typedef struct ai_info {
 	fix		avoid_check_timestamp;			//	timestamp at which to next check for having to avoid ship

 	vec3d	big_collision_normal;			// Global normal of collision with big ship.  Helps find direction to fly away from big ship.  Set for each collision.
-	vec3d	big_recover_1_direction;		//	A relative direction to fly towards when recovering from collision with a big ship, stage 1.
-	vec3d	big_recover_2_pos;				//	Global point to fly towards when recovering from collision with a big ship, stage 2.
+	vec3d	big_recover_pos_1;				//	Global point to fly towards when recovering from collision with a big ship, stage 1.
+	vec3d	big_recover_pos_2;				//	Global point to fly towards when recovering from collision with a big ship, stage 2.
 	int		big_recover_timestamp;			//	timestamp at which it's OK to re-enter stage 1.

 	int		abort_rearm_timestamp;			//	time at which this rearm should be aborted in a multiplayer game.
@@ -487,10 +487,7 @@ typedef struct ai_info {

 	flagset<AI::Maneuver_Override_Flags>	ai_override_flags;			// flags for marking ai overrides from sexp or lua systems
 	control_info	ai_override_ci;		// ai override control info
-	int		ai_override_lat_timestamp;		// mark for when to end the current lateral maneuver override
-	int		ai_override_rot_timestamp;		// mark for when to end the current rotational maneuver override
-
-	int form_obj_slotnum;               // for flying in formation object mode, the position in the formation
+	int		ai_override_timestamp;		// mark for when to end the current override
 } ai_info;

 // Goober5000
@@ -516,6 +513,8 @@ typedef struct {
 #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 int Total_goal_target_names;
+extern char Goal_target_names[MAX_GOAL_TARGET_NAMES][NAME_LENGTH];

 extern void update_ai_info_for_hit(int hitter_obj, int hit_obj);
 extern void ai_frame_all(void);
@@ -557,8 +556,7 @@ 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();
+char *ai_get_goal_target_name(const char *name, int *index);

 extern void init_ai_system(void);
 extern void ai_attack_object(object *attacker, object *attacked, ship_subsys *ssp, int ship_info_index = -1);
@@ -571,7 +569,7 @@ extern void ai_do_default_behavior(object *obj);
 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 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 ai_turn_towards_vector(vec3d *dest, object *objp, float turn_time, vec3d *slide_vec, vec3d *rel_pos, float bank_override, int flags, vec3d *rvec = nullptr, int sexp_flags = 0);
 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
@@ -584,7 +582,8 @@ extern void ai_update_danger_weapon(int objnum, int weapon_objnum);

 // called externally from MissionParse.cpp to position ships in wings upon arrival into the
 // mission.
-extern void get_absolute_wing_pos(vec3d *result_pos, object *leader_objp, int wingnum, int wing_index, bool formation_object_flag, bool autopilot = false);
+extern void get_absolute_wing_pos( vec3d *result_pos, object *leader_objp, int wing_index, int formation_object_flag);
+extern void get_absolute_wing_pos_autopilot( vec3d *result_pos, object *leader_objp, int wing_index, int formation_object_flag);

 //	Interface from goals code to AI.  Set ship to guard.  *objp guards *other_objp
 extern void ai_set_guard_object(object *objp, object *other_objp);
@@ -622,7 +621,7 @@ extern int might_collide_with_ship(object *obj1, object *obj2, float dot_to_enem
 extern int ai_fire_primary_weapon(object *objp);	//changed to return weather it fired-Bobboau
 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 void turn_towards_point(object *objp, vec3d *point, vec3d *slide_vec, float bank_override);
 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);

@@ -634,7 +633,7 @@ void set_predicted_enemy_pos_turret(vec3d *predicted_enemy_pos, vec3d *gun_pos,

 // function to change rearm status for ai ships (called from sexpression code)
 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_good_secondary_time( int team, int weapon_index, int num_weapons, char *shipname );

 extern void ai_do_objects_docked_stuff(object *docker, int docker_point, object *dockee, int dockee_point, bool update_clients = true);
 extern void ai_do_objects_undocked_stuff( object *docker, object *dockee );
@@ -667,6 +666,4 @@ void ai_update_aim(ai_info *aip);
 //SUSHI: Random evasive sidethrust
 void do_random_sidethrust(ai_info *aip, ship_info *sip);

-void ai_formation_object_recalculate_slotnums(int form_objnum, int exiting_objnum = -1);
-
 #endif
@@ -51,21 +51,14 @@ namespace AI {
 	};

 	FLAG_LIST(Maneuver_Override_Flags) {
-		Full_rot,	//	full sexp control over pitch/bank/heading rotation
+		Full,		//	Full sexp control
 		Roll,		//	Sexp forced roll maneuver
 		Pitch,		//	Sexp forced pitch change
 		Heading,	//	Sexp forced heading change
 		Full_lat,	//  full control over up/side/forward movement
-		Up,			//	Sexp forced vertical movement
-		Sideways,	//	Sexp forced horizontal movement
-		Forward,	//	Sexp forced forward movement
-
-		Dont_bank_when_turning,		// maps to CIF_DONT_BANK_WHEN_TURNING
-		Dont_clamp_max_velocity,	// maps to CIF_DONT_CLAMP_MAX_VELOCITY
-		Instantaneous_acceleration,	// maps to CIF_INSTANTANEOUS_ACCELERATION
-		Lateral_never_expire,       // don't clear the lateral maneuver when the timestamp is up
-		Rotational_never_expire,    // don't clear the rotational maneuver when the timestamp is up
-		Dont_override_old_maneuvers,// doesn't clear any previous maneuvers
+		Up,			//	vertical movement
+		Sideways,	//	horizontal movement
+		Forward,	//	forward movement

 		NUM_VALUES
 	};
@@ -86,17 +79,13 @@ namespace AI {
        Assist_scoring_scales_with_damage,
        Beams_damage_weapons,
        Big_ships_can_attack_beam_turrets_on_untargeted_ships,
-		Check_comms_for_non_player_ships,
        Disable_linked_fire_penalty,
-        Disable_player_secondary_doublefire,
-        Disable_ai_secondary_doublefire,
        Disable_weapon_damage_scaling,
        Dont_insert_random_turret_fire_delay,
        Fix_ai_class_bug,
        Fix_ai_path_order_bug,
        Fix_heat_seeker_stealth_bug,
        Fix_linked_primary_bug,
-		Fix_ramming_stationary_targets_bug,
        Force_beam_turret_fov,
 		Free_afterburner_use,
        Glide_decay_requires_thrust,
@@ -120,19 +109,13 @@ namespace AI {
        Smart_secondary_weapon_selection,
        Smart_shield_management,
        Smart_subsystem_targeting_for_turrets,
-        Strict_turret_tagged_only_targeting,
+        Strict_turred_tagged_only_targeting,
 		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,
        Use_additive_weapon_velocity,
        Use_newtonian_dampening,
        Use_only_single_fov_for_turrets,
-        No_turning_directional_bias,
-		Use_axial_turnrate_differences,
-		nonshielded_ships_can_manage_ets,
-		Better_collision_avoidance,
-		Require_exact_los,

 		NUM_VALUES
 	};
@@ -7,12 +7,11 @@



-#include "ai/ai_profiles.h"
-#include "ai/aibig.h"
+#include "globalincs/pstypes.h"
 #include "def_files/def_files.h"
+#include "ai/ai_profiles.h"
 #include "globalincs/pstypes.h"
 #include "localization/localize.h"
-#include "mod_table/mod_table.h"
 #include "parse/parselo.h"
 #include "ship/ship.h"
 #include "weapon/weapon.h"
@@ -372,16 +371,10 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$navigation subsystem governs warpout capability:", AI::Profile_Flags::Navigation_subsys_governs_warp);

-				set_flag(profile, "$check communications for non-player ships:", AI::Profile_Flags::Check_comms_for_non_player_ships);
-
 				set_flag(profile, "$ignore lower bound for minimum speed of docked ship:", AI::Profile_Flags::No_min_dock_speed_cap);

 				set_flag(profile, "$disable linked fire penalty:", AI::Profile_Flags::Disable_linked_fire_penalty);

-				set_flag(profile, "$disable player secondary doublefire:", AI::Profile_Flags::Disable_player_secondary_doublefire);
-
-				set_flag(profile, "$disable ai secondary doublefire:", AI::Profile_Flags::Disable_ai_secondary_doublefire);
-
 				set_flag(profile, "$disable weapon damage scaling:", AI::Profile_Flags::Disable_weapon_damage_scaling);

 				set_flag(profile, "$use additive weapon velocity:", AI::Profile_Flags::Use_additive_weapon_velocity);
@@ -398,8 +391,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$fix linked primary weapon decision bug:", AI::Profile_Flags::Fix_linked_primary_bug);

-				set_flag(profile, "$fix ramming stationary targets bug:", AI::Profile_Flags::Fix_ramming_stationary_targets_bug);
-
 				set_flag(profile, "$prevent turrets targeting too distant bombs:", AI::Profile_Flags::Prevent_targeting_bombs_beyond_range);

 				set_flag(profile, "$smart subsystem targeting for turrets:", AI::Profile_Flags::Smart_subsystem_targeting_for_turrets);
@@ -446,8 +437,6 @@ void parse_ai_profiles_tbl(const char *filename)

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

-				set_flag(profile, "$firing requires exact los:", AI::Profile_Flags::Require_exact_los);
-
 				profile->ai_path_mode = AI_PATH_MODE_NORMAL;
 				if (optional_string("$ai path mode:"))
 				{
@@ -465,7 +454,7 @@ void parse_ai_profiles_tbl(const char *filename)

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

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

 				set_flag(profile, "$aspect bomb invulnerability fix:", AI::Profile_Flags::Aspect_invulnerability_fix);

@@ -475,18 +464,6 @@ void parse_ai_profiles_tbl(const char *filename)

 				set_flag(profile, "$use actual primary range:", AI::Profile_Flags::Use_actual_primary_range);

-				if (optional_string("$override radius for subsystem path points:")) {
-					int path_radii;
-					stuff_int(&path_radii);
-					if (path_radii >= Minimum_subsystem_path_pt_dist) {
-						profile->subsystem_path_radii = path_radii;
-					} else {
-						mprintf(("Warning: \"$override radius for subsystem path points:\" should be >= %i (read %i). Value will not be used. ", Minimum_subsystem_path_pt_dist, path_radii));
-					}
-				}
-
-				set_flag(profile, "$use POF radius for subsystem path points:", AI::Profile_Flags::Use_subsystem_path_point_radii);
-
 				profile->bay_arrive_speed_mult = 1.0f;
 				profile->bay_depart_speed_mult = 1.0f;
 				if (optional_string("$bay arrive speed multiplier:")) {
@@ -513,21 +490,7 @@ void parse_ai_profiles_tbl(const char *filename)
 					stuff_boolean(&temp);
                    profile->flags.set(AI::Profile_Flags::Allow_primary_link_at_start, !temp);
 				}
-				if (optional_string("$lead indicator second-order prediction factor:")) {
-					stuff_float(&profile->second_order_lead_predict_factor);
-					if (profile->second_order_lead_predict_factor > 1 || profile->second_order_lead_predict_factor < 0) {
-						mprintf(("Warning: \"$lead indicator second-order prediction factor\" must be 0 - 1, resetting to 0.\"\n"));
-						profile->second_order_lead_predict_factor = 0;
-					}
-				}

-                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, "$ships with no shields can manage ETS:", AI::Profile_Flags::nonshielded_ships_can_manage_ets);
-
-				set_flag(profile, "$better combat collision avoidance for fightercraft:", AI::Profile_Flags::Better_collision_avoidance);

 				// if we've been through once already and are at the same place, force a move
 				if (saved_Mp && (saved_Mp == Mp))
@@ -554,6 +517,10 @@ void parse_ai_profiles_tbl(const char *filename)
 		mprintf(("TABLES: Unable to parse '%s'!  Error message = %s.\n", (filename) ? filename : "<default ai_profiles.tbl>", e.what()));
 		return;
 	}
+
+	// add tbl/tbm to multiplayer validation list
+	extern void fs2netd_add_table_validation(const char *tblname);
+	fs2netd_add_table_validation(filename);
 }

 void ai_profiles_init()
@@ -601,10 +568,8 @@ void ai_profile_t::reset()
    flags.reset();

    ai_path_mode = 0;
-	subsystem_path_radii = 0;
    bay_arrive_speed_mult = 0;
    bay_depart_speed_mult = 0;
-	second_order_lead_predict_factor = 0;

    for (int i = 0; i < NUM_SKILL_LEVELS; ++i) {
        max_incoming_asteroids[i] = 0;
@@ -663,23 +628,4 @@ void ai_profile_t::reset()
    for (int i = 0; i <= MAX_DETAIL_LEVEL; ++i) {
        detail_distance_mult[i] = 0;
    }
-
-	// via Github #2332, enable bugfixes if we are targeting version 20 and up
-	if (mod_supports_version(20, 0, 0)) {
-		flags.set(AI::Profile_Flags::Huge_turret_weapons_ignore_bombs);
-		flags.set(AI::Profile_Flags::Fix_linked_primary_bug);
-		flags.set(AI::Profile_Flags::Prevent_targeting_bombs_beyond_range);
-		flags.set(AI::Profile_Flags::Fix_heat_seeker_stealth_bug);
-		flags.set(AI::Profile_Flags::Allow_vertical_dodge);
-		flags.set(AI::Profile_Flags::Fix_ai_class_bug);
-		flags.set(AI::Profile_Flags::Ai_guards_specific_ship_in_wing);
-		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::nonshielded_ships_can_manage_ets);
-	}
-	// this flag has been enabled ever since 3.7.2
-	if (mod_supports_version(3, 7, 2)) {
-		flags.set(AI::Profile_Flags::Fix_ramming_stationary_targets_bug);
-	}
 }
@@ -97,17 +97,11 @@ public:

 	int ai_path_mode;

-	// radii to use for the radius for subsystem path points and default value --wookieejedi
-	int subsystem_path_radii;
-
 	// Ships flying bay paths will gradually accelerate/decelerate instead of
 	// flying the whole path at max speed
 	float bay_arrive_speed_mult;
 	float bay_depart_speed_mult;

-	// How much 0-1 of a second-order lead prediction factor to add to lead indicators. Affects only the HUD indicator, and autoaim.
-	float second_order_lead_predict_factor;
-
    void reset();
 };

@@ -370,8 +370,7 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 	float		dot = 1.0f, min_dot;
 	object	*target_objp;

-	auto shipp = &Ships[Pl_objp->instance];
-	aip = &Ai_info[shipp->ai_index];
+	aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
    
 	if ( aip->target_objnum < 0 )
 		return 0;
@@ -383,8 +382,7 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 		float			dist;

 		// Get models of both source and target
-		polymodel *pm = model_get( Ship_info[shipp->ship_info_index].model_num );
-		polymodel_instance *pmi = model_get_instance( shipp->model_instance_num );
+		polymodel *pm = model_get( Ship_info[Ships[Pl_objp->instance].ship_info_index].model_num );
 		polymodel *pm_t = model_get( Ship_info[Ships[target_objp->instance].ship_info_index].model_num );

 		// Necessary sanity check
@@ -405,8 +403,8 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 			aip->path_subsystem_next_check = timestamp(1500);

 			// get world pos of eye (stored in geye)
-			ep = &(pm->view_positions[shipp->current_viewpoint]);
-			model_instance_find_world_point( &geye, &ep->pnt, pm, pmi, 0, &Pl_objp->orient, &Pl_objp->pos );
+			ep = &(pm->view_positions[Ships[Pl_objp->instance].current_viewpoint]);
+			model_find_world_point( &geye, &ep->pnt, pm->id, 0, &Pl_objp->orient, &Pl_objp->pos );
 			
 			// get world pos of subsystem
 			vm_vec_unrotate(&gsubpos, &aip->targeted_subsys->system_info->pnt, &En_objp->orient);
@@ -433,6 +431,7 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 		min_dot = (target_objp->phys_info.fspeed > 5.0f?MIN_DOT_TO_ATTACK_MOVING_SUBSYS:MIN_DOT_TO_ATTACK_SUBSYS);
 		if ( (checked_sight && ((!subsys_in_sight) || (dot < min_dot)) ) )  {

+			aip->path_goal_dist = 5;
 			subsys_path_num = aip->targeted_subsys->system_info->path_num;
 			if ( ((aip->path_start) == -1 || (aip->mp_index != subsys_path_num)) && subsys_path_num < pm_t->n_paths ) {
 				// maybe create a new path
@@ -462,41 +461,9 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 			Assert(aip->path_length >= 2);
 			dist = vm_vec_dist_quick(&Path_points[aip->path_start+aip->path_length-2].pos, &Pl_objp->pos);

-			// distance setting --wookieejedi
 			if ( aip->path_cur >= (aip->path_start+aip->path_length-1) ) {
-				// register that path is done and reset goal distance to default
-				aip->path_goal_dist = Default_subsystem_path_pt_dist;
 				path_done=1;
 			}
-			// if not done then set path distances based on specified options
-			else {
-				bool found_point = false;
-				// 1. use radii of path points if specified
-				if (aip->ai_profile_flags[AI::Profile_Flags::Use_subsystem_path_point_radii]) {
-					// need a valid path and point in model to use pof specified radius
-					int path_num = aip->targeted_subsys->system_info->path_num;
-					if ((0 <= path_num) && (path_num < pm_t->n_paths)) {
-						// need a valid place in the path
-						if ((0 <= aip->path_cur) && (aip->path_cur < aip->path_length)) {
-							float path_point_radius = pm_t->paths[path_num].verts[aip->path_cur].radius;
-							int goal_dist = fl2i(path_point_radius);
-							// only set if >= Minimum path distance specified in aibig.h
-							if (goal_dist >= Minimum_subsystem_path_pt_dist) {
-								aip->path_goal_dist = goal_dist;
-								found_point = true;
-							}
-						}
-					}
-				}
-				// 2. use radii value in ai_profiles table if specified and no valid point found
-				if (!found_point && The_mission.ai_profile->subsystem_path_radii) {
-					aip->path_goal_dist = The_mission.ai_profile->subsystem_path_radii;
-				}
-				// 3. use default radii value if no valid point or specified radii
-				else {
-					aip->path_goal_dist = Default_subsystem_path_pt_dist;
-				}
-			}

 			min_dot = (target_objp->phys_info.fspeed > 5.0f?MIN_DOT_TO_ATTACK_MOVING_SUBSYS:MIN_DOT_TO_ATTACK_SUBSYS);
 			if ( (checked_sight && subsys_in_sight) && (dot > min_dot) ) {
@@ -664,8 +631,8 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 			compute_desired_rvec(rvec, enemy_pos, &Pl_objp->pos);
 		else
 			rvec = NULL;
-		
-		ai_turn_towards_vector(enemy_pos, Pl_objp, nullptr, rel_pos, 0.0f, 0, rvec);
+
+		ai_turn_towards_vector(enemy_pos, Pl_objp, sip->srotation_time, nullptr, rel_pos, 0.0f, 0, rvec);

 		// calc range of primary weapon
 		weapon_travel_dist = ai_get_weapon_dist(&Ships[Pl_objp->instance].weapons);
@@ -739,7 +706,7 @@ void ai_big_chase_ct()
 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 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 int maybe_avoid_big_ship(object *objp, object *ignore_objp, ai_info *aip, vec3d *goal_point, float delta_time);

 extern void maybe_cheat_fire_synaptic(object *objp);

@@ -1330,7 +1297,7 @@ void ai_big_strafe_attack()

 	if (aip->ai_flags[AI::AI_Flags::Kamikaze]) {
 		if (target_dist < 1200.0f) {
-			ai_turn_towards_vector(&target_pos, Pl_objp, nullptr, nullptr, 0.0f, 0);
+			ai_turn_towards_vector(&target_pos, Pl_objp, Ship_info[Ships[Pl_objp->instance].ship_info_index].srotation_time, nullptr, nullptr, 0.0f, 0);
 			accelerate_ship(aip, 1.0f);
 			if ((target_dist < 400.0f) && ai_maybe_fire_afterburner(Pl_objp, aip)) {
 				afterburners_start(Pl_objp);
@@ -1455,7 +1422,7 @@ void ai_big_strafe_glide_attack()
 		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);
+		vm_vec_random_in_circle(&tangentPoint, &target_objp->pos, &orient, target_objp->radius + GLIDE_STRAFE_DISTANCE, 1);
 		//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);
 		vm_vec_scale(&tangentPoint, 1000.0f);
@@ -1707,7 +1674,7 @@ void ai_big_strafe()
 		break;
 	default:

-		Error(LOCATION, "Ai_big_strafe() just tried to use an illegal submode. Go tell a coder!");		
+		Int3();		//	Illegal submode for AIM_STRAFE
 		break;
 	}

@@ -27,10 +27,6 @@ void	ai_big_strafe_maybe_attack_turret(const object *ship_objp, const object *we
 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()
-const int Default_subsystem_path_pt_dist = 5;
-const int Minimum_subsystem_path_pt_dist = 1;

 #endif

@@ -21,12 +21,9 @@
 #include "object/waypoint.h"
 #include "parse/sexp.h"
 #include "playerman/player.h"
-#include "scripting/scripting.h"
 #include "ship/ship.h"
 #include "weapon/weapon.h"

-// Just a reference to this struct being for looking up a ship's team in TVT
-struct ship_registry_entry;

 // all ai goals dealt with in this code are goals that are specified through
 // sexpressions in the mission file.  They are either specified as part of a
@@ -136,48 +133,28 @@ const char *Ai_goal_text(int goal)
 	return NULL;
 }

-void ai_maybe_add_form_goal(wing* wingp)
+// function to maybe add the form on my wing goal for a player's starting wing.  Called when a player wing arrives.
+void ai_maybe_add_form_goal( wing *wingp )
 {
-	// Cyborg17 - Changes from the client would just get overridden by the server anyway
-	// might as well keep them more closely in sync.
-	if (MULTIPLAYER_CLIENT) {
-		return;
-	}
-
 	int j;

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

-		Assert(wingp->ship_index[j] != -1);						// get Allender
+		Assert( wingp->ship_index[j] != -1 );						// get Allender

 		aip = &Ai_info[Ships[wingp->ship_index[j]].ai_index];
-		// don't process a Player_ship
-		if (Objects[Ships[aip->shipnum].objnum].flags[Object::Object_Flags::Player_ship]) {
+		// don't process Player_ship
+		if ( aip == Player_ai )
 			continue;
-		}
-
-		// need to add a form on my wing goal here.  Ships are always forming on the player's wing.
+		
 		// it is sufficient enough to check the first goal entry to see if it has a valid goal
-		if (aip->goals[0].ai_mode == AI_GOAL_NONE) {
-			// Need to have a more specific target in multi, or they may end up trying to target standalone placeholder.
-			// So form on their team leader.  In dogfight, all player-slot ai die, so just exclude.
-			if (MULTIPLAYER_MASTER && !(Netgame.type_flags & NG_TYPE_DOGFIGHT)) {
-				int wingnum;
-				if (Netgame.type_flags & NG_TYPE_TEAM) {
-					const ship_registry_entry* ship_regp = ship_registry_get(Ships[wingp->ship_index[j]].ship_name);
-					wingnum = TVT_wings[ship_regp->p_objp->team];
-					ai_add_ship_goal_player(AIG_TYPE_PLAYER_SHIP, AI_GOAL_FORM_ON_WING, -1, Ships[Wings[wingnum].ship_index[Wings[wingnum].special_ship]].ship_name, aip);
-				} else {
-					wingnum = Starting_wings[0];
-					ai_add_ship_goal_player(AIG_TYPE_PLAYER_SHIP, AI_GOAL_FORM_ON_WING, -1, Ships[Wings[wingnum].ship_index[Wings[wingnum].special_ship]].ship_name, aip);
-				}
-			} else if (!(Game_mode & GM_MULTIPLAYER)) {
-				ai_add_ship_goal_player(AIG_TYPE_PLAYER_SHIP, AI_GOAL_FORM_ON_WING, -1, Player_ship->ship_name, aip);
-			}
+		if ( aip->goals[0].ai_mode == AI_GOAL_NONE ) {
+			// need to add a form on my wing goal here.  Ships are always forming on the player's wing.
+			ai_add_ship_goal_player( AIG_TYPE_PLAYER_SHIP, AI_GOAL_FORM_ON_WING, -1, Player_ship->ship_name, aip );
 		}
 	}
 }
@@ -291,16 +268,13 @@ void ai_clear_ship_goals( ai_info *aip )
 	{
 		ai_do_default_behavior( &Objects[Ships[aip->shipnum].objnum] );
 	}
-
-	// add scripting hook for 'On Goals Cleared' --wookieejedi
-	Script_system.SetHookObject("Ship", &Objects[Ships[aip->shipnum].objnum]);
-	Script_system.RunCondition(CHA_ONGOALSCLEARED);
-	Script_system.RemHookVars({"Ship"});
 }

-void ai_clear_wing_goals( wing *wingp )
+void ai_clear_wing_goals( int wingnum )
 {
 	int i;
+	wing *wingp = &Wings[wingnum];
+	//p_object *objp;

 	// clear the goals for all ships in the wing
 	for (i = 0; i < wingp->current_count; i++) {
@@ -311,13 +285,15 @@ void ai_clear_wing_goals( wing *wingp )

 	}

-	// clear out the goals for the wing now
+		// clear out the goals for the wing now
 	for (i = 0; i < MAX_AI_GOALS; i++) {
 		wingp->ai_goals[i].ai_mode = AI_GOAL_NONE;
 		wingp->ai_goals[i].signature = -1;
 		wingp->ai_goals[i].priority = -1;
 		wingp->ai_goals[i].flags.reset();
 	}
+
+
 }

 // routine which marks a wing goal as being complete.  We get the wingnum and a pointer to the goal
@@ -327,7 +303,7 @@ void ai_clear_wing_goals( wing *wingp )
 void ai_mission_wing_goal_complete( int wingnum, ai_goal *remove_goalp )
 {
 	int mode, submode, priority, i;
-	const char *name;
+	char *name;
 	ai_goal *aigp;
 	wing *wingp;

@@ -405,7 +381,7 @@ void ai_goal_purge_invalid_goals( ai_goal *aigp, ai_goal *goal_list, ai_info *ai
 {
 	int i, j;
 	ai_goal *purge_goal;
-	const char *name;
+	char *name;
 	int mode, ship_index, wingnum;

 	// get locals for easer access
@@ -852,10 +828,11 @@ void ai_add_wing_goal_player( int type, int mode, int submode, char *shipname, i
 void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp, char *actor_name )
 {
 	int node, dummy, op;
+	char *text;

 	Assert ( Sexp_nodes[sexp].first != -1 );
 	node = Sexp_nodes[sexp].first;
-	op = get_operator_const( node );
+	text = CTEXT(node);

 	aigp->signature = Ai_goal_signature++;

@@ -864,6 +841,8 @@ void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp, char *actor_name )
 	aigp->type = type;
 	aigp->flags.reset();

+	op = get_operator_const( text );
+
 	switch (op) {

 	case OP_AI_WAYPOINTS_ONCE:
@@ -1032,7 +1011,7 @@ void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp, char *actor_name )
 	}

 	if ( aigp->priority > MAX_GOAL_PRIORITY ) {
-		nprintf (("AI", "bashing sexpression priority of goal %s from %d to %d.\n", CTEXT(node), aigp->priority, MAX_GOAL_PRIORITY));
+		nprintf (("AI", "bashing sexpression priority of goal %s from %d to %d.\n", text, aigp->priority, MAX_GOAL_PRIORITY));
 		aigp->priority = MAX_GOAL_PRIORITY;
 	}

@@ -1097,9 +1076,14 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp )
 	int goalsubmode = -1;

 	/* Sexp node */
-	int node = Sexp_nodes[sexp].first;
+	int node = -1;
 	/* The operator to use */
-	int op = get_operator_const( node );
+	char* op_text = NULL;
+	int op = -1;
+
+	node = Sexp_nodes[ sexp ].first;
+	op_text = CTEXT( node );
+	op = get_operator_const( op_text );

 	/* We now need to determine what the mode and submode values are*/
 	switch( op )
@@ -1226,10 +1210,11 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp )
 }

 // code to add ai goals to wings.
-void ai_remove_wing_goal_sexp(int sexp, wing *wingp)
+void ai_remove_wing_goal_sexp(int sexp, int wingnum)
 {
 	int i;
 	int goalindex = -1;
+	wing *wingp = &Wings[wingnum];

 	// add the ai goal for any ship that is currently arrived in the game (only if fred isn't running)
 	if ( !Fred_running ) {
@@ -1260,9 +1245,10 @@ void ai_add_ship_goal_sexp( int sexp, int type, ai_info *aip )
 }

 // code to add ai goals to wings.
-void ai_add_wing_goal_sexp(int sexp, int type, wing *wingp)
+void ai_add_wing_goal_sexp(int sexp, int type, int wingnum)
 {
 	int i;
+	wing *wingp = &Wings[wingnum];

 	// add the ai goal for any ship that is currently arrived in the game (only if fred isn't running)
 	if ( !Fred_running ) {
@@ -1383,7 +1369,7 @@ void ai_copy_mission_wing_goal( ai_goal *aigp, ai_info *aip )
 	}

 	if (j >= MAX_AI_GOALS) {
-		mprintf(("Unable to assign wing goal to ship %s; the ship goals are already filled to capacity\n", Ships[aip->shipnum].ship_name));
+		mprintf(("Unable to assign wing goal to ship %s; the ship goals are already filled to capacity", Ships[aip->shipnum].ship_name));
 	}
 }

@@ -1420,17 +1406,21 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 	{
 		ship *shipp = &Ships[objp->instance];

-		// always valid if has working subspace drive, not disabled, and not limited by subsystem strength
-		if ( ship_can_warp_full_check(shipp) )
+		// always valid if has subspace drive
+		if (!(shipp->flags[Ship::Ship_Flags::No_subspace_drive]))
 			return AI_GOAL_ACHIEVABLE;

-		// if we can't warp, we can only depart if the ship (or its wing) departs to a fighter bay and the mothership is present
-		if (ship_can_bay_depart(shipp)) {
-			return AI_GOAL_ACHIEVABLE;
-		}
-		else {
-			return AI_GOAL_NOT_KNOWN;
+		// if no subspace drive, only valid if our mothership is present
+
+		// check that we have a mothership and that we can depart to it
+		if (shipp->departure_location == DEPART_AT_DOCK_BAY)
+		{
+			int anchor_shipnum = ship_name_lookup(Parse_names[shipp->departure_anchor]);
+			if (anchor_shipnum >= 0 && ship_useful_for_departure(anchor_shipnum, shipp->departure_path_mask))
+				return AI_GOAL_ACHIEVABLE;
 		}
+
+		return AI_GOAL_NOT_KNOWN;
 	}


@@ -1509,8 +1499,7 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 			Assert ( aigp->ai_submode >= 0 );
 			ssp = ship_get_indexed_subsys( &Ships[sindex], aigp->ai_submode );
 			if (ssp != NULL) {
-				// see MWA 3/20/97 comment above - instead of checking the mission log, check the current hits
-				status = (ssp->current_hits <= 0.0f) ? 1 : 0;
+				status = mission_log_get_time( LOG_SHIP_SUBSYS_DESTROYED, aigp->target_name, ssp->system_info->subobj_name, NULL );
 			} else {
 				// not supposed to ever happen, but could if there is a mismatch between the table and model subsystems
 				nprintf(("AI", "Couldn't find subsystem %d for ship %s\n", aigp->ai_submode, Ships[sindex].ship_name));
@@ -1520,36 +1509,12 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 		}

 		case AI_GOAL_DISABLE_SHIP:
-		{
-			// shipnum could be -1 depending on if the ship hasn't arrived or died.  only look for subsystem
-			// destroyed when shipnum is valid
-			sindex = ship_name_lookup(aigp->target_name);
-
-			// can't determine the status of this goal if ship not valid
-			if (sindex < 0) {
-				status = 0;
-			} else {
-				// see MWA 3/20/97 comment above - instead of checking the mission log, check the current hits
-				status = (Ships[sindex].subsys_info[SUBSYSTEM_ENGINE].aggregate_current_hits <= 0.0f) ? 1 : 0;
-			}
+			status = mission_log_get_time( LOG_SHIP_DISABLED, aigp->target_name, NULL, NULL );
 			break;
-		}

 		case AI_GOAL_DISARM_SHIP:
-		{
-			// shipnum could be -1 depending on if the ship hasn't arrived or died.  only look for subsystem
-			// destroyed when shipnum is valid
-			sindex = ship_name_lookup(aigp->target_name);
-
-			// can't determine the status of this goal if ship not valid
-			if (sindex < 0) {
-				status = 0;
-			} else {
-				// see MWA 3/20/97 comment above - instead of checking the mission log, check the current hits
-				status = (Ships[sindex].subsys_info[SUBSYSTEM_TURRET].aggregate_current_hits <= 0.0f) ? 1 : 0;
-			}
+			status = mission_log_get_time( LOG_SHIP_DISARMED, aigp->target_name, NULL, NULL );
 			break;
-		}

 		// to guard or ignore a ship, the goal cannot continue if the ship being guarded is either destroyed
 		// or has departed.
@@ -1655,35 +1620,25 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 	}
 	else
 	{
-		auto ship_entry = ship_registry_get(aigp->target_name);
-
-		if (!ship_entry)
-		{
-			status = SHIP_STATUS_UNKNOWN;
-		}
 		// goal ship is currently in mission
-		else if (ship_entry->status == ShipStatus::PRESENT)
+		if ( ship_name_lookup( aigp->target_name ) != -1 )
 		{
 			status = SHIP_STATUS_ARRIVED;
 		}
 		// goal ship is still on the arrival list
-		else if (ship_entry->status == ShipStatus::NOT_YET_PRESENT)
+		else if ( mission_parse_get_arrival_ship(aigp->target_name) )
 		{
 			status = SHIP_STATUS_NOT_ARRIVED;
 		}
 		// goal ship has left the area
-		else if (ship_entry->status == ShipStatus::EXITED)
+		else if ( ship_find_exited_ship_by_name(aigp->target_name) != -1 )
 		{
 			status = SHIP_STATUS_GONE;
 		}
 		else
-		{
-			status = SHIP_STATUS_UNKNOWN;
-		}
-
-		if (status == SHIP_STATUS_UNKNOWN)
 		{
 			mprintf(("Potentially incorrect behaviour in AI goal for ship %s: Ship %s could not be found among currently active, departed, or yet-to-arrive ships.\nPlease check the mission file.\n", Ships[objp->instance].ship_name, aigp->target_name));
+			status = SHIP_STATUS_UNKNOWN;
 		}
 	}

@@ -2118,13 +2073,7 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 	// if this object was flying in formation off of another object, remove the flag that tells him
 	// to do this.  The form-on-my-wing command is removed from the goal list as soon as it is called, so
 	// we are safe removing this bit here.
-	int old_form_objnum = -1;
-	if (aip->ai_flags[AI::AI_Flags::Formation_object]) {
-		// save who he was following so we can tell any others 
-		// who are following to re-organize
-		old_form_objnum = aip->goal_objnum;
-		aip->ai_flags.remove(AI::AI_Flags::Formation_object);
-	}
+	aip->ai_flags.remove(AI::AI_Flags::Formation_object);

 	// Goober5000 - we may want to use AI for the player
 	// AL 3-7-98: If this is a player ship, and the goal is not a formation goal, then do a quick out
@@ -2390,8 +2339,6 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		break;
 	}

-	if (old_form_objnum != -1)
-		ai_formation_object_recalculate_slotnums(old_form_objnum);
 }

 void ai_update_goal_references(ai_goal *goals, int type, const char *old_name, const char *new_name)
@@ -102,11 +102,11 @@ extern int ai_goal_num(ai_goal *goals);
 // adds goals to ships/wing through sexpressions
 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_wing_goal_sexp( int sexp, int type, int wingnum );
 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 );
-extern void ai_remove_wing_goal_sexp( int sexp, wing *wingp );
+extern void ai_remove_wing_goal_sexp(int sexp, int wingnum);

 // adds goals to ships/sings through player orders
 extern void ai_add_ship_goal_player( int type, int mode, int submode, char *shipname, ai_info *aip );
@@ -114,7 +114,7 @@ extern void ai_add_wing_goal_player( int type, int mode, int submode, char *ship

 extern void ai_remove_ship_goal( ai_info *aip, int index );
 extern void ai_clear_ship_goals( ai_info *aip );
-extern void ai_clear_wing_goals( wing *wingp );
+extern void ai_clear_wing_goals( int wingnum );

 extern void ai_copy_mission_wing_goal( ai_goal *aigp, ai_info *aip );

@@ -26,12 +26,9 @@ int object_is_targetable(object *target, ship *viewer);
 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.
-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, ship_subsys* turret);
+int check_ok_to_fire(int objnum, int target_objnum, weapon_info *wip);

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

 #endif
@@ -151,21 +151,14 @@ int unpack_pixel(anim_instance *ai, ubyte *data, ubyte pix, int aabitmap, int bp
 			bit_16 = (ushort)pix;
 			break;
 		case 8:
-			// 8 bit-per-pixel aa bitmaps are a bit special since they only use a palette index value in the range [0, 15]. These 
-			// palette indexes must be remapped to alpha values between [0, 255] which is what graphics code expects. Palette 
-			// range [0, 14] is a gradient from black to white, and palette index 15 is a special color which indicates the background
-			// area of a HUD gauge. Retail code uses the final alpha value for index 1 for this special index to give gauges a dark
-			// transparent background.
-			if (pix > 15) {
-				bit_8 = 255;
+			// 8 bit-per-pixel aa bitmaps are a bit special since they only use value in the range [0, 15] where 15 wraps
+			// around back to 0. Since the rest of the code expects the value to be in the range [0, 255] the pixel value
+			// needs to be adjusted here. By muliplying the value with 17 the original range [0, 15] is mapped to [0, 255]
+			if (pix >= 15) {
+				bit_8 = 0;
+			} else {
+				bit_8 = (ubyte)(pix * 17);
 			}
-			else if (pix == 15) {
-				bit_8 = 18;
-			}
-			else {
-				bit_8 = (ubyte)(pix * 18);
-			}
-
 			break;
 		default:
 			Int3();
@@ -249,21 +242,14 @@ int unpack_pixel_count(anim_instance *ai, ubyte *data, ubyte pix, int count = 0,
 			bit_16 = (ushort)pix;
 			break;
 		case 8 :
-			// 8 bit-per-pixel aa bitmaps are a bit special since they only use a palette index value in the range [0, 15]. These 
-			// palette indexes must be remapped to alpha values between [0, 255] which is what graphics code expects. Palette 
-			// range [0, 14] is a gradient from black to white, and palette index 15 is a special color which indicates the background
-			// area of a HUD gauge. Retail code uses the final alpha value for index 1 for this special index to give gauges a dark
-			// transparent background.
-			if (pix > 15) {
-				bit_8 = 255;
+			// 8 bit-per-pixel aa bitmaps are a bit special since they only use value in the range [0, 15] where 15 wraps
+			// around back to 0. Since the rest of the code expects the value to be in the range [0, 255] the pixel value
+			// needs to be adjusted here. By muliplying the value with 17 the original range [0, 15] is mapped to [0, 255]
+			if (pix >= 15) {
+				bit_8 = 0;
+			} else {
+				bit_8 = (ubyte)(pix * 17);
 			}
-			else if (pix == 15) {
-				bit_8 = 18;
-			}
-			else {
-				bit_8 = (ubyte)(pix * 18);
-			}
-
 			break;
 		default :
 			Int3();			
@@ -36,7 +36,6 @@
 #include "particle/particle.h"
 #include "render/3d.h"
 #include "ship/ship.h"
-#include "ship/shipfx.h"
 #include "ship/shiphit.h"
 #include "species_defs/species_defs.h"
 #include "stats/scoring.h"
@@ -479,7 +478,7 @@ static void asteroid_load(int asteroid_info_index, int asteroid_subtype)
 			}
 			else
 			{
-				nprintf(("Warning",  "For asteroid '%s', detail level mismatch (POF needs %d)\n", asip->name, pm->n_detail_levels));
+				nprintf(("Warning",  "For asteroid '%s', detail level mismatch (POF needs %d)", asip->name, pm->n_detail_levels));
 			}
 		}	
 		// Stuff detail level distances.
@@ -929,6 +928,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		Assert( other_obj->type == OBJ_WEAPON );
 		mc.model_instance_num = Asteroids[num].model_instance_num;
 		mc.model_num = Asteroid_info[Asteroids[num].asteroid_type].model_num[asteroid_subtype];	// Fill in the model to check
+		model_clear_instance( mc.model_num );
 		mc.orient = &pasteroid->orient;					// The object's orient
 		mc.pos = &pasteroid->pos;							// The object's position
 		mc.p0 = &other_obj->last_pos;				// Point 1 of ray to check
@@ -942,11 +942,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 			if (hitnormal)
 			{
 				vec3d normal;
-
-				if (mc.model_instance_num >= 0)
-					model_instance_find_world_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
-				else
-					model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
+				model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);

 				*hitnormal = normal;
 			}
@@ -1014,51 +1010,51 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		// first test against the sphere - if this fails then don't do any submodel tests
 		mc.flags = MC_ONLY_SPHERE | MC_CHECK_SPHERELINE;

+		SCP_vector<int> submodel_vector;
+		polymodel_instance *pmi;
+
 		if (model_collide(&mc)) {

 			// Set earliest hit time
 			asteroid_hit_info->hit_time = FLT_MAX;

-			auto pmi = model_get_instance(Ships[heavy_obj->instance].model_instance_num);
-			auto pm = model_get(pmi->model_num);
-
 			// Do collision the cool new way
 			if ( asteroid_hit_info->collide_rotate ) {
 				// We collide with the sphere, find the list of rotating submodels and test one at a time
-				SCP_vector<int> submodel_vector;
 				model_get_rotating_submodel_list(&submodel_vector, heavy_obj);

-				// turn off all rotating submodels, collide against only 1 at a time.
-				// turn off collision detection for all rotating submodels
-				for (auto submodel: submodel_vector) {
-					pmi->submodel[submodel].collision_checked = true;
+				// Get polymodel and turn off all rotating submodels, collide against only 1 at a time.
+				pmi = model_get_instance(Ships[heavy_obj->instance].model_instance_num);
+
+				// turn off all rotating submodels and test for collision
+				for (size_t j=0; j<submodel_vector.size(); j++) {
+					pmi->submodel[submodel_vector[j]].collision_checked = true;
 				}

 				// reset flags to check MC_CHECK_MODEL | MC_CHECK_SPHERELINE and maybe MC_CHECK_INVISIBLE_FACES and MC_SUBMODEL_INSTANCE
 				mc.flags = copy_flags | MC_SUBMODEL_INSTANCE;

-				// check each submodel in turn
-				for (auto submodel: submodel_vector) {
-					auto smi = &pmi->submodel[submodel];

-					// turn on just one submodel for collision test
-					smi->collision_checked = false;
+				// check each submodel in turn
+				for (size_t i=0; i<submodel_vector.size(); i++) {
+					// turn on submodel for collision test
+					pmi->submodel[submodel_vector[i]].collision_checked = false;

 					// set angles for last frame (need to set to prev to get p0)
-					angles copy_angles = smi->angs;
+					angles copy_angles = pmi->submodel[submodel_vector[i]].angs;

 					// find the start and end positions of the sphere in submodel RF
-					smi->angs = smi->prev_angs;
-					world_find_model_instance_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos);
+					pmi->submodel[submodel_vector[i]].angs = pmi->submodel[submodel_vector[i]].prev_angs;
+					world_find_model_instance_point(&p0, &light_obj->last_pos, pmi, submodel_vector[i], &heavy_obj->last_orient, &heavy_obj->last_pos);

-					smi->angs = copy_angles;
-					world_find_model_instance_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
+					pmi->submodel[submodel_vector[i]].angs = copy_angles;
+					world_find_model_instance_point(&p1, &light_obj->pos, pmi, submodel_vector[i], &heavy_obj->orient, &heavy_obj->pos);

 					mc.p0 = &p0;
 					mc.p1 = &p1;

 					mc.orient = &vmd_identity_matrix;
-					mc.submodel_num = submodel;
+					mc.submodel_num = submodel_vector[i];

 					if ( model_collide(&mc) ) {
 						if ( mc.hit_dist < asteroid_hit_info->hit_time ) {
@@ -1069,18 +1065,18 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos

 							// set up asteroid_hit_info for rotating submodel
 							if (asteroid_hit_info->edge_hit == 0) {
-								model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+								model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, Ships[heavy_obj->instance].model_instance_num, mc.hit_submodel, &heavy_obj->orient);
 							}

 							// find position in submodel RF of light object at collison
 							vec3d int_light_pos, diff;
 							vm_vec_sub(&diff, mc.p1, mc.p0);
 							vm_vec_scale_add(&int_light_pos, mc.p0, &diff, mc.hit_dist);
-							model_instance_find_world_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							model_instance_find_world_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, mc.model_instance_num, mc.hit_submodel, &heavy_obj->orient, &zero);
 						}
 					}
 					// Don't look at this submodel again
-					smi->collision_checked = true;
+					pmi->submodel[submodel_vector[i]].collision_checked = true;
 				}

 			}
@@ -1101,7 +1097,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos

 					// get collision normal if not edge hit
 					if (asteroid_hit_info->edge_hit == 0) {
-						model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+						model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, Ships[heavy_obj->instance].model_instance_num, mc.hit_submodel, &heavy_obj->orient);
 					}

 					// find position in submodel RF of light object at collison
@@ -1117,6 +1113,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		// Asteroid is heavier obj
 		mc.model_instance_num = Asteroids[num].model_instance_num;
 		mc.model_num = Asteroid_info[Asteroids[num].asteroid_type].model_num[asteroid_subtype];		// Fill in the model to check
+		model_clear_instance( mc.model_num );
 		mc.orient = &pasteroid->orient;				// The object's orient
 		mc.radius = model_get_core_radius(Ship_info[Ships[pship_obj->instance].ship_info_index].model_num);

@@ -1140,23 +1137,6 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos

 		}
 	}
-
-	// check if the hit point is beyond the clip plane if the ship is warping.
-	if (mc_ret_val) {
-		WarpEffect* warp_effect = nullptr;
-		ship* shipp = &Ships[pship_obj->instance];
-
-		// this is extremely confusing but mc.hit_point_world isn't actually in world coords
-		// everything above was calculated relative to the heavy's position
-		vec3d actual_world_hit_pos = mc.hit_point_world + heavy_obj->pos;
-		if ((shipp->is_arriving()) && (shipp->warpin_effect != nullptr))
-			warp_effect = shipp->warpin_effect;
-		else if ((shipp->flags[Ship::Ship_Flags::Depart_warp]) && (shipp->warpout_effect != nullptr))
-			warp_effect = shipp->warpout_effect;
-
-		if (warp_effect != nullptr && point_is_clipped_by_warp(&actual_world_hit_pos, warp_effect))
-			mc_ret_val = 0;
-	}
 	

 	if ( mc_ret_val )	{
@@ -1957,11 +1937,11 @@ static void asteroid_parse_tbl()
 		if (tally != max_asteroids)
 		{
 #ifndef NDEBUG
-			mprintf(("Asteroid.tbl as parsed:\n"));
 			for (SCP_vector<SCP_string>::iterator iter = parsed_asteroids.begin();
 				iter != parsed_asteroids.end(); ++iter)
 			{
-				mprintf(("%s\n", iter->c_str()));
+				mprintf(("Asteroid.tbl as parsed:\n"));
+				mprintf(("%s", iter->c_str()));
 			}
 #endif
 			Error(LOCATION,
@@ -108,7 +108,7 @@ bool Sel_NextNav()


 // ********************************************************************************************
-const vec3d *NavPoint::GetPosition()
+vec3d *NavPoint::GetPosition()
 {
 	if (flags & NP_WAYPOINT)
 	{
@@ -123,7 +123,7 @@ const vec3d *NavPoint::GetPosition()
 }

 // ********************************************************************************************
-bool CanAutopilot(const vec3d *targetPos, bool send_msg)
+bool CanAutopilot(vec3d targetPos, bool send_msg)
 {
 	if (CurrentNav == -1)
 	{
@@ -140,7 +140,7 @@ bool CanAutopilot(const vec3d *targetPos, bool send_msg)
 	}

 	// You cannot autopilot if you're within 1000 meters of your destination nav point
-	if (vm_vec_dist_quick(targetPos, Navs[CurrentNav].GetPosition()) < 1000) {
+	if (vm_vec_dist_quick(&targetPos, Navs[CurrentNav].GetPosition()) < 1000) {
 		if (send_msg)
 					send_autopilot_msgID(NP_MSG_FAIL_TOCLOSE);
 		return false;
@@ -156,7 +156,7 @@ bool CanAutopilot(const vec3d *targetPos, bool send_msg)
 				&& !(Ship_info[Ships[other_objp->instance].ship_info_index].flags[Ship::Info_Flags::Cargo])) // ignore cargo
 			{
 				// Cannot autopilot if enemy within AutopilotMinEnemyDistance meters
-				if (vm_vec_dist_quick(targetPos, &other_objp->pos) < AutopilotMinEnemyDistance) {
+				if (vm_vec_dist_quick(&targetPos, &other_objp->pos) < AutopilotMinEnemyDistance) {
 					if (send_msg)
 						send_autopilot_msgID(NP_MSG_FAIL_HOSTILES);
 					return false;
@@ -173,7 +173,7 @@ bool CanAutopilot(const vec3d *targetPos, bool send_msg)
 			if (Asteroids[n].flags & AF_USED)
 			{
 				// Cannot autopilot if asteroid within AutopilotMinAsteroidDistance meters
-				if (vm_vec_dist_quick(targetPos, &Objects[Asteroids[n].objnum].pos) < AutopilotMinAsteroidDistance) {
+				if (vm_vec_dist_quick(&targetPos, &Objects[Asteroids[n].objnum].pos) < AutopilotMinAsteroidDistance) {
 					if (send_msg)
 						send_autopilot_msgID(NP_MSG_FAIL_HAZARD);
 					return false;
@@ -218,9 +218,9 @@ bool StartAutopilot()
 			if (shipp->team != Player_ship->team)
 				continue;

-			Assertion((shipp->ship_info_index >= 0) && (shipp->ship_info_index < ship_info_size()),
+			Assertion((shipp->ship_info_index >= 0) && (shipp->ship_info_index < static_cast<int>(Ship_info.size())),
 				"Ship '%s' does not have a valid pointer to a ship class. Pointer is %d, which is smaller than 0 or bigger than %d",
-				shipp->ship_name, shipp->ship_info_index, ship_info_size());
+				shipp->ship_name, shipp->ship_info_index, static_cast<int>(Ship_info.size()));
 			ship_info *sip = &Ship_info[shipp->ship_info_index];

 			if ( !(sip->flags[Ship::Info_Flags::Support]) )
@@ -409,11 +409,11 @@ bool StartAutopilot()
 				if (leader_objp != &Objects[Ships[i].objnum])
 				{
 					// not leader.. get our position relative to leader
-					get_absolute_wing_pos(&goal_point, leader_objp, wingnum, wing_index, aip->ai_flags[AI::AI_Flags::Formation_object], true);
+					get_absolute_wing_pos_autopilot(&goal_point, leader_objp, wing_index, aip->ai_flags[AI::AI_Flags::Formation_object]);
 				}
 				else
 				{
-					ai_clear_wing_goals(&Wings[wingnum]);
+					ai_clear_wing_goals(wingnum);
 					j = 1+int( (float)floor(double(wcount-1)/2.0) );
 					switch (wcount % 2)
 					{
@@ -484,7 +484,7 @@ bool StartAutopilot()
 				//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] );
+				ai_clear_wing_goals( i );
 				if (Navs[CurrentNav].flags & NP_WAYPOINT)
 				{
 					
@@ -989,7 +989,7 @@ void nav_warp(bool prewarp=false)
 	/* using the vector of the flight leaders's path, simulate moving the 
 	flight along this path by checking the autopilot conditions as specific
 	intervals along the path*/
-	while (CanAutopilot(&tpos))
+	while (CanAutopilot(tpos))
 	{
 		vm_vec_add(&tpos, &tpos, &pos);
 	}
@@ -1192,7 +1192,7 @@ void send_autopilot_msgID(int msgid)
 }
 // ********************************************************************************************

-void send_autopilot_msg(const char *msg, const char *snd)
+void send_autopilot_msg(char *msg, char *snd)
 {
 	// setup
 	if (audio_handle != -1)
@@ -1312,7 +1312,7 @@ void parse_autopilot_table(const char *filename)

 // ********************************************************************************************
 // Finds a Nav point by name
-int FindNav(const char *Nav)
+int FindNav(char *Nav)
 {
 	for (int i = 0; i < MAX_NAVPOINTS; i++)
 	{
@@ -1325,7 +1325,7 @@ int FindNav(const char *Nav)

 // ********************************************************************************************
 // Removes a Nav
-bool DelNavPoint(const char *Nav)
+bool DelNavPoint(char *Nav)
 {
 	int n = FindNav(Nav);

@@ -1354,7 +1354,7 @@ bool DelNavPoint(int nav)

 // ********************************************************************************************
 // adds a Nav
-bool AddNav_Ship(const char *Nav, const char *TargetName, int flags)
+bool AddNav_Ship(char *Nav, char *TargetName, int flags)
 {
 	// find an empty nav - should be the end

@@ -1397,7 +1397,7 @@ bool AddNav_Ship(const char *Nav, const char *TargetName, int flags)
 }


-bool AddNav_Waypoint(const char *Nav, const char *WP_Path, int node, int flags)
+bool AddNav_Waypoint(char *Nav, char *WP_Path, int node, int flags)
 {
 	// find an empty nav - should be the end

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

 // ********************************************************************************************
 //Get Flags
-int Nav_Get_Flags(const char *Nav)
+int Nav_Get_Flags(char *Nav)
 {
 	int flags = 0;

@@ -1451,7 +1451,7 @@ int Nav_Get_Flags(const char *Nav)
 // Sexp Accessors

 //Generic
-bool Nav_Set_Flag(const char *Nav, int flag)
+bool Nav_Set_Flag(char *Nav, int flag)
 {
 	Assert(!(flag & NP_VALIDTYPE));
 	int nav = FindNav(Nav);
@@ -1467,7 +1467,7 @@ bool Nav_Set_Flag(const char *Nav, int flag)

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_UnSet_Flag(const char *Nav, int flag)
+bool Nav_UnSet_Flag(char *Nav, int flag)
 {
 	Assert(!(flag & NP_VALIDTYPE));

@@ -1484,7 +1484,7 @@ bool Nav_UnSet_Flag(const char *Nav, int flag)

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //Named
-bool Nav_Set_Hidden(const char *Nav)
+bool Nav_Set_Hidden(char *Nav)
 {
 	return Nav_Set_Flag(Nav, NP_HIDDEN);

@@ -1492,14 +1492,14 @@ bool Nav_Set_Hidden(const char *Nav)

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_Set_NoAccess(const char *Nav)
+bool Nav_Set_NoAccess(char *Nav)
 {
 	return Nav_Set_Flag(Nav, NP_NOACCESS);
 }

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_Set_Visited(const char *Nav)
+bool Nav_Set_Visited(char *Nav)
 {
 	
 	return Nav_Set_Flag(Nav, NP_VISITED);
@@ -1507,28 +1507,28 @@ bool Nav_Set_Visited(const char *Nav)

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_UnSet_Hidden(const char *Nav)
+bool Nav_UnSet_Hidden(char *Nav)
 {
 	return Nav_UnSet_Flag(Nav, NP_HIDDEN);
 }

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_UnSet_NoAccess(const char *Nav)
+bool Nav_UnSet_NoAccess(char *Nav)
 {
 	return Nav_UnSet_Flag(Nav, NP_NOACCESS);
 }

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool Nav_UnSet_Visited(const char *Nav)
+bool Nav_UnSet_Visited(char *Nav)
 {
 	return Nav_UnSet_Flag(Nav, NP_VISITED);
 }

 // ********************************************************************************************
 // Selects a navpoint by name.
-void SelectNav(const char *Nav)
+void SelectNav(char *Nav)
 {
 	for (int i = 0; i < MAX_NAVPOINTS; i++)
 	{
@@ -1547,7 +1547,7 @@ void DeselectNav()
 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+


-unsigned int DistanceTo(const char *nav)
+unsigned int DistanceTo(char *nav)
 {
 	int n = FindNav(nav);

@@ -1564,7 +1564,7 @@ unsigned int DistanceTo(int nav)

 //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

-bool IsVisited(const char *nav)
+bool IsVisited(char *nav)
 {
 	int n = FindNav(nav);

@@ -32,17 +32,17 @@ public:
 	char m_NavName[32];
 	int flags;

-	const void *target_obj;
+	void *target_obj;
 	int waypoint_num; //only used when flags & NP_WAYPOINT

-	const vec3d *GetPosition();
+	vec3d *GetPosition();

 	void clear()
 	{
 		m_NavName[0] = 0;
 		flags = 0;

-		target_obj = nullptr;
+		target_obj = NULL;
 		waypoint_num = -1;
 	}
 };
@@ -82,11 +82,11 @@ bool Sel_NextNav();
 //        * No asteroids within AutopilotMinAsteroidDistance meters
 //        * Destination > 1,000 meters away
 //        * Support ship not present or is actively leaving
-bool CanAutopilot(const vec3d *targetPos, bool send_msg=false);
+bool CanAutopilot(vec3d targetPos, bool send_msg=false);

 // Check if autopilot is allowed at player's current position
 // See CanAutopilot(vec3d, bool) for more information
-inline bool CanAutopilot(bool send_msg=false) { return CanAutopilot(&Player_obj->pos, send_msg); }
+inline bool CanAutopilot(bool send_msg=false) { return CanAutopilot(Player_obj->pos, send_msg); }

 // Engages autopilot
 // This does:
@@ -120,42 +120,42 @@ void NavSystem_Init();
 void parse_autopilot_table(const char *filename);

 // Finds a Nav point by name
-int FindNav(const char *Nav);
+int FindNav(char *Nav);

 // Selects a Nav point by name
-void SelectNav(const char *Nav);
+void SelectNav(char *Nav);

 // Deselects any navpoint selected.
 void DeselectNav();

 // Removes a Nav
-bool DelNavPoint(const char *Nav);
+bool DelNavPoint(char *Nav);
 bool DelNavPoint(int nav);

 // adds a Nav
-bool AddNav_Ship(const char *Nav, const char *TargetName, int flags);
-bool AddNav_Waypoint(const char *Nav, const char *WP_Path, int node, int flags);
+bool AddNav_Ship(char *Nav, char *TargetName, int flags); 
+bool AddNav_Waypoint(char *Nav, char *WP_Path, int node, int flags);

 // Sexp Accessors
-bool Nav_Set_Flag(const char *Nav, int flag);
-bool Nav_UnSet_Flag(const char *Nav, int flag);
+bool Nav_Set_Flag(char *Nav, int flag);
+bool Nav_UnSet_Flag(char *Nav, int flag);

-bool Nav_Set_Hidden(const char *Nav);
-bool Nav_Set_NoAccess(const char *Nav);
-bool Nav_Set_Visited(const char *Nav);
+bool Nav_Set_Hidden(char *Nav);
+bool Nav_Set_NoAccess(char *Nav);
+bool Nav_Set_Visited(char *Nav);

-bool Nav_UnSet_Hidden(const char *Nav);
-bool Nav_UnSet_NoAccess(const char *Nav);
-bool Nav_UnSet_Visited(const char *Nav);
+bool Nav_UnSet_Hidden(char *Nav);
+bool Nav_UnSet_NoAccess(char *Nav);
+bool Nav_UnSet_Visited(char *Nav);

 // Useful functions
-unsigned int DistanceTo(const char *nav);
+unsigned int DistanceTo(char *nav);
 unsigned int DistanceTo(int nav);

-bool IsVisited(const char *nav);
+bool IsVisited(char *nav);
 bool IsVisited(int nav);

-void send_autopilot_msg(const char *msg, const char *snd=nullptr);
+void send_autopilot_msg(char *msg, char *snd=NULL);
 void send_autopilot_msgID(int msgid);
 #endif

@@ -9,6 +9,18 @@
 *
 */

+/**
+ * @file bm_internal.h
+ * These are functions and types used by bmpman and a few others.
+ *
+ * @details It is a "protected" header that requires BMPMAN_INTERNAL to be defined before it can be included. This is to
+ * provide a small measure of safety since this functions can cause problems if not used correctly
+ */
+
+#ifndef BMPMAN_INTERNAL
+#error The file header "bmpman/bm_internal.h" is protected. Make sure you know what you are doing!
+#endif
+
 #include "bmpman/bmpman.h"

 #include <array>
@@ -46,7 +58,7 @@ union bm_extra_info {
 		// Stuff needed for user bitmaps
 		void* data;         //!< For user bitmaps, this is where the data comes from
 		ubyte bpp;          //!< For user bitmaps, this is what format the data is
-		ushort flags;        //!< For user bitmaps, Flags passed to bm_create
+		ubyte flags;        //!< For user bitmaps, Flags passed to bm_create
 	} user;
 };

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

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

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

 const size_t BM_BLOCK_SIZE = 4096;

@@ -10,9 +10,12 @@
 #define BMPMAN_NDEBUG
 #endif

-#define WIN32_LEAN_AND_MEAN
 #define BMPMAN_INTERNAL

+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 #include "anim/animplay.h"
 #include "anim/packunpack.h"
 #include "bmpman/bm_internal.h"
@@ -81,8 +84,6 @@ static bool bm_inited = false;
 static uint Bm_next_signature = 0x1234;
 static int Bm_low_mem = 0;

-SCP_map<int,ubyte*> bm_lookup_cache;
-
 /**
 * How much RAM bmpman can use for textures.
 *
@@ -157,20 +158,16 @@ bitmap_lookup::bitmap_lookup(int bitmap_num):
 	Width = be->bm.w;
 	Height = be->bm.h;

+	Bitmap_data = (ubyte*)vm_malloc(Width * Height * Num_channels * sizeof(ubyte));

-	auto cache_search = bm_lookup_cache.find(bitmap_num);
-	if (cache_search == bm_lookup_cache.end()) {
-		Bitmap_data = (ubyte*)vm_malloc(Width * Height * Num_channels * sizeof(ubyte));
-
-		gr_get_bitmap_from_texture((void*)Bitmap_data, bitmap_num);
-		bm_lookup_cache.insert({bitmap_num, Bitmap_data});
-	} else {
-		Bitmap_data = cache_search->second;
-	}
+	gr_get_bitmap_from_texture((void*)Bitmap_data, bitmap_num);
 }

 bitmap_lookup::~bitmap_lookup()
 {
+	if ( Bitmap_data != NULL ) {
+		vm_free(Bitmap_data);
+	}
 }

 bool bitmap_lookup::valid()
@@ -194,17 +191,10 @@ float bitmap_lookup::get_channel_alpha(float u, float v)
 	return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 3]) / 255.0f;
 }

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

 /**
 * Frees a bitmap's data if it can
@@ -584,7 +574,7 @@ int bm_create(int bpp, int w, int h, void *data, int flags) {
 	return n;
 }

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

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

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

 	if (!bm_inited) return -1;
@@ -974,9 +964,6 @@ int bm_is_compressed(int num) {
 	case BM_TYPE_DXT5:
 		return DDS_DXT5;

-	case BM_TYPE_BC7:
-		return DDS_BC7;
-
 	case BM_TYPE_CUBEMAP_DXT1:
 		return DDS_CUBEMAP_DXT1;

@@ -1050,10 +1037,6 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int
 			*c_type = BM_TYPE_DXT5;
 			break;

-		case DDS_BC7:
-			*c_type = BM_TYPE_BC7;
-			break;
-
 		case DDS_UNCOMPRESSED:
 			*c_type = BM_TYPE_DDS;
 			break;
@@ -1320,7 +1303,7 @@ bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int
 /**
 * Lock an image files data into memory
 */
-static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
+static int bm_load_image_data(int handle, int bpp, ubyte flags, bool nodebug)
 {
 	BM_TYPE c_type = BM_TYPE_NONE;
 	int true_bpp;
@@ -1396,7 +1379,6 @@ static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
 		case BM_TYPE_DXT1:
 		case BM_TYPE_DXT3:
 		case BM_TYPE_DXT5:
-		case BM_TYPE_BC7:
 		case BM_TYPE_CUBEMAP_DDS:
 		case BM_TYPE_CUBEMAP_DXT1:
 		case BM_TYPE_CUBEMAP_DXT3:
@@ -1836,7 +1818,7 @@ int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **
 	if (!res.found)
 		return -1;

-	CFILE *test = cfopen_special(res, "rb", dir_type);
+	CFILE *test = cfopen_special(res.full_name.c_str(), "rb", res.size, res.offset, res.data_ptr, dir_type);

 	if (test != NULL) {
 		if (img_cfp != NULL)
@@ -1846,11 +1828,11 @@ int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **
 	}

 	// umm, that's not good...
-	Warning(LOCATION, "Could not open file %s!", real_filename);
+	Warning(LOCATION, "Could not open file %s!", res.full_name.c_str());
 	return -1;
 }

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

 	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");
@@ -1872,7 +1854,7 @@ bitmap * bm_lock(int handle, int bpp, ushort flags, bool nodebug) {
 			Assert(bpp == 8);
 		} else if ((flags & BMP_TEX_NONCOMP) && (!(flags & BMP_TEX_COMP))) {
 			Assert(bpp >= 16);  // cheating but bpp passed isn't what we normally end up with
-		} else if ((flags & BMP_TEX_DXT1) || (flags & BMP_TEX_DXT3) || (flags & BMP_TEX_DXT5) || (flags & BMP_TEX_BC7)) {
+		} else if ((flags & BMP_TEX_DXT1) || (flags & BMP_TEX_DXT3) || (flags & BMP_TEX_DXT5)) {
 			Assert(bpp >= 16); // cheating but bpp passed isn't what we normally end up with
 		} else if (flags & BMP_TEX_CUBEMAP) {
 			Assert((be->type == BM_TYPE_CUBEMAP_DDS) ||
@@ -1951,7 +1933,7 @@ bitmap * bm_lock(int handle, int bpp, ushort flags, bool nodebug) {
 	return bmp;
 }

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


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


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

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

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

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

-void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags) {
+void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ubyte flags) {
 	ubyte *data = NULL;
 	int byte_size;
 	char filename[MAX_FILENAME_LEN];
@@ -2387,7 +2369,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) {
+void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ubyte flags) {
 	auto be = &bs->entry;

 	// Unload any existing data
@@ -2669,10 +2651,6 @@ void bm_page_in_texture(int bitmapnum, int nframes) {
 			frame_entry->used_flags = BMP_TEX_DXT5;
 			continue;

-		case BM_TYPE_BC7:
-			frame_entry->used_flags = BMP_TEX_BC7;
-			continue;
-
 		case BM_TYPE_CUBEMAP_DXT1:
 		case BM_TYPE_CUBEMAP_DXT3:
 		case BM_TYPE_CUBEMAP_DXT5:
@@ -2714,10 +2692,6 @@ void bm_page_in_xparent_texture(int bitmapnum, int nframes) {
 			entry->used_flags = BMP_TEX_DXT5;
 			continue;

-		case BM_TYPE_BC7:
-			entry->used_flags = BMP_TEX_BC7;
-			continue;
-
 		case BM_TYPE_CUBEMAP_DXT1:
 		case BM_TYPE_CUBEMAP_DXT3:
 		case BM_TYPE_CUBEMAP_DXT5:
@@ -2854,28 +2828,6 @@ int bm_release(int handle, int clear_render_targets) {
 	return 1;
 }

-bool bm_release_rendertarget(int handle) {
-	Assert(handle >= 0);
-
-	bitmap_entry* be = bm_get_entry(handle);
-
-	if (be->type == BM_TYPE_NONE) {
-		return false;	// Already been released?
-	}
-
-	Assertion(be->handle == handle, "Invalid bitmap handle number %d (expected %d) for %s passed to bm_release_rendertarget()\n", be->handle, handle, be->filename);
-	Assertion(!bm_is_anim(be), "Cannot release a render target of an animation (bitmap handle number %d for %s)!\n", be->handle, be->filename);
-
-	if (!((be->type == BM_TYPE_RENDER_TARGET_STATIC) || (be->type == BM_TYPE_RENDER_TARGET_DYNAMIC))) {
-		nprintf(("BmpMan", "Tried to release a render target of a non-rendered bitmap!\n"));
-		return false;
-	}
-
-	gr_bm_free_data(bm_get_slot(handle), false);
-
-	return true;
-}
-
 int bm_reload(int bitmap_handle, const char* filename) {
 	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");

@@ -40,12 +40,11 @@
 #define BMP_TEX_DXT1        (1<<3)      //!< dxt1 compressed 8r8g8b1a (24bit)
 #define BMP_TEX_DXT3        (1<<4)      //!< dxt3 compressed 8r8g8b4a (32bit)
 #define BMP_TEX_DXT5        (1<<5)      //!< dxt5 compressed 8r8g8b8a (32bit)
-#define BMP_TEX_BC7			(1<<6)		//!< BC7  compressed 8r8g8b8a (32bit)
-#define BMP_TEX_CUBEMAP     (1<<7)      //!< a texture made for cubic environment map
-#define BMP_MASK_BITMAP     (1<<8)      //!< a bitmap that will be used for masking mouse interaction. Typically not used in render operations
+#define BMP_TEX_CUBEMAP     (1<<6)      //!< a texture made for cubic environment map
+#define BMP_MASK_BITMAP     (1<<7)      //!< a bitmap that will be used for masking mouse interaction. Typically not used in render operations

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

@@ -75,7 +74,6 @@ enum BM_TYPE
 	BM_TYPE_DXT1,           //!< 24 bit with switchable alpha
 	BM_TYPE_DXT3,           //!< 32 bit with 4 bit alpha
 	BM_TYPE_DXT5,           //!< 32 bit with 8 bit alpha
-	BM_TYPE_BC7,			//!< 32-bit with variable alpha
 	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)
@@ -93,7 +91,7 @@ struct bitmap
 	short	rowsize;    //!< What you need to add to go to next row
 	int	bpp;        //!< Requested bitdepth of each pixel. ( 7, 8, 15, 16, 24, 32)
 	int	true_bpp;   //!< The image's actual bitdepth
-	ushort	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
+	ubyte	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
 	ptr_u	data;       //!< Pointer to data, or maybe offset into VRAM.
 	ubyte *palette;     /**< @brief   Pointer to this bitmap's palette (if it has one).
 	                     *   @details If BMP_NO_PALETTE_MAP flag is cleared, this palette just points to the screen palette. (gr_palette)
@@ -167,8 +165,6 @@ public:
 	float get_channel_alpha(float u, float v);
 };

-void clear_bm_lookup_cache();
-
 /**
 * @brief Loads a bitmap so we can draw with it later.
 *
@@ -261,21 +257,6 @@ int bm_unload_fast(int handle, int clear_render_targets = 0);
 */
 int bm_release(int handle, int clear_render_targets = 0);

-/**
- * @brief Detaches the render target of a bitmap if it exists
- *
- * @details Once called, this handle cannot be used as a target to switch the rendering context to
- *
- * @param handle               The index number of the bitmap to release
- *
- * @returns 1 on success,
- * @returns 0 otherwise
- *
- * @note If the passed handle is that of an ANI, it frees the render target of EVERY frame. Be sure to only pass the handle of the first frame!
- *
- */
-bool bm_release_rendertarget(int handle);
-
 /**
 * @brief Loads a bitmap sequance so we can draw with it.
 *
@@ -320,7 +301,7 @@ int bm_load_either(const char *filename, int *nframes = NULL, int *fps = NULL, i
 * @returns A pointer to the bitmap that's valid until bm_unlock is called if successful, or
 * @returns NULL if unsuccessful
 */
-bitmap* bm_lock(int handle, int bpp, ushort flags, bool nodebug = false);
+bitmap* bm_lock(int handle, int bpp, ubyte flags, bool nodebug = false);

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

 /**
 * @brief Gets the filename of the bitmap indexed by handle
@@ -319,14 +319,11 @@ void camera::get_info(vec3d *position, matrix *orientation)
 		{
 			object *objp = object_host.objp;
 			int model_num = object_get_model(objp);
-			polymodel *pm = nullptr;
-			polymodel_instance *pmi = nullptr;
+			polymodel *pm = NULL;
 			
-			if(model_num >= 0)
+			if(model_num > -1)
 			{
 				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)
@@ -342,16 +339,13 @@ void camera::get_info(vec3d *position, matrix *orientation)
 					Assertion(objp->type == OBJ_SHIP, "This part of the code expects the object to be a ship");

 					vec3d c_pos_in;
-					find_submodel_instance_point_normal(&c_pos_in, &host_normal, pm, pmi, eyep->parent, &eyep->pnt, &eyep->norm);
+					find_submodel_instance_point_normal(&c_pos_in, &host_normal, Ships[objp->instance].model_instance_num, eyep->parent, &eyep->pnt, &eyep->norm);
 					vm_vec_unrotate(&c_pos, &c_pos_in, &objp->orient);
 					vm_vec_add2(&c_pos, &objp->pos);
 				}
 				else
 				{
-					if (pmi != nullptr)
-						model_instance_find_world_point(&c_pos, &pt, pm, pmi, object_host_submodel, &objp->orient, &objp->pos);
-					else
-						model_find_world_point( &c_pos, &pt, pm, object_host_submodel, &objp->orient, &objp->pos );
+					model_find_world_point( &c_pos, &pt, pm->id, object_host_submodel, &objp->orient, &objp->pos );
 				}
 			}
 		}
@@ -380,16 +374,13 @@ void camera::get_info(vec3d *position, matrix *orientation)
 			{
 				object *objp = object_target.objp;
 				int model_num = object_get_model(objp);
-				polymodel *pm = nullptr;
-				polymodel_instance *pmi = nullptr;
+				polymodel *pm = NULL;
 				vec3d target_pos = vmd_zero_vector;
 				
 				//See if we can get the model
-				if(model_num >= 0)
+				if(model_num > -1)
 				{
 					pm = model_get(model_num);
-					if (objp->type == OBJ_SHIP)
-						pmi = model_get_instance(Ships[objp->instance].model_instance_num);
 				}

 				//If we don't have a submodel or don't have the model use object pos
@@ -400,10 +391,7 @@ void camera::get_info(vec3d *position, matrix *orientation)
 				}
 				else
 				{
-					if (pmi != nullptr)
-						model_instance_find_world_point(&target_pos, &vmd_zero_vector, pm, pmi, object_target_submodel, &objp->orient, &objp->pos);
-					else
-						model_find_world_point( &target_pos, &vmd_zero_vector, pm, object_target_submodel, &objp->orient, &objp->pos );
+					model_find_world_point( &target_pos, &vmd_zero_vector, pm->id, object_target_submodel, &objp->orient, &objp->pos );
 				}

 				vec3d targetvec;
@@ -1107,35 +1095,3 @@ eye* get_submodel_eye(polymodel *pm, int submodel_num)
 	}
 	return NULL;
 }
-
-// maybe push the camera away from preferred dist if it would intersect the ship's bounding box
-float cam_get_bbox_dist(const object* viewer_obj, float preferred_distance, const matrix* cam_orient) {
-	if (viewer_obj == nullptr)
-		return preferred_distance;
-
-	// radius is the maximal extent of the ship's bbox from the center, so if its at least that plus the padding its guaranteed to be good
-	// plus a little fudge factor at the end because shields count against the bounding box, but not the radius
-	if (preferred_distance > (viewer_obj->radius * EXTERN_CAM_BBOX_MULTIPLIER_PADDING + EXTERN_CAM_BBOX_CONSTANT_PADDING) * 1.5f) 
-		return preferred_distance;
-	
-	int modelnum = object_get_model(viewer_obj);
-	polymodel* pm = model_get(modelnum);
-	vec3d adjusted_bbox;
-	const vec3d* cam_vec = &cam_orient->vec.fvec;
-
-	// the bounding box is expanded by the padding and maybe use negative min instead of max, because they could differ significantly
-	// and we only care about the one thats on the side of the camera
-	adjusted_bbox.xyz.x = (cam_vec->xyz.x < 0 ? -pm->mins.xyz.x : pm->maxs.xyz.x) * EXTERN_CAM_BBOX_MULTIPLIER_PADDING + EXTERN_CAM_BBOX_CONSTANT_PADDING;
-	adjusted_bbox.xyz.y = (cam_vec->xyz.y < 0 ? -pm->mins.xyz.y : pm->maxs.xyz.y) * EXTERN_CAM_BBOX_MULTIPLIER_PADDING + EXTERN_CAM_BBOX_CONSTANT_PADDING;
-	adjusted_bbox.xyz.z = (cam_vec->xyz.z < 0 ? -pm->mins.xyz.z : pm->maxs.xyz.z) * EXTERN_CAM_BBOX_MULTIPLIER_PADDING + EXTERN_CAM_BBOX_CONSTANT_PADDING;
-
-	vec3d adjusted_dist;
-	// adjusted_dist is the vector (with an inverted magnitude) that contacts the surface of an 
-	// ellipsoid which contacts the adjusted_bbox at each of its faces 
-	adjusted_dist.xyz.x = cam_vec->xyz.x / adjusted_bbox.xyz.x;
-	adjusted_dist.xyz.y = cam_vec->xyz.y / adjusted_bbox.xyz.y;
-	adjusted_dist.xyz.z = cam_vec->xyz.z / adjusted_bbox.xyz.z;
-	float compensation =  vm_vec_mag(&adjusted_dist);
-
-	return fmaxf(1 / compensation, preferred_distance);
-}
@@ -15,9 +15,6 @@
 #define CAM_STATIONARY_POS			(1<<2)
 #define CAM_DEFAULT_FLAGS			0

-#define	EXTERN_CAM_BBOX_CONSTANT_PADDING			5.0f
-#define	EXTERN_CAM_BBOX_MULTIPLIER_PADDING			1.5f
-
 class camera
 {
 protected:
@@ -167,7 +164,6 @@ camid cam_lookup(const char* name);
 camid cam_get_camera(uint index);
 camid cam_get_current();
 size_t cam_get_num();
-float cam_get_bbox_dist(const object* viewer_obj, float preferred_distance, const matrix* cam_orient);

 void get_turret_cam_pos(camera *cam, vec3d *pos);
 void get_turret_cam_orient(camera *cam, matrix *ori);
@@ -38,9 +38,6 @@

 #include <limits>

-char Cfile_root_dir[CFILE_ROOT_DIRECTORY_LEN] = "";
-char Cfile_user_dir[CFILE_ROOT_DIRECTORY_LEN] = "";
-
 // During cfile_init, verify that Pathtypes[n].index == n for each item
 // Each path must have a valid parent that can be tracable all the way back to the root
 // so that we can create directories when we need to.
@@ -57,7 +54,7 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ CF_TYPE_MAPS,					"data" DIR_SEPARATOR_STR "maps",											".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
 	{ CF_TYPE_TEXT,					"data" DIR_SEPARATOR_STR "text",											".txt .net",						CF_TYPE_DATA	},
 	{ CF_TYPE_MODELS,				"data" DIR_SEPARATOR_STR "models",											".pof",								CF_TYPE_DATA	},
-	{ CF_TYPE_TABLES,				"data" DIR_SEPARATOR_STR "tables",											".tbl .tbm .lua",						CF_TYPE_DATA	},
+	{ CF_TYPE_TABLES,				"data" DIR_SEPARATOR_STR "tables",											".tbl .tbm",						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	},
@@ -71,7 +68,7 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ 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",	CF_TYPE_DATA	},
-	{ CF_TYPE_FONT,					"data" DIR_SEPARATOR_STR "fonts",											".vf .ttf .otf",						CF_TYPE_DATA	},
+	{ CF_TYPE_FONT,					"data" DIR_SEPARATOR_STR "fonts",											".vf .ttf",							CF_TYPE_DATA	},
 	{ CF_TYPE_EFFECTS,				"data" DIR_SEPARATOR_STR "effects",											".ani .eff .pcx .neb .tga .jpg .png .dds .sdr",	CF_TYPE_DATA	},
 	{ CF_TYPE_HUD,					"data" DIR_SEPARATOR_STR "hud",												".pcx .ani .eff .tga .jpg .png .dds",	CF_TYPE_DATA	},
 	{ CF_TYPE_PLAYERS,				"data" DIR_SEPARATOR_STR "players",											".hcf",								CF_TYPE_DATA	},
@@ -103,20 +100,18 @@ static char Cfile_stack[CFILE_STACK_MAX][CFILE_ROOT_DIRECTORY_LEN];

 std::array<CFILE, MAX_CFILE_BLOCKS> Cfile_block_list;

-static const char *Cfile_cdrom_dir = NULL;
-
 //
 // Function prototypes for internally-called functions
 //
 static int cfget_cfile_block();
-static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* original_filename, FILE * fp, int type);
-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);
+static CFILE *cf_open_fill_cfblock(const char* source, int line, FILE * fp, int type);
+static CFILE *cf_open_packed_cfblock(const char* source, int line, FILE *fp, int type, size_t offset, size_t size);
+static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, 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);
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, 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);
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, FILE *fp, int type);
 #endif

 static void cf_chksum_long_init();
@@ -147,47 +142,15 @@ void cfile_close()
 	#define MIN_NUM_PATH_COMPONENTS 3     /* Drive + directory + file */
 #endif

-/**
- * @brief Determine if the given path is in the root directory
- *
- * @param exe_path Path to executable
- *
- * @return true if root directory, false if not
- */
-static bool cfile_in_root_dir(const char *exe_path)
-{
-	int new_token;
-	int token_count = 0;
-	const char *p = exe_path;
-
-	Assert(exe_path != NULL);
-
-	do {
-		new_token = 0;
-		while (*p == DIR_SEPARATOR_CHAR) {
-			p++;
-		}
-
-		while ((*p != '\0') && (*p != DIR_SEPARATOR_CHAR)) {
-			new_token = 1;
-			p++;
-		}
-		token_count += new_token;
-	} while (*p != '\0');
-
-	return (token_count < MIN_NUM_PATH_COMPONENTS);
-}
-
 /**
 * @brief Initialize the cfile system. Called once at application start.
 *
 * @param exe_dir Path to a file (not a directory)
- * @param cdrom_dir Path to a CD drive mount point (may be NULL)
 *
 * @return 0 On success
 * @return 1 On error
 */
-int cfile_init(const char *exe_dir, const char *cdrom_dir)
+int cfile_init(const SCP_vector<cfile::ModRoot>& modRoots)
 {
 	// initialize encryption
 	encrypt_init();	
@@ -196,36 +159,8 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)
 		return 0;
 	}

-	char buf[CFILE_ROOT_DIRECTORY_LEN];
-
-	strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1);
-	buf[CFILE_ROOT_DIRECTORY_LEN - 1] = '\0';
-
-	// are we in a root directory?		
-	if(cfile_in_root_dir(buf)){
-		os::dialogs::Message(os::dialogs::MESSAGEBOX_ERROR, "FreeSpace2/Fred2 cannot be run from a drive root directory!");
-		return 1;
-	}		
-
 	// This needs to be set here because cf_build_secondary_filelist assumes it to be true
 	cfile_inited = 1;
-	
-	/*
-	 * Determine the executable's directory.  Note that DIR_SEPARATOR_CHAR
-	 * is guaranteed to be found in the string else cfile_in_root_dir()
-	 * would have failed.
-	 */
-
-	char *p;
-
-	p = strrchr(buf, DIR_SEPARATOR_CHAR);
-	*p = '\0';
-
-	cfile_chdir(buf);
-
-	// set root directory
-	strcpy_s(Cfile_root_dir, buf);
-	strcpy_s(Cfile_user_dir, os_get_config_path().c_str());

 	// Initialize the block list with proper data
 	Cfile_block_list.fill({});
@@ -233,8 +168,7 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)
 	// 32 bit CRC table init
 	cf_chksum_long_init();

-	Cfile_cdrom_dir = cdrom_dir;
-	cf_build_secondary_filelist(Cfile_cdrom_dir);
+	cf_build_secondary_filelist(modRoots);

 	return 0;
 }
@@ -675,10 +609,13 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 	
 	if ( strchr(mode,'w') || strchr(mode,'+') || strchr(mode,'a') )	{
 		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 ) {
+#ifdef SCP_UNIX
+		if ( strpbrk(file_path, "/") ) {
+#else
+		if ( strpbrk(file_path,"/\\:")  ) {
+#endif
 			// Full path given?
 			strcpy_s(longname, file_path );
 		} else {
@@ -694,7 +631,7 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*

 		// JOHN: TODO, you should create the path if it doesn't exist.
 		
-		//WMC - For some reason, fread does not return the correct number of bytes read
+		//WMC - For some godawful reason, fread does not return the correct number of bytes read
 		//in text mode, which messes up FS2_Open's raw_position indicator in fgets. As a consequence, you
 		//_must_ open files that are gonna be read in binary mode.

@@ -729,7 +666,7 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*

 		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);
+			return cf_open_fill_cfblock(source, line, fp, dir_type);
 		}
 		return NULL;
 	} 
@@ -757,19 +694,20 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 				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);
+					return cf_open_mapped_fill_cfblock(source, line, 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);
+					return cf_open_mapped_fill_cfblock(source, line, 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 _cfopen_special(source, line, find_res.full_name.c_str(), mode, find_res.size, find_res.offset,
+			                       find_res.data_ptr, dir_type);
 		}

 	}
@@ -788,14 +726,14 @@ CFILE* _cfopen(const char* source, int line, const char* file_path, const char*
 // returns:		success	==> address of CFILE structure
 //				error	==> NULL
 //
-CFILE *_cfopen_special(const char* source, int line, const CFileLocation &res, const char* mode, int dir_type)
+CFILE *_cfopen_special(const char* source, int line, const char *file_path, const char *mode, const size_t size, const size_t offset, const void* data, int dir_type)
 {
 	if ( !cfile_inited) {
 		Int3();
 		return NULL;
 	}

-	Assert( !res.full_name.empty() );
+	Assert( file_path && strlen(file_path) );
 	Assert( mode != NULL );

 	// cfopen_special() only supports reading files, not creating them
@@ -805,21 +743,21 @@ CFILE *_cfopen_special(const char* source, int line, const CFileLocation &res, c
 	}

 	// In-Memory files are a bit different from normal files so we need to handle them separately
-	if (res.data_ptr != nullptr) {
-		return cf_open_memory_fill_cfblock(source, line, res.name_ext.c_str(), res.data_ptr, res.size, dir_type);
+	if (data != nullptr) {
+		return cf_open_memory_fill_cfblock(source, line, data, size, dir_type);
 	}
 	else {
 		// "file_path" should already be a fully qualified path, so just try to open it
-		FILE *fp = fopen(res.full_name.c_str(), "rb");
+		FILE *fp = fopen(file_path, "rb");

 		if (fp) {
-			if (res.offset) {
+			if (offset) {
 				// Found it in a pack file
-				return cf_open_packed_cfblock(source, line, res.name_ext.c_str(), fp, dir_type, res.offset, res.size);
+				return cf_open_packed_cfblock(source, line, fp, dir_type, offset, size);
 			}
 			else {
 				// Found it in a normal file
-				return cf_open_fill_cfblock(source, line, res.name_ext.c_str(), fp, dir_type);
+				return cf_open_fill_cfblock(source, line, fp, dir_type);
 			}
 		}
 	}
@@ -842,7 +780,7 @@ CFILE *ctmpfile()
 	FILE	*fp;
 	fp = tmpfile();
 	if ( fp )
-		return cf_open_fill_cfblock(LOCATION, "<temporary file>", fp, 0);
+		return cf_open_fill_cfblock(LOCATION, fp, 0);
 	else
 		return NULL;
 }
@@ -949,7 +887,7 @@ int cf_is_valid(CFILE *cfile)
 // returns:   success ==> ptr to CFILE structure.  
 //            error   ==> NULL
 //
-static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* original_filename, FILE *fp, int type)
+static CFILE *cf_open_fill_cfblock(const char* source, int line, FILE *fp, int type)
 {
 	int cfile_block_index;

@@ -965,7 +903,6 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 		cfp->dir_type = type;
 		cfp->max_read_len = 0;

-		cfp->original_filename = original_filename;
 		cfp->source_file = source;
 		cfp->line_num = line;
 		
@@ -985,7 +922,7 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 // returns:   success ==> ptr to CFILE structure.  
 //            error   ==> NULL
 //
-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_packed_cfblock(const char* source, int line, FILE *fp, int type, size_t offset, size_t size)
 {
 	// Found it in a pack file
 	int cfile_block_index;
@@ -1003,7 +940,6 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* o
 		cfp->dir_type = type;
 		cfp->max_read_len = 0;

-		cfp->original_filename = original_filename;
 		cfp->source_file = source;
 		cfp->line_num = line;

@@ -1022,9 +958,9 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* o
 // 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)
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, 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)
+static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, FILE *fp, int type)
 #endif
 {
 	int cfile_block_index;
@@ -1047,7 +983,6 @@ static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const ch
 #endif
 		cfp->dir_type = type;

-		cfp->original_filename = original_filename;
 		cfp->source_file = source;
 		cfp->line_num = line;

@@ -1077,7 +1012,7 @@ static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const ch
 	}
 }

-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)
+static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const void* data, size_t size, int dir_type)
 {
 	int cfile_block_index;

@@ -1093,7 +1028,6 @@ static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const ch
 		cfp->mem_mapped = false;
 		cfp->dir_type = dir_type;

-		cfp->original_filename = original_filename;
 		cfp->source_file = source;
 		cfp->line_num = line;

@@ -1104,12 +1038,7 @@ static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const ch
 	}
 }

-const char *cf_get_filename(const CFILE *cfile)
-{
-	return cfile->original_filename.c_str();
-}
-
-int cf_get_dir_type(const CFILE *cfile)
+int cf_get_dir_type(CFILE *cfile)
 {
 	return cfile->dir_type;
 }
@@ -18,7 +18,6 @@
 #include <ctime>
 #include <stdexcept>
 #include <memory>
-#include <utility>


 #define CF_EOF (-1)
@@ -166,21 +165,29 @@ extern const char *Get_file_list_child;

 // cfile directory. valid after cfile_init() returns successfully
 #define CFILE_ROOT_DIRECTORY_LEN			256
-extern char Cfile_root_dir[CFILE_ROOT_DIRECTORY_LEN];
-extern char Cfile_user_dir[CFILE_ROOT_DIRECTORY_LEN];
+
+namespace cfile {
+enum class ModRootType { Unknown, Folder, Package };
+
+enum class LocationType { Unknown, SecondaryMod, PrimaryMod, GameRoot };
+
+struct ModRoot {
+	ModRootType type = ModRootType::Unknown;
+	SCP_string path;
+	LocationType location_type = LocationType::Unknown;
+	bool user_location         = false;
+};
+} // namespace cfile

 //================= LOW-LEVEL FUNCTIONS ==================
-int cfile_init(const char *exe_dir, const char *cdrom_dir=NULL);
+int cfile_init(const SCP_vector<cfile::ModRoot>& modRoots);
 void cfile_close();

 // add an extension to a filename if it doesn't already have it
 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);
-
 // return CF_TYPE (directory location type) of a CFILE you called cfopen() successfully on.
-int cf_get_dir_type(const CFILE *cfile);
+int cf_get_dir_type(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.
@@ -188,12 +195,10 @@ CFILE* _cfopen(const char* source_file, int line, const char* filename, const ch
               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

-struct CFileLocation;
-
 // like cfopen(), but it accepts a fully qualified path only (ie, the result of a cf_find_file_location() call)
 // NOTE: only supports reading files!!
-CFILE *_cfopen_special(const char* source_file, int line, const CFileLocation &res, const char* mode,
-	                   int dir_type = CF_TYPE_ANY);
+CFILE *_cfopen_special(const char* source_file, int line, const char *file_path, const char *mode,
+	const size_t size, const size_t offset, const void* data, int dir_type = CF_TYPE_ANY);
 #define cfopen_special(...) _cfopen_special(LOCATION, __VA_ARGS__) // Pass source location to the function

 // Flush the open file buffer
@@ -297,10 +302,6 @@ uint cf_add_chksum_long(uint seed, ubyte *buffer, size_t size);
 #define CF_RENAME_FAIL_EXIST			2					// old name does not exist
 int cf_rename(const char *old_name, const char *name, int type = CF_TYPE_ANY );

-// Creates the directory path if it doesn't exist. Even creates all its
-// parent paths.
-void cf_create_directory(int dir_type, uint32_t location_flags = CF_LOCATION_ALL);
-
 // changes the attributes of a file
 void cf_attrib(const char *name, int set, int clear, int type);

@@ -374,7 +375,6 @@ void cf_sort_filenames( SCP_vector<SCP_string> &list, int sort, SCP_vector<file_

 struct CFileLocation {
 	bool found = false;
-	SCP_string name_ext;
 	SCP_string full_name;
 	size_t size          = 0;
 	size_t offset        = 0;
@@ -444,13 +444,13 @@ namespace cfile
 			{
 			}

-			explicit cfile_error(std::string excuse) : m_excuse(std::move(excuse))
+			explicit cfile_error(const std::string &excuse) : m_excuse(excuse)
 			{
 			}

-			~cfile_error() noexcept override = default;
+			~cfile_error() SCP_NOEXCEPT override {}

-			const char *what() const noexcept override {
+			const char *what() const SCP_NOEXCEPT override {
 				return m_excuse.c_str();
 			}

@@ -8,15 +8,14 @@
 */ 


+
 #ifndef _CFILEARCHIVE_H
 #define _CFILEARCHIVE_H

 #ifndef _CFILE_INTERNAL 
-#pragma message("This file should only be included internally in CFILE!!")
+#error This file should only be included internally in CFILE!!
 #endif

-#include "globalincs/pstypes.h"
-
 // The following Cfile_block data is private to cfile.cpp
 // DO NOT MOVE the Cfile_block* information to cfile.h / do not extern this data
 //
@@ -41,7 +40,6 @@ struct CFILE {

 	size_t max_read_len;    // max read offset, for special error handling

-	SCP_string original_filename;
 	const char* source_file;
 	int line_num;
 };
@@ -0,0 +1,266 @@
+#define _CFILE_INTERNAL
+
+#include "cfilemod.h"
+#include "cfile.h"
+#include "cmdline/cmdline.h"
+#include "osapi/osapi.h"
+#include "cfilesystem.h"
+
+#ifdef SCP_UNIX
+#include <glob.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fnmatch.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <libgen.h>
+#endif
+
+namespace cfile {
+
+namespace {
+
+typedef struct cf_root_sort {
+	SCP_string path;
+	int cf_type;
+} cf_root_sort;
+
+// packfile sort function
+bool cf_packfile_sort_func(const cf_root_sort& r1, const cf_root_sort& r2) {
+	// if the 2 directory types are the same, do a string compare
+	if (r1.cf_type == r2.cf_type) {
+		return (stricmp(r1.path.c_str(), r2.path.c_str()) < 0);
+	}
+
+	// otherwise return them in order of CF_TYPE_* precedence
+	return (r1.cf_type < r2.cf_type);
+}
+
+// Go through a root and look for pack files
+void build_pack_list(SCP_vector<ModRoot>& mod_roots,
+                     const SCP_string& search_path,
+                     LocationType location_type,
+                     bool user_location) {
+	char filespec[MAX_PATH_LEN];
+
+	// allocate a temporary array of temporary roots so we can easily sort them
+	SCP_vector<cf_root_sort> temp_roots_sort;
+
+	// now just setup all the root info
+	for (int i = CF_TYPE_ROOT; i < CF_MAX_PATH_TYPES; i++) {
+		strcpy_s(filespec, search_path.c_str());
+
+		if (strlen(Pathtypes[i].path)) {
+			strcat_s(filespec, Pathtypes[i].path);
+
+			if (filespec[strlen(filespec) - 1] != DIR_SEPARATOR_CHAR)
+				strcat_s(filespec, DIR_SEPARATOR_STR);
+		}
+
+#if defined _WIN32
+			strcat_s( filespec, "*.vp" );
+
+		intptr_t find_handle;
+		_finddata_t find;
+
+		find_handle = _findfirst( filespec, &find );
+
+		 if (find_handle != -1) {
+			do {
+				// add the new item
+				if (!(find.attrib & _A_SUBDIR)) {
+
+					// get a temp pointer
+					rptr_sort = &temp_roots_sort[root_index++];
+
+					// fill in all the proper info
+					strcpy_s(rptr_sort->path, root->path);
+
+					if(strlen(Pathtypes[i].path)) {
+
+						strcat_s(rptr_sort->path, Pathtypes[i].path );
+						strcat_s(rptr_sort->path, DIR_SEPARATOR_STR);
+					}
+
+					strcat_s(rptr_sort->path, find.name );
+					rptr_sort->roottype = CF_ROOTTYPE_PACK;
+					rptr_sort->cf_type = i;
+				}
+
+			} while (!_findnext(find_handle, &find));
+
+			_findclose( find_handle );
+		}
+#elif defined SCP_UNIX
+		strcat_s(filespec, "*.[vV][pP]");
+		glob_t globinfo;
+
+		memset(&globinfo, 0, sizeof(globinfo));
+
+		int status = glob(filespec, 0, NULL, &globinfo);
+
+		if (status == 0) {
+			for (uint j = 0; j < globinfo.gl_pathc; j++) {
+				// Determine if this is a regular file
+				struct stat statbuf;
+				memset(&statbuf, 0, sizeof(statbuf));
+				stat(globinfo.gl_pathv[j], &statbuf);
+
+				if (S_ISREG(statbuf.st_mode)) {
+
+					cf_root_sort sort;
+
+					// fill in all the proper info
+					sort.path = globinfo.gl_pathv[j];
+					sort.cf_type = i;
+					temp_roots_sort.push_back(sort);
+				}
+			}
+
+			globfree(&globinfo);
+		}
+#endif
+	}
+
+	// sort the roots
+	std::sort(temp_roots_sort.begin(), temp_roots_sort.end(), cf_packfile_sort_func);
+
+	// now insert them all into the real root list properly
+	for (const auto& pack_root : temp_roots_sort) {
+		ModRoot root;
+		root.type = ModRootType::Package;
+		root.path = pack_root.path;
+		root.user_location = user_location;
+		root.location_type = location_type;
+
+		mod_roots.push_back(root);
+	}
+}
+
+char normalize_directory_separator(char in) {
+	if (in == '/') {
+		return DIR_SEPARATOR_CHAR;
+	}
+
+	return in;
+}
+
+void
+add_mod_roots(SCP_vector<ModRoot>& mod_roots, const char* mod_cmdline, const SCP_string& rootDirectory, bool user_location) {
+	if (mod_cmdline) {
+		bool primary = true;
+		for (const char* cur_pos = mod_cmdline; strlen(cur_pos) != 0; cur_pos += (strlen(cur_pos) + 1)) {
+			SCP_stringstream ss;
+			ss << rootDirectory;
+
+			if (rootDirectory.back() != DIR_SEPARATOR_CHAR) {
+				ss << DIR_SEPARATOR_CHAR;
+			}
+
+			ss << cur_pos << DIR_SEPARATOR_STR;
+
+			SCP_string rootPath = ss.str();
+
+			// normalize the path to the native path format
+			std::transform(rootPath.begin(), rootPath.end(), rootPath.begin(), normalize_directory_separator);
+
+			ModRoot root;
+			root.type = ModRootType::Folder;
+			root.path = rootPath;
+			root.user_location = user_location;
+
+			if (primary) {
+				root.location_type = LocationType::PrimaryMod;
+			} else {
+				root.location_type = LocationType::SecondaryMod;
+			}
+
+			mod_roots.push_back(root);
+
+			build_pack_list(mod_roots, rootPath, root.location_type, user_location);
+
+			primary = false;
+		}
+	}
+}
+
+}
+
+SCP_vector<ModRoot> getModRootsFromModCmdline(const SCP_string& content_root, const char* mod_cmdline) {
+	SCP_vector<ModRoot> mod_roots;
+
+	if (os_is_legacy_mode()) {
+		// =========================================================================
+#ifdef WIN32
+		// Nothing to do here, Windows uses the current directory as the base
+#else
+		add_mod_roots(mod_roots, mod_cmdline, os_get_legacy_user_dir(), true);
+
+		ModRoot root;
+		root.type = ModRootType::Folder;
+		root.path = os_get_legacy_user_dir();
+		root.user_location = true;
+		root.location_type = LocationType::GameRoot;
+
+		// do we already have a slash? as in the case of a root directory install
+		if (root.path.back() != DIR_SEPARATOR_CHAR) {
+			root.path += DIR_SEPARATOR_STR;        // put trailing backslash on for easier path construction
+		}
+
+		mod_roots.push_back(root);
+
+		// Next, check any VP files under the current directory.
+		build_pack_list(mod_roots, root.path, root.location_type, root.user_location);
+#endif
+		// =========================================================================
+	} else if (!Cmdline_portable_mode) {
+		// =========================================================================
+		// now look for mods under the users HOME directory to use before system ones
+		add_mod_roots(mod_roots, mod_cmdline, os_get_config_path(), true);
+		// =========================================================================
+
+		// =========================================================================
+		// set users HOME directory as default for loading and saving files
+		ModRoot root;
+		root.type = ModRootType::Folder;
+		root.path = os_get_config_path();
+		root.user_location = true;
+		root.location_type = LocationType::GameRoot;
+
+		// do we already have a slash? as in the case of a root directory install
+		if (root.path.back() != DIR_SEPARATOR_CHAR) {
+			root.path += DIR_SEPARATOR_STR;        // put trailing backslash on for easier path construction
+		}
+
+		mod_roots.push_back(root);
+
+		// Next, check any VP files under the current directory.
+		build_pack_list(mod_roots, root.path, root.location_type, root.user_location);
+		// =========================================================================
+	}
+
+	add_mod_roots(mod_roots, mod_cmdline, content_root, false);
+
+	ModRoot root;
+	root.type = ModRootType::Folder;
+	root.path = content_root;
+	root.user_location = false;
+	root.location_type = LocationType::GameRoot;
+
+	// do we already have a slash? as in the case of a root directory install
+	if (root.path.back() != DIR_SEPARATOR_CHAR) {
+		root.path += DIR_SEPARATOR_STR;        // put trailing backslash on for easier path construction
+	}
+
+	mod_roots.push_back(root);
+
+	//======================================================
+	// Next, check any VP files under the current directory.
+	build_pack_list(mod_roots, root.path, root.location_type, root.user_location);
+
+	return mod_roots;
+}
+
+}
+
+
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+#include "cfile/cfile.h"
+
+namespace cfile {
+
+SCP_vector<ModRoot> getModRootsFromModCmdline(const SCP_string& content_root, const char* mod_cmdline);
+
+}
@@ -160,379 +160,113 @@ cf_root *cf_create_root()
 	return &Root_blocks[block]->roots[offset];
 }

-// return the # of packfiles which exist
-int cf_get_packfile_count(cf_root *root)
+static bool has_mod_location(const SCP_vector<cfile::ModRoot>& modRoots)
 {
-	SCP_string filespec;
-	int i;
-	int packfile_count;
-
-	// count up how many packfiles we're gonna have
-	packfile_count = 0;
-	for (i=CF_TYPE_ROOT; i<CF_MAX_PATH_TYPES; i++ )
+	for (const auto& root : modRoots)
 	{
-		filespec = root->path;
-		
-		if(strlen(Pathtypes[i].path))
+		if (root.location_type == cfile::LocationType::PrimaryMod)
 		{
-			filespec += Pathtypes[ i ].path;
-			if ( filespec[ filespec.length( ) - 1 ] != DIR_SEPARATOR_CHAR )
-			{
-				filespec += DIR_SEPARATOR_STR;
-			}
-		}
-
-#if defined _WIN32
-		filespec += "*.vp";
-
-		intptr_t find_handle;
-		_finddata_t find;
-		
-		find_handle = _findfirst( filespec.c_str( ), &find );
-
- 		if (find_handle != -1) {
-			do {
-				if (!(find.attrib & _A_SUBDIR)) {
-					packfile_count++;
-				}
-
-			} while (!_findnext(find_handle, &find));
-
-			_findclose( find_handle );
-		}	
-#elif defined SCP_UNIX
-		filespec += "*.[vV][pP]";
-
-		glob_t globinfo;
-		memset(&globinfo, 0, sizeof(globinfo));
-		int status = glob(filespec.c_str( ), 0, NULL, &globinfo);
-		if (status == 0) {
-			for (unsigned int j = 0;  j < globinfo.gl_pathc;  j++) {
-				// Determine if this is a regular file
-				struct stat statbuf;
-				memset(&statbuf, 0, sizeof(statbuf));
-				stat(globinfo.gl_pathv[j], &statbuf);
-				if (S_ISREG(statbuf.st_mode)) {
-					packfile_count++;
-				}
-			}
-			globfree(&globinfo);
-		}
-#endif
-	}
-
-	return packfile_count;
-}
-
-// packfile sort function
-bool cf_packfile_sort_func(const cf_root_sort &r1, const cf_root_sort &r2)
-{
-	// if the 2 directory types are the same, do a string compare
-	if (r1.cf_type == r2.cf_type) {
-		return (stricmp(r1.path, r2.path) < 0);
-	}
-
-	// otherwise return them in order of CF_TYPE_* precedence
-	return (r1.cf_type < r2.cf_type);
-}
-
-// Go through a root and look for pack files
-void cf_build_pack_list( cf_root *root )
-{
-	char filespec[MAX_PATH_LEN];
-	int i;
-	cf_root_sort *temp_roots_sort, *rptr_sort;
-	int temp_root_count, root_index;
-
-	// determine how many packfiles there are
-	temp_root_count = cf_get_packfile_count(root);
-
-	if (temp_root_count <= 0)
-		return;
-
-	// allocate a temporary array of temporary roots so we can easily sort them
-	temp_roots_sort = (cf_root_sort*)vm_malloc(sizeof(cf_root_sort) * temp_root_count);
-
-	if (temp_roots_sort == NULL) {
-		Int3();
-		return;
-	}
-
-	// now just setup all the root info
-	root_index = 0;
-	for (i = CF_TYPE_ROOT; i < CF_MAX_PATH_TYPES; i++) {
-		strcpy_s( filespec, root->path );
-		
-		if ( strlen(Pathtypes[i].path) ) {
-			strcat_s( filespec, Pathtypes[i].path );
-
-			if ( filespec[strlen(filespec)-1] != DIR_SEPARATOR_CHAR )
-				strcat_s( filespec, DIR_SEPARATOR_STR );
-		}
-
-#if defined _WIN32
-		strcat_s( filespec, "*.vp" );
-
-		intptr_t find_handle;
-		_finddata_t find;
-		
-		find_handle = _findfirst( filespec, &find );
-
- 		if (find_handle != -1) {
-			do {
-				// add the new item
-				if (!(find.attrib & _A_SUBDIR)) {					
-					Assert(root_index < temp_root_count);
-
-					// get a temp pointer
-					rptr_sort = &temp_roots_sort[root_index++];
-
-					// fill in all the proper info
-					strcpy_s(rptr_sort->path, root->path);
-					
-					if(strlen(Pathtypes[i].path)) {
-
-						strcat_s(rptr_sort->path, Pathtypes[i].path );
-						strcat_s(rptr_sort->path, DIR_SEPARATOR_STR);
-					}
-					
-					strcat_s(rptr_sort->path, find.name );
-					rptr_sort->roottype = CF_ROOTTYPE_PACK;
-					rptr_sort->cf_type = i;
-				}
-
-			} while (!_findnext(find_handle, &find));
-
-			_findclose( find_handle );
-		}	
-#elif defined SCP_UNIX
-		strcat_s( filespec, "*.[vV][pP]" );
-		glob_t globinfo;
-
-		memset(&globinfo, 0, sizeof(globinfo));
-
-		int status = glob(filespec, 0, NULL, &globinfo);
-
-		if (status == 0) {
-			for (uint j = 0;  j < globinfo.gl_pathc;  j++) {
-				// Determine if this is a regular file
-				struct stat statbuf;
-				memset(&statbuf, 0, sizeof(statbuf));
-				stat(globinfo.gl_pathv[j], &statbuf);
-
-				if ( S_ISREG(statbuf.st_mode) ) {
-					Assert(root_index < temp_root_count);
-
-					// get a temp pointer
-					rptr_sort = &temp_roots_sort[root_index++];
-
-					// fill in all the proper info
-					strcpy_s(rptr_sort->path, globinfo.gl_pathv[j] );
-					rptr_sort->roottype = CF_ROOTTYPE_PACK;
-					rptr_sort->cf_type = i;
-				}
-			}
-
-			globfree(&globinfo);
-		}
-#endif
-	}
-
-	// these should always be the same
-	Assert(root_index == temp_root_count);
-
-	// sort the roots
-	std::sort(temp_roots_sort, temp_roots_sort + temp_root_count, cf_packfile_sort_func);
-
-	// now insert them all into the real root list properly
-	for (i = 0; i < temp_root_count; i++) {
-		auto new_root            = cf_create_root();
-		new_root->location_flags = root->location_flags;
-		strcpy_s( new_root->path, root->path );
-
-#ifndef NDEBUG
-		uint chksum = 0;
-		cf_chksum_pack(temp_roots_sort[i].path, &chksum);
-		mprintf(("Found root pack '%s' with a checksum of 0x%08x\n", temp_roots_sort[i].path, chksum));
-#endif
-
-		// mwa -- 4/2/98 put in the next 2 lines because the path name needs to be there
-		// to find the files.
-		strcpy_s(new_root->path, temp_roots_sort[i].path);		
-		new_root->roottype = CF_ROOTTYPE_PACK;		
-	}
-
-	// free up the temp list
-	vm_free(temp_roots_sort);
-}
-
-static char normalize_directory_separator(char in)
-{
-	if (in == '/')
-	{
-		return DIR_SEPARATOR_CHAR;
-	}
-
-	return in;
-}
-
-static void cf_add_mod_roots(const char* rootDirectory, uint32_t basic_location)
-{
-	if (Cmdline_mod)
-	{
-		bool primary = true;
-		for (const char* cur_pos=Cmdline_mod; strlen(cur_pos) != 0; cur_pos+= (strlen(cur_pos)+1))
-		{
-			SCP_stringstream ss;
-			ss << rootDirectory;
-
-			if (rootDirectory[strlen(rootDirectory) - 1] != DIR_SEPARATOR_CHAR)
-			{
-				ss << DIR_SEPARATOR_CHAR;
-			}
-
-			ss << cur_pos << DIR_SEPARATOR_STR;
-
-			SCP_string rootPath = ss.str();
-			if (rootPath.size() + 1 >= CF_MAX_PATHNAME_LENGTH) {
-				Error(LOCATION, "The length of mod directory path '%s' exceeds the maximum of %d!\n", rootPath.c_str(), CF_MAX_PATHNAME_LENGTH);
-			}
-
-			// normalize the path to the native path format
-			std::transform(rootPath.begin(), rootPath.end(), rootPath.begin(), normalize_directory_separator);
-
-			cf_root* root = cf_create_root();
-
-			strncpy(root->path, rootPath.c_str(),  CF_MAX_PATHNAME_LENGTH-1);
-			if (primary) {
-				root->location_flags = basic_location | CF_LOCATION_TYPE_PRIMARY_MOD;
-			} else {
-				root->location_flags = basic_location | CF_LOCATION_TYPE_SECONDARY_MODS;
-			}
-
-			root->roottype = CF_ROOTTYPE_PATH;
-			cf_build_pack_list(root);
-
-			primary = false;
+			return true;
 		}
 	}
+
+	return false;
 }

-void cf_build_root_list(const char *cdrom_dir)
+void cf_build_root_list(const SCP_vector<cfile::ModRoot>& modRoots)
 {
 	Num_roots = 0;
 	Num_path_roots = 0;

-	cf_root	*root = nullptr;
+	auto has_mod = has_mod_location(modRoots);

-	if (os_is_legacy_mode())
+	mprintf(("CFile root configuration:\n"));
+	// Go through the roots specified and convert them to the internal data structure
+	for (const auto& root : modRoots)
 	{
-		// =========================================================================
-#ifdef WIN32
-		// Nothing to do here, Windows uses the current directory as the base
-#else
-		cf_add_mod_roots(os_get_legacy_user_dir(), CF_LOCATION_ROOT_USER);
-
-		root = cf_create_root();
-		strncpy(root->path, os_get_legacy_user_dir(), CF_MAX_PATHNAME_LENGTH - 1);
-
-		root->location_flags |= CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT;
-		if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
-			// If there are no mods then the root is the primary mod
-			root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+		if (root.path.size() >= CF_MAX_PATHNAME_LENGTH - 1)
+		{
+			Error(LOCATION, "Mod root path '%s' is longer than the maximum %d!", root.path.c_str(), CF_MAX_PATHNAME_LENGTH - 1);
+			return;
 		}

-		// do we already have a slash? as in the case of a root directory install
-		if ((strlen(root->path) < (CF_MAX_PATHNAME_LENGTH - 1)) && (root->path[strlen(root->path) - 1] != DIR_SEPARATOR_CHAR)) {
-			strcat_s(root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
-		}
-		root->roottype = CF_ROOTTYPE_PATH;
+		auto cfile_root = cf_create_root();
+		memset(cfile_root, 0, sizeof(*cfile_root));

-		// Next, check any VP files under the current directory.
-		cf_build_pack_list(root);
+		strcpy_s(cfile_root->path, root.path.c_str());
+
+		if (root.user_location)
+		{
+			cfile_root->location_flags |= CF_LOCATION_ROOT_USER;
+		} else {
+			cfile_root->location_flags |= CF_LOCATION_ROOT_GAME;
+		}
+
+		if (root.location_type == cfile::LocationType::SecondaryMod)
+		{
+			cfile_root->location_flags |= CF_LOCATION_TYPE_SECONDARY_MODS;
+		} else if (root.location_type == cfile::LocationType::PrimaryMod)
+		{
+			cfile_root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+		} else if (root.location_type == cfile::LocationType::GameRoot)
+		{
+			cfile_root->location_flags |= CF_LOCATION_TYPE_ROOT;
+			if (!has_mod)
+			{
+				// If we do not have a mod then game roots are also primary mods
+				cfile_root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+			}
+		} else {
+			UNREACHABLE("Unknown root location type!");
+		}
+
+		switch (root.type)
+		{
+		case cfile::ModRootType::Folder:
+			cfile_root->roottype = CF_ROOTTYPE_PATH;
+			break;
+		case cfile::ModRootType::Package:
+			cfile_root->roottype = CF_ROOTTYPE_PACK;
+			break;
+		default:
+			UNREACHABLE("Unknown root type!");
+			break;
+		}
+
+		if (root.type == cfile::ModRootType::Folder)
+		{
+			size_t path_len = strlen(cfile_root->path);
+
+			// do we already have a slash? as in the case of a root directory install
+			if ( (path_len < (CF_MAX_PATHNAME_LENGTH-1)) && (cfile_root->path[path_len-1] != DIR_SEPARATOR_CHAR) ) {
+				strcat_s(cfile_root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
+			}
+		}
+
+#ifndef NDEBUG
+		switch (root.type)
+		{
+		case cfile::ModRootType::Folder:
+			mprintf(("  Found root folder '%s'\n", root.path.c_str()));
+			break;
+		case cfile::ModRootType::Package: {
+			uint chksum = 0;
+			cf_chksum_pack(root.path.c_str(), &chksum);
+			mprintf(("  Found root pack '%s' with a checksum of 0x%08x\n", root.path.c_str(), chksum));
+			break;
+		}
+		default:
+			UNREACHABLE("Unknown root type!");
+			break;
+		}
 #endif
-		// =========================================================================
-	}
-	else if (!Cmdline_portable_mode)
-	{
-		// =========================================================================
-		// now look for mods under the users HOME directory to use before system ones
-		cf_add_mod_roots(Cfile_user_dir, CF_LOCATION_ROOT_USER);
-		// =========================================================================
-
-		// =========================================================================
-		// set users HOME directory as default for loading and saving files
-		root = cf_create_root();
-		strcpy_s(root->path, Cfile_user_dir);
-
-		root->location_flags |= CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT;
-		if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
-			// If there are no mods then the root is the primary mod
-			root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
-		}
-
-		// do we already have a slash? as in the case of a root directory install
-		if ((strlen(root->path) < (CF_MAX_PATHNAME_LENGTH - 1)) && (root->path[strlen(root->path) - 1] != DIR_SEPARATOR_CHAR)) {
-			strcat_s(root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
-		}
-		root->roottype = CF_ROOTTYPE_PATH;
-
-		// Next, check any VP files under the current directory.
-		cf_build_pack_list(root);
-		// =========================================================================
-	}
-
-	char working_directory[CF_MAX_PATHNAME_LENGTH];
-	
-	if ( !_getcwd(working_directory, CF_MAX_PATHNAME_LENGTH ) ) {
-		Error(LOCATION, "Can't get current working directory -- %d", errno );
-	}
-
-	cf_add_mod_roots(working_directory, CF_LOCATION_ROOT_GAME);
-
-	root = cf_create_root();
-
-	root->location_flags |= CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT;
-	if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
-		// If there are no mods then the root is the primary mod
-		root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
-	}
-
-	strcpy_s(root->path, working_directory);
-
-	size_t path_len = strlen(root->path);
-
-	// do we already have a slash? as in the case of a root directory install
-	if ( (path_len < (CF_MAX_PATHNAME_LENGTH-1)) && (root->path[path_len-1] != DIR_SEPARATOR_CHAR) ) {
-		strcat_s(root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
-	}
-
-	root->roottype = CF_ROOTTYPE_PATH;
-
-   //======================================================
-	// Next, check any VP files under the current directory.
-	cf_build_pack_list(root);
-
-
-   //======================================================
-	// Check the real CD if one...
-	if ( cdrom_dir && (strlen(cdrom_dir) < CF_MAX_PATHNAME_LENGTH) )	{
-		root = cf_create_root();
-		strcpy_s( root->path, cdrom_dir );
-		root->roottype = CF_ROOTTYPE_PATH;
-
-		//======================================================
-		// Next, check any VP files in the CD-ROM directory.
-		cf_build_pack_list(root);
-
 	}

 	// The final root is the in-memory root
-	root = cf_create_root();
+	auto root = cf_create_root();
 	root->location_flags = CF_LOCATION_ROOT_MEMORY | CF_LOCATION_TYPE_ROOT;
 	memset(root->path, 0, sizeof(root->path));
 	root->roottype = CF_ROOTTYPE_MEMORY;
-
 }

 // Given a lower case list of file extensions 
@@ -556,40 +290,17 @@ void cf_search_root_path(int root_index)
 	int i;
 	int num_files = 0;

-	cf_root* root = cf_get_root(root_index);
+	cf_root *root = cf_get_root(root_index);

-	mprintf(("Searching root '%s' ... ", root->path));
-
-#ifndef WIN32
-	try {
-		auto current           = root->path;
-		const auto prefPathEnd = root->path + strlen(root->path);
-		while (current != prefPathEnd) {
-			const auto cp = utf8::next(current, prefPathEnd);
-			if (cp > 127) {
-				// On Windows, we currently do not support Unicode paths so catch this early and let the user
-				// know
-				const auto invalid_end = current;
-				utf8::prior(current, root->path);
-				Error(LOCATION,
-				      "Trying to use path \"%s\" as a data root. That path is not supported since it "
-				      "contains a Unicode character (%s). If possible, change this path to something that only uses "
-				      "ASCII characters.",
-				      root->path, std::string(current, invalid_end).c_str());
-			}
-		}
-	} catch (const std::exception& e) {
-		Error(LOCATION, "UTF-8 error while checking the root path \"%s\": %s", root->path, e.what());
-	}
-#endif
+	mprintf(( "Searching root '%s' ... ", root->path ));

 	char search_path[CF_MAX_PATHNAME_LENGTH];
 #ifdef SCP_UNIX
-	// This map stores the mapping between a specific path type and the actual path that we use for it
+    // This map stores the mapping between a specific path type and the actual path that we use for it
 	SCP_unordered_map<int, SCP_string> pathTypeToRealPath;
 #endif

-	for (i = CF_TYPE_ROOT; i < CF_MAX_PATH_TYPES; i++) {
+	for (i=CF_TYPE_ROOT; i<CF_MAX_PATH_TYPES; i++ )	{

 		// we don't want to add player files to the cache - taylor
 		if ( (i == CF_TYPE_SINGLE_PLAYERS) || (i == CF_TYPE_MULTI_PLAYERS) ) {
@@ -946,7 +657,7 @@ void cf_build_file_list()
 }


-void cf_build_secondary_filelist(const char *cdrom_dir)
+void cf_build_secondary_filelist(const SCP_vector<cfile::ModRoot>& modRoots)
 {
 	int i;

@@ -967,7 +678,7 @@ void cf_build_secondary_filelist(const char *cdrom_dir)
 	mprintf(( "Building file index...\n" ));
 	
 	// build the list of searchable roots
-	cf_build_root_list(cdrom_dir);	
+	cf_build_root_list(modRoots);

 	// build the list of files themselves
 	cf_build_file_list();
@@ -1034,21 +745,18 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool loc
 	// of the file

 	// NOTE: full path should also include localization, if so desired
-	auto last_separator = strrchr(filespec, DIR_SEPARATOR_CHAR);
-
-	// do we have a full path already?
-	if ( last_separator ) {
+#ifdef SCP_UNIX
+	if ( strpbrk(filespec, "/") ) {			// do we have a full path already?
+#else
+	if ( strpbrk(filespec,"/\\:")  ) {		// do we have a full path already?
+#endif
 		FILE *fp = fopen(filespec, "rb" );
 		if (fp)	{
 			CFileLocation res(true);
 			res.size = static_cast<size_t>(filelength(fileno(fp)));
-
-			fclose(fp);
-
 			res.offset = 0;
 			res.full_name = filespec;
-			res.name_ext = last_separator + 1;
-
+			fclose(fp);
 			return res;
 		}

@@ -1107,7 +815,6 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool loc

 				res.offset = 0;
 				res.full_name = longname;
-				res.name_ext = filespec;

 				return res;
 			}
@@ -1123,7 +830,6 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool loc

 					res.offset = 0;
 					res.full_name = longname;
-					res.name_ext = filespec;

 					return res;
 				}
@@ -1159,7 +865,6 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool loc
 					res.size = static_cast<size_t>(f->size);
 					res.offset = (size_t)f->pack_offset;
 					res.data_ptr = f->data;
-					res.name_ext = f->name_ext;

 					if (f->data != nullptr) {
 						// This is an in-memory file so we just copy the pathtype name + file name
@@ -1187,7 +892,6 @@ CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool loc
 			res.size = static_cast<size_t>(f->size);
 			res.offset = (size_t)f->pack_offset;
 			res.data_ptr = f->data;
-			res.name_ext = f->name_ext;

 			if (f->data != nullptr) {
 				// This is an in-memory file so we just copy the pathtype name + file name
@@ -1242,8 +946,13 @@ CFileLocationExt cf_find_file_location_ext( const char *filename, const int ext_
 	Assert( (ext_list != NULL) && (ext_num > 1) );	// if we are searching for just one ext
 													// then this is the wrong function to use

+
 	// if we have a full path already then fail.  this function if for searching via filter only!
-	if ( strchr(filename, DIR_SEPARATOR_CHAR) ) {		// do we have a full path already?
+#ifdef SCP_UNIX
+	if ( strpbrk(filename, "/") ) {			// do we have a full path already?
+#else
+	if ( strpbrk(filename,"/\\:")  ) {		// do we have a full path already?
+#endif
 		Int3();
 		return CFileLocationExt();
 	}
@@ -1314,7 +1023,6 @@ CFileLocationExt cf_find_file_location_ext( const char *filename, const int ext_

 				res.offset = 0;
 				res.full_name = longname;
-				res.name_ext = filespec;

 				return res;
 			}
@@ -1331,7 +1039,6 @@ CFileLocationExt cf_find_file_location_ext( const char *filename, const int ext_

 					res.offset = 0;
 					res.full_name = longname;
-					res.name_ext = filespec;

 					return res;
 				}
@@ -1423,7 +1130,6 @@ CFileLocationExt cf_find_file_location_ext( const char *filename, const int ext_
 						res.size = static_cast<size_t>(f->size);
 						res.offset = (size_t)f->pack_offset;
 						res.data_ptr = f->data;
-						res.name_ext = f->name_ext;

 						if (f->data != nullptr) {
 							// This is an in-memory file so we just copy the pathtype name + file name
@@ -1455,7 +1161,6 @@ CFileLocationExt cf_find_file_location_ext( const char *filename, const int ext_
 				res.size = static_cast<size_t>(f->size);
 				res.offset = (size_t)f->pack_offset;
 				res.data_ptr = f->data;
-				res.name_ext = f->name_ext;

 				if (f->data != nullptr) {
 					// This is an in-memory file so we just copy the pathtype name + file name
@@ -1585,9 +1290,6 @@ static int cf_file_already_in_list( SCP_vector<SCP_string> &list, const char *fi
 // This one has a 'type', which is a CF_TYPE_* value.  Because this specifies the directory
 // location, 'filter' only needs to be the filter itself, with no path information.
 // See above descriptions of cf_get_file_list() for more information about how it all works.
-// Note that filesystem listing is always sorted by name *before* sorting by the
-// provided sort order. This isn't strictly needed on NTFS, which always provides the list
-// sorted by name. But on mac/linux it's always needed.
 int cf_get_file_list(SCP_vector<SCP_string>& list, int pathtype, const char* filter, int sort,
                     SCP_vector<file_list_info>* info, uint32_t location_flags)
 {
@@ -1710,10 +1412,6 @@ int cf_get_file_list(SCP_vector<SCP_string>& list, int pathtype, const char* fil
 	}
 #endif

-	// tcrayford: sort the filesystem listing by name by default to ensure
-	// a stable order across filesystems
-	cf_sort_filenames( list, CF_SORT_NAME, info );
-
 	bool skip_packfiles = false;
 	if ( (pathtype == CF_TYPE_PLAYERS) || (pathtype == CF_TYPE_SINGLE_PLAYERS) || (pathtype == CF_TYPE_MULTI_PLAYERS) ) {
 		skip_packfiles = true;
@@ -1779,6 +1477,7 @@ int cf_get_file_list(SCP_vector<SCP_string>& list, int pathtype, const char* fil
 		}
 	}

+
 	if (sort != CF_SORT_NONE)	{
 		cf_sort_filenames( list, sort, info );
 	}
@@ -2269,7 +1968,11 @@ int cf_get_file_list_preallocated(int max, char arr[][MAX_FILENAME_LEN], char**
 int cf_create_default_path_string(char* path, uint path_max, int pathtype, const char* filename, bool localize,
                                  uint32_t location_flags)
 {
-	if ( filename && strchr(filename, DIR_SEPARATOR_CHAR) ) {
+#ifdef SCP_UNIX
+	if ( filename && strpbrk(filename,"/")  ) {
+#else
+	if ( filename && strpbrk(filename,"/\\:")  ) {
+#endif
 		// Already has full path
 		strncpy( path, filename, path_max );

@@ -2348,7 +2051,11 @@ int cf_create_default_path_string(char* path, uint path_max, int pathtype, const
 int cf_create_default_path_string(SCP_string& path, int pathtype, const char* filename, bool /*localize*/,
                                  uint32_t location_flags)
 {
-	if ( filename && strchr(filename, DIR_SEPARATOR_CHAR) ) {
+#ifdef SCP_UNIX
+	if ( filename && strpbrk(filename,"/")  ) {
+#else
+	if ( filename && strpbrk(filename,"/\\:")  ) {
+#endif
 		// Already has full path
 		path.assign(filename);

@@ -15,7 +15,7 @@
 #include "cfile/cfile.h"

 // Builds a list of all the files
-void cf_build_secondary_filelist( const char *cdrom_path );
+void cf_build_secondary_filelist(const SCP_vector<cfile::ModRoot>& modRoots);
 void cf_free_secondary_filelist();

 // Internal stuff
@@ -12,6 +12,7 @@
 #ifndef FS_CMDLINE_HEADER_FILE
 #define FS_CMDLINE_HEADER_FILE

+#include "globalincs/pstypes.h"

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

@@ -24,11 +25,11 @@ int parse_cmdline(int argc, char *argv[]);


 // RETAIL OPTIONS ----------------------------------------------
-extern char *Cmdline_connect_addr;
-extern char *Cmdline_game_name;
-extern char *Cmdline_game_password;
-extern char *Cmdline_rank_above;
-extern char *Cmdline_rank_below;
+extern SCP_string Cmdline_connect_addr;
+extern SCP_string Cmdline_game_name;
+extern SCP_string Cmdline_game_password;
+extern SCP_string Cmdline_rank_above;
+extern SCP_string Cmdline_rank_below;
 extern int Cmdline_cd_check;
 extern int Cmdline_client_dodamage;
 extern int Cmdline_closed_game;
@@ -46,14 +47,16 @@ extern int Cmdline_timeout;
 extern int Cmdline_use_last_pilot;
 extern int Cmdline_window;
 extern int Cmdline_fullscreen_window;
-extern char *Cmdline_res;
-extern char *Cmdline_center_res;
+extern SCP_string Cmdline_res;
+extern SCP_string Cmdline_center_res;


 // FSO OPTIONS -------------------------------------------------

 // Graphics related
+extern double specular_exponent_value;
 extern float Cmdline_clip_dist;
+extern float Cmdline_ogl_spec;
 extern float static_light_factor;
 extern float static_point_factor;
 extern float static_tube_factor;
@@ -67,9 +70,8 @@ extern int Cmdline_height;
 extern int Cmdline_enable_3d_shockwave;
 extern int Cmdline_softparticles;
 extern int Cmdline_bloom_intensity;
-extern bool Cmdline_force_lightshaft_off;
 extern int Cmdline_no_deferred_lighting;
-extern int Cmdline_emissive;
+extern int Cmdline_no_emissive;
 extern int Cmdline_aniso_level;

 // Game Speed related
@@ -90,20 +92,24 @@ extern int Cmdline_weapon_choice_3d;
 extern int Cmdline_warp_flash;
 extern int Cmdline_autopilot_interruptable;
 extern int Cmdline_stretch_menu;
-extern int Cmdline_no_screenshake;

 // Audio related
 extern int Cmdline_voice_recognition;
 extern int Cmdline_no_enhanced_sound;

+namespace cfile {
+struct ModRoot;
+} // namespace cfile
+
 // MOD related
-extern char *Cmdline_mod;	 // DTP for mod support
+extern SCP_vector<cfile::ModRoot> Cmdline_mod;	 // DTP for mod support
 // Multiplayer/Network related
-extern char *Cmdline_almission;	// DTP for autoload mission (for multi only)
+extern SCP_string Cmdline_almission;	// DTP for autoload mission (for multi only)
 extern int Cmdline_ingamejoin;
 extern int Cmdline_mpnoreturn;
+extern SCP_string Cmdline_spew_mission_crcs;
+extern SCP_string Cmdline_spew_table_crcs;
 extern int Cmdline_objupd;
-extern char *Cmdline_gateway_ip;

 // Launcher related options
 extern bool Cmdline_portable_mode;
@@ -118,7 +124,7 @@ extern int Cmdline_mipmap;
 extern int Cmdline_ati_color_swap;
 extern int Cmdline_no_3d_sound;
 extern int Cmdline_drawelements;
-extern char* Cmdline_keyboard_layout;
+extern SCP_string Cmdline_keyboard_layout;
 extern bool Cmdline_gl_finish;
 extern bool Cmdline_no_geo_sdr_effects;
 extern bool Cmdline_set_cpu_affinity;
@@ -129,7 +135,7 @@ extern bool Cmdline_alternate_registry_path;
 #endif

 // Developer/Testing related
-extern char *Cmdline_start_mission;
+extern SCP_string Cmdline_start_mission;
 extern int Cmdline_dis_collisions;
 extern int Cmdline_dis_weapons;
 extern bool Cmdline_output_sexp_info;
@@ -149,11 +155,5 @@ extern bool Cmdline_json_profiling;
 extern bool Cmdline_frame_profile;
 extern bool Cmdline_show_video_info;
 extern bool Cmdline_debug_window;
-extern bool Cmdline_graphics_debug_output;
-extern bool Cmdline_log_to_stdout;
-
-enum class WeaponSpewType { NONE = 0, STANDARD, ALL };
-extern WeaponSpewType Cmdline_spew_weapon_stats;
-

 #endif
@@ -0,0 +1,48 @@
+{
+  "version": 1,
+  "flags": {
+    "-bool_option": false,
+    "-number_option": 5.8,
+    "-string_option": "asdf",
+    "-mod": [
+      {
+        "type": "folder",
+        "path": "/home/fso/mediavps",
+        "user": true,
+        "location_type": "primary_mod"
+      },
+      {
+        "type": "folder",
+        "path": "/home/fso",
+        "user": true,
+        "location_type": "game_root"
+      },
+      {
+        "type": "folder",
+        "path": "/path/to/fso/mediavps",
+        "user": false,
+        "location_type": "primary_mod"
+      },
+      {
+        "type": "package",
+        "path": "/path/to/fso/mediavps/MVPS-Z.vp",
+        "location_type": "primary_mod"
+      },
+      {
+        "type": "package",
+        "path": "/path/to/fso/mediavps/MVPS-X.vp",
+        "location_type": "primary_mod"
+      },
+      {
+        "type": "folder",
+        "path": "/path/to/fso",
+        "location_type": "game_root"
+      },
+      {
+        "type": "package",
+        "path": "/path/to/fso/retail.vp",
+        "location_type": "game_root"
+      }
+    ]
+  }
+}
@@ -516,10 +516,8 @@ void control_config_list_prepare()
 	Num_cc_lines = y = z = 0;
 	while (z < CCFG_MAX) {
 		if (Control_config[z].tab == Tab && !Control_config[z].disabled) {
-			if (Control_config[z].indexXSTR > 1) {
-				Cc_lines[Num_cc_lines].label = XSTR(Control_config[z].text, Control_config[z].indexXSTR, true);
-			} else if (Control_config[z].indexXSTR == 1) {
-				Cc_lines[Num_cc_lines].label = XSTR(Control_config[z].text, CONTROL_CONFIG_XSTR + z, true);
+			if (Control_config[z].hasXSTR) {
+				Cc_lines[Num_cc_lines].label = XSTR(Control_config[z].text, CONTROL_CONFIG_XSTR + z);
 			} else {
 				Cc_lines[Num_cc_lines].label = Control_config[z].text;
 			}
@@ -1001,7 +999,7 @@ void control_config_reset_defaults(int presetnum)
 		Control_config[i].key_id = preset[i].key_default;
 		Control_config[i].joy_id = preset[i].joy_default;
 		Control_config[i].tab = preset[i].tab;
-		Control_config[i].indexXSTR = preset[i].indexXSTR;
+		Control_config[i].hasXSTR = preset[i].hasXSTR;
 		Control_config[i].type = preset[i].type;
 		Control_config[i].disabled = preset[i].disabled;
 	}
@@ -1984,10 +1982,8 @@ void control_config_do_frame(float frametime)
 		gr_get_string_size(&w, NULL, str);
 		gr_printf_menu(x - w / 2, y - font_height, "%s", str);

-		if (Control_config[i].indexXSTR > 1) {
-			strcpy_s(buf, XSTR(Control_config[i].text, Control_config[i].indexXSTR, true));
-		} else if (Control_config[i].indexXSTR == 1) {
-			strcpy_s(buf, XSTR(Control_config[i].text, CONTROL_CONFIG_XSTR + i, true));
+		if (Control_config[i].hasXSTR) {
+			strcpy_s(buf, XSTR(Control_config[i].text, CONTROL_CONFIG_XSTR + i));
 		} else {
 			strcpy_s(buf, Control_config[i].text);
 		}
@@ -2304,7 +2300,7 @@ int check_control_used(int id, int key)

 	if ((Control_config[id].key_id == key) || joy_down_count(Control_config[id].joy_id, 1) ||
 			((Control_config[id].joy_id >= 0) && (Control_config[id].joy_id < MOUSE_NUM_BUTTONS) && mouse_down_count(1 << Control_config[id].joy_id))) {
-		//mprintf(("Key used %d\n", key));
+		//mprintf(("Key used %d", key));
 		control_used(id);
 		return 1;
 	}
@@ -62,7 +62,7 @@ typedef struct config_item {
 	short key_default;		//!< default key bound to action
 	short joy_default;		//!< default joystick button bound to action
 	char tab;				//!< what tab (category) it belongs in
-	int indexXSTR;			//!< what string index we should use to translate this with an XSTR
+	bool hasXSTR;			//!< whether we should translate this with an XSTR
 	const char *text;		//!< describes the action in the config screen
 	char type;				//!< manner control should be checked in
 	short key_id;			//!< actual key bound to action
@@ -270,15 +270,6 @@ enum IoActionId  {
 	//!< ----------------------------
 	CYCLE_PRIMARY_WEAPON_SEQUENCE					=118,	//!< cycle num primaries to fire at once

-	//!< @n
-	//!< Custom control slots
-	//!< ----------------------------
-	CUSTOM_CONTROL_1								= 119,
-	CUSTOM_CONTROL_2								= 120,
-	CUSTOM_CONTROL_3								= 121,
-	CUSTOM_CONTROL_4								= 122,
-	CUSTOM_CONTROL_5								= 123,
-
 	/*!
 	 * This must always be below the last defined item
 	 */
@@ -17,7 +17,6 @@
 #include "io/joy.h"
 #include "io/key.h"
 #include "localization/localize.h"
-#include "options/Option.h"
 #include "parse/parselo.h"

 // z64: These enumerations MUST equal to those in controlsconfig.cpp...
@@ -33,29 +32,8 @@ int Failed_key_index;

 // Joystick configuration
 int Joy_dead_zone_size = 10;
-
-auto DeadZoneOption =
-    options::OptionBuilder<int>("Input.JoystickDeadZone", "Deadzone", "The deadzone of the selected joystick.")
-        .category("Input")
-        .range(0, 45)
-        .level(options::ExpertLevel::Beginner)
-        .default_val(10)
-        .bind_to(&Joy_dead_zone_size)
-        .importance(1)
-        .finish();
-
 int Joy_sensitivity = 9;

-auto SensitivityOption =
-    options::OptionBuilder<int>("Input.JoystickSensitivity", "Sensitivity", "The sentitivity of the selected joystick.")
-        .category("Input")
-        .range(0, 9)
-        .level(options::ExpertLevel::Beginner)
-        .default_val(9)
-        .bind_to(&Joy_sensitivity)
-        .importance(2)
-        .finish();
-
 int Invert_axis[JOY_NUM_AXES] = { 0, 0, 0, 0, 0, 0 };
 int Invert_axis_defaults[JOY_NUM_AXES] = { 0, 0, 0, 0, 0, 0 };

@@ -64,159 +42,154 @@ int Invert_axis_defaults[JOY_NUM_AXES] = { 0, 0, 0, 0, 0, 0 };
 //XSTR:OFF
 config_item Control_config[CCFG_MAX + 1] = {
 	// targeting a ship
-	{                           KEY_T,              -1, TARGET_TAB,   1,  "Target Next Ship",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_T,              -1, TARGET_TAB,   1,  "Target Previous Ship",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_H,               2, TARGET_TAB,   1,  "Target Next Closest Hostile Ship",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_H,              -1, TARGET_TAB,   1,  "Target Previous Closest Hostile Ship",   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_H,              -1, TARGET_TAB,   1,  "Toggle Auto Targeting",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_F,              -1, TARGET_TAB,   1,  "Target Next Closest Friendly Ship",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_F,              -1, TARGET_TAB,   1,  "Target Previous Closest Friendly Ship",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_Y,               4, TARGET_TAB,   1,  "Target Ship in Reticle",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_G,              -1, TARGET_TAB,   1,  "Target Target's Nearest Attacker",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_Y,              -1, TARGET_TAB,   1,  "Target Last Ship to Send Transmission",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_T,              -1, TARGET_TAB,   1,  "Turn Off Targeting",                     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_T,              -1, TARGET_TAB,   true,  "Target Next Ship",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_T,              -1, TARGET_TAB,   true,  "Target Previous Ship",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_H,               2, TARGET_TAB,   true,  "Target Next Closest Hostile Ship",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_H,              -1, TARGET_TAB,   true,  "Target Previous Closest Hostile Ship",   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_H,              -1, TARGET_TAB,   true,  "Toggle Auto Targeting",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_F,              -1, TARGET_TAB,   true,  "Target Next Closest Friendly Ship",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_F,              -1, TARGET_TAB,   true,  "Target Previous Closest Friendly Ship",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_Y,               4, TARGET_TAB,   true,  "Target Ship in Reticle",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_G,              -1, TARGET_TAB,   true,  "Target Target's Nearest Attacker",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_Y,              -1, TARGET_TAB,   true,  "Target Last Ship to Send Transmission",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_T,              -1, TARGET_TAB,   true,  "Turn Off Targeting",                     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// targeting a ship's subsystem
-	{                           KEY_V,              -1, TARGET_TAB,   1,  "Target Subsystem in Reticle",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_S,              -1, TARGET_TAB,   1,  "Target Next Subsystem",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_S,              -1, TARGET_TAB,   1,  "Target Previous Subsystem",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_S,              -1, TARGET_TAB,   1,  "Turn Off Targeting of Subsystems",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_V,              -1, TARGET_TAB,   true,  "Target Subsystem in Reticle",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_S,              -1, TARGET_TAB,   true,  "Target Next Subsystem",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_S,              -1, TARGET_TAB,   true,  "Target Previous Subsystem",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_S,              -1, TARGET_TAB,   true,  "Turn Off Targeting of Subsystems",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// matching speed
-	{                           KEY_M,              -1, COMPUTER_TAB, 1,  "Match Target Speed",                     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_M,              -1, COMPUTER_TAB, 1,  "Toggle Auto Speed Matching",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_M,              -1, COMPUTER_TAB, true,  "Match Target Speed",                     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_M,              -1, COMPUTER_TAB, true,  "Toggle Auto Speed Matching",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// weapons
-	{                           KEY_LCTRL,           0, WEAPON_TAB,   1,  "Fire Primary Weapon",                    CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_SPACEBAR,        1, WEAPON_TAB,   1,  "Fire Secondary Weapon",                  CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PERIOD,         -1, WEAPON_TAB,   1,  "Cycle Forward Primary Weapon",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_COMMA,          -1, WEAPON_TAB,   1,  "Cycle Backward Primary Weapon",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_DIVIDE,         -1, WEAPON_TAB,   1,  "Cycle Secondary Weapon Bank",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_DIVIDE,         -1, WEAPON_TAB,   1,  "Cycle Secondary Weapon Firing Rate",     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_X,               3, WEAPON_TAB,   1,  "Launch Countermeasure",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_LCTRL,           0, WEAPON_TAB,   true,  "Fire Primary Weapon",                    CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_SPACEBAR,        1, WEAPON_TAB,   true,  "Fire Secondary Weapon",                  CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PERIOD,         -1, WEAPON_TAB,   true,  "Cycle Forward Primary Weapon",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_COMMA,          -1, WEAPON_TAB,   true,  "Cycle Backward Primary Weapon",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_DIVIDE,         -1, WEAPON_TAB,   true,  "Cycle Secondary Weapon Bank",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_DIVIDE,         -1, WEAPON_TAB,   true,  "Cycle Secondary Weapon Firing Rate",     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_X,               3, WEAPON_TAB,   true,  "Launch Countermeasure",                  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// controls
-	{                           KEY_A,              -1, SHIP_TAB,     1,  "Forward Thrust",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_Z,              -1, SHIP_TAB,     1,  "Reverse Thrust",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD7,           -1, SHIP_TAB,     1,  "Bank Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD9,           -1, SHIP_TAB,     1,  "Bank Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD8,           -1, SHIP_TAB,     1,  "Pitch Forward",                          CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD2,           -1, SHIP_TAB,     1,  "Pitch Backward",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD4,           -1, SHIP_TAB,     1,  "Turn Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD6,           -1, SHIP_TAB,     1,  "Turn Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_A,              -1, SHIP_TAB,     true,  "Forward Thrust",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_Z,              -1, SHIP_TAB,     true,  "Reverse Thrust",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD7,           -1, SHIP_TAB,     true,  "Bank Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD9,           -1, SHIP_TAB,     true,  "Bank Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD8,           -1, SHIP_TAB,     true,  "Pitch Forward",                          CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD2,           -1, SHIP_TAB,     true,  "Pitch Backward",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD4,           -1, SHIP_TAB,     true,  "Turn Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD6,           -1, SHIP_TAB,     true,  "Turn Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },

 	// throttle controls
-	{                           KEY_BACKSP,         -1, SHIP_TAB,     1,  "Set Throttle to Zero",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_SLASH,          -1, SHIP_TAB,     1,  "Set Throttle to Max",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_LBRACKET,       -1, SHIP_TAB,     1,  "Set Throttle to One-Third",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_RBRACKET,       -1, SHIP_TAB,     1,  "Set Throttle to Two-Thirds",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_EQUAL,          -1, SHIP_TAB,     1,  "Increase Throttle 5 Percent",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_MINUS,          -1, SHIP_TAB,     1,  "Decrease Throttle 5 Percent",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_BACKSP,         -1, SHIP_TAB,     true,  "Set Throttle to Zero",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_SLASH,          -1, SHIP_TAB,     true,  "Set Throttle to Max",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_LBRACKET,       -1, SHIP_TAB,     true,  "Set Throttle to One-Third",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_RBRACKET,       -1, SHIP_TAB,     true,  "Set Throttle to Two-Thirds",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_EQUAL,          -1, SHIP_TAB,     true,  "Increase Throttle 5 Percent",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_MINUS,          -1, SHIP_TAB,     true,  "Decrease Throttle 5 Percent",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// squadmate messaging
-	{             KEY_SHIFTED | KEY_A,              -1, COMPUTER_TAB, 1,  "Attack My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_Z,              -1, COMPUTER_TAB, 1,  "Disarm My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_D,              -1, COMPUTER_TAB, 1,  "Disable My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_V,              -1, COMPUTER_TAB, 1,  "Attack My Subsystem",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_X,              -1, COMPUTER_TAB, 1,  "Capture My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_E,              -1, COMPUTER_TAB, 1,  "Engage Enemy",                           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_W,              -1, COMPUTER_TAB, 1,  "Form on My Wing",                        CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_I,              -1, COMPUTER_TAB, 1,  "Ignore My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_P,              -1, COMPUTER_TAB, 1,  "Protect My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_C,              -1, COMPUTER_TAB, 1,  "Cover Me",                               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_J,              -1, COMPUTER_TAB, 1,  "Return to Base",                         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_R,              -1, COMPUTER_TAB, 1,  "Rearm Me",                               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_A,              -1, COMPUTER_TAB, true,  "Attack My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_Z,              -1, COMPUTER_TAB, true,  "Disarm My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_D,              -1, COMPUTER_TAB, true,  "Disable My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_V,              -1, COMPUTER_TAB, true,  "Attack My Subsystem",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_X,              -1, COMPUTER_TAB, true,  "Capture My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_E,              -1, COMPUTER_TAB, true,  "Engage Enemy",                           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_W,              -1, COMPUTER_TAB, true,  "Form on My Wing",                        CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_I,              -1, COMPUTER_TAB, true,  "Ignore My Target",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_P,              -1, COMPUTER_TAB, true,  "Protect My Target",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_C,              -1, COMPUTER_TAB, true,  "Cover Me",                               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_J,              -1, COMPUTER_TAB, true,  "Return to Base",                         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_R,              -1, COMPUTER_TAB, true,  "Rearm Me",                               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

-	{                           KEY_R,               6, TARGET_TAB,   1,  "Target Closest Attacking Ship",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_R,               6, TARGET_TAB,   true,  "Target Closest Attacking Ship",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// Views
-	{                           KEY_PADMULTIPLY,    -1, COMPUTER_TAB, 1,  "Chase View",                             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PADPERIOD,      -1, COMPUTER_TAB, 1,  "External View",                          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PADENTER,       -1, COMPUTER_TAB, 1,  "Toggle External Camera Lock",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PAD0,           -1, COMPUTER_TAB, 1,  "Free Look View",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PADDIVIDE,      -1, COMPUTER_TAB, 1,  "Current Target View",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PADPLUS,        -1, COMPUTER_TAB, 1,  "Increase View Distance",                 CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PADMINUS,       -1, COMPUTER_TAB, 1,  "Decrease View Distance",                 CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           KEY_PAD5,           -1, COMPUTER_TAB, 1,  "Center View",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           -1,                 33, COMPUTER_TAB, 1,  "View Up",                                CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           -1,                 32, COMPUTER_TAB, 1,  "View Rear",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           -1,                 34, COMPUTER_TAB, 1,  "View Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           -1,                 35, COMPUTER_TAB, 1,  "View Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PADMULTIPLY,    -1, COMPUTER_TAB, true,  "Chase View",                             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PADPERIOD,      -1, COMPUTER_TAB, true,  "External View",                          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PADENTER,       -1, COMPUTER_TAB, true,  "Toggle External Camera Lock",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PAD0,           -1, COMPUTER_TAB, true,  "Free Look View",                         CC_TYPE_CONTINUOUS, -1, -1, 0, false, false }, // Not in use anymore (Swifty)
+	{                           KEY_PADDIVIDE,      -1, COMPUTER_TAB, true,  "Current Target View",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PADPLUS,        -1, COMPUTER_TAB, true,  "Increase View Distance",                 CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PADMINUS,       -1, COMPUTER_TAB, true,  "Decrease View Distance",                 CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_PAD5,           -1, COMPUTER_TAB, true,  "Center View",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 33, COMPUTER_TAB, true,  "View Up",                                CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 32, COMPUTER_TAB, true,  "View Rear",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 34, COMPUTER_TAB, true,  "View Left",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 35, COMPUTER_TAB, true,  "View Right",                             CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },

-	{                           KEY_RAPOSTRO,       -1, COMPUTER_TAB, 1,  "Cycle Radar Range",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_C,              -1, COMPUTER_TAB, 1,  "Communications Menu",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           -1,                 -1, -1,           1,  "Show Objectives",                        CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_J,              -1, COMPUTER_TAB, 1,  "Enter Subspace (End Mission)",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_J,              -1, TARGET_TAB,   1,  "Target Target's Target",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_TAB,             5, SHIP_TAB,     1,  "Afterburner",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           KEY_RAPOSTRO,       -1, COMPUTER_TAB, true,  "Cycle Radar Range",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_C,              -1, COMPUTER_TAB, true,  "Communications Menu",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           -1,                 -1, -1,           true,  "Show Objectives",                        CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_J,              -1, COMPUTER_TAB, true,  "Enter Subspace (End Mission)",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_J,              -1, TARGET_TAB,   true,  "Target Target's Target",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_TAB,             5, SHIP_TAB,     true,  "Afterburner",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
 	
-	{                           KEY_INSERT,         -1, COMPUTER_TAB, 1,  "Increase Weapon Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_DELETE,         -1, COMPUTER_TAB, 1,  "Decrease Weapon Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_HOME,           -1, COMPUTER_TAB, 1,  "Increase Shield Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_END,            -1, COMPUTER_TAB, 1,  "Decrease Shield Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PAGEUP,         -1, COMPUTER_TAB, 1,  "Increase Engine Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_PAGEDOWN,       -1, COMPUTER_TAB, 1,  "Decrease Engine Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_D,              -1, COMPUTER_TAB, 1,  "Equalize Energy Settings",               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_INSERT,         -1, COMPUTER_TAB, true,  "Increase Weapon Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_DELETE,         -1, COMPUTER_TAB, true,  "Decrease Weapon Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_HOME,           -1, COMPUTER_TAB, true,  "Increase Shield Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_END,            -1, COMPUTER_TAB, true,  "Decrease Shield Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PAGEUP,         -1, COMPUTER_TAB, true,  "Increase Engine Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_PAGEDOWN,       -1, COMPUTER_TAB, true,  "Decrease Engine Energy",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_D,              -1, COMPUTER_TAB, true,  "Equalize Energy Settings",               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

-	{                           KEY_Q,               7, COMPUTER_TAB, 1,  "Equalize Shields",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_UP,             -1, COMPUTER_TAB, 1,  "Augment Forward Shield",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_DOWN,           -1, COMPUTER_TAB, 1,  "Augment Rear Shield",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_LEFT,           -1, COMPUTER_TAB, 1,  "Augment Left Shield",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_RIGHT,          -1, COMPUTER_TAB, 1,  "Augment Right Shield",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_SCROLLOCK,      -1, COMPUTER_TAB, 1,  "Transfer Energy Laser->Shield",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_SCROLLOCK,      -1, COMPUTER_TAB, 1,  "Transfer Energy Shield->Laser",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_Q,               7, COMPUTER_TAB, true,  "Equalize Shields",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_UP,             -1, COMPUTER_TAB, true,  "Augment Forward Shield",                 CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_DOWN,           -1, COMPUTER_TAB, true,  "Augment Rear Shield",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_LEFT,           -1, COMPUTER_TAB, true,  "Augment Left Shield",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_RIGHT,          -1, COMPUTER_TAB, true,  "Augment Right Shield",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_SCROLLOCK,      -1, COMPUTER_TAB, true,  "Transfer Energy Laser->Shield",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_SCROLLOCK,      -1, COMPUTER_TAB, true,  "Transfer Energy Shield->Laser",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
 //	{                           -1,                 -1, -1,           true,  "Show Damage Popup Window" },

-	{                           -1,                 -1, SHIP_TAB,     0, "Glide When Pressed",                     CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 -1, SHIP_TAB,     false, "Glide When Pressed",                     CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
 //Backslash -- this was a convenient place for Glide When Pressed, as Show Damage Popup isn't used
-	{                           -1,                 -1, SHIP_TAB,     1,  "Bank When Pressed",                      CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{                           -1,                 -1, -1,           1,  "Show Nav Map",                           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_E,              -1, COMPUTER_TAB, 1,  "Add or Remove Escort",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_E,              -1, COMPUTER_TAB, 1,  "Clear Escort List",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_E,              -1, TARGET_TAB,   1,  "Target Next Escort Ship",                CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_R,              -1, TARGET_TAB,   1,  "Target Closest Repair Ship",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           -1,                 -1, SHIP_TAB,     true,  "Bank When Pressed",                      CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 -1, -1,           true,  "Show Nav Map",                           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_E,              -1, COMPUTER_TAB, true,  "Add or Remove Escort",                   CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED | KEY_SHIFTED | KEY_E,              -1, COMPUTER_TAB, true,  "Clear Escort List",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_E,              -1, TARGET_TAB,   true,  "Target Next Escort Ship",                CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_R,              -1, TARGET_TAB,   true,  "Target Closest Repair Ship",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

-	{                           KEY_U,              -1, TARGET_TAB,   1,  "Target Next Uninspected Cargo",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_U,              -1, TARGET_TAB,   1,  "Target Previous Uninspected Cargo",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_N,              -1, TARGET_TAB,   1,  "Target Newest Ship in Area",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_K,              -1, TARGET_TAB,   1,  "Target Next Live Turret",                CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_K,              -1, TARGET_TAB,   1,  "Target Previous Live Turret",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_U,              -1, TARGET_TAB,   true,  "Target Next Uninspected Cargo",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_U,              -1, TARGET_TAB,   true,  "Target Previous Uninspected Cargo",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_N,              -1, TARGET_TAB,   true,  "Target Newest Ship in Area",             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_K,              -1, TARGET_TAB,   true,  "Target Next Live Turret",                CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_K,              -1, TARGET_TAB,   true,  "Target Previous Live Turret",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

-	{                           KEY_B,              -1, TARGET_TAB,   1,  "Target Next Hostile Bomb or Bomber",     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_B,              -1, TARGET_TAB,   1,  "Target Previous Hostile Bomb or Bomber", CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_B,              -1, TARGET_TAB,   true,  "Target Next Hostile Bomb or Bomber",     CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_B,              -1, TARGET_TAB,   true,  "Target Previous Hostile Bomb or Bomber", CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// multiplayer messaging keys
-	{                           KEY_1,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Message All",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_2,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Message Friendly",         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_3,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Message Hostile",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_4,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Message Target",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_X,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Observer Zoom to Target",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_PERIOD,         -1, COMPUTER_TAB, 1,  "Increase Time Compression",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_COMMA,          -1, COMPUTER_TAB, 1,  "Decrease Time Compression",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_L,              -1, COMPUTER_TAB, 1,  "Toggle High HUD Contrast",               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_N,              -1, COMPUTER_TAB, 1,  "(Multiplayer) Toggle Network Info",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_END,            -1, COMPUTER_TAB, 1,  "(Multiplayer) Self Destruct",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_1,              -1, COMPUTER_TAB, true,  "(Multiplayer) Message All",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_2,              -1, COMPUTER_TAB, true,  "(Multiplayer) Message Friendly",         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_3,              -1, COMPUTER_TAB, true,  "(Multiplayer) Message Hostile",          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_4,              -1, COMPUTER_TAB, true,  "(Multiplayer) Message Target",           CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_X,              -1, COMPUTER_TAB, true,  "(Multiplayer) Observer Zoom to Target",  CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_PERIOD,         -1, COMPUTER_TAB, true,  "Increase Time Compression",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_COMMA,          -1, COMPUTER_TAB, true,  "Decrease Time Compression",              CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_L,              -1, COMPUTER_TAB, true,  "Toggle High HUD Contrast",               CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_N,              -1, COMPUTER_TAB, true,  "(Multiplayer) Toggle Network Info",      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_END,            -1, COMPUTER_TAB, true,  "(Multiplayer) Self Destruct",            CC_TYPE_TRIGGER,    -1, -1, 0, false, false },

 	// Misc
-	{             KEY_SHIFTED | KEY_O,              -1, COMPUTER_TAB, 1,  "Toggle HUD",                             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_3,              -1, SHIP_TAB,     1,  "Right Thrust",                           CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_1,              -1, SHIP_TAB,     1,  "Left Thrust",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_PADPLUS,        -1, SHIP_TAB,     1,  "Up Thrust",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{             KEY_SHIFTED | KEY_PADENTER,       -1, SHIP_TAB,     1,  "Down Thrust",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_Q,              -1, COMPUTER_TAB, 1,  "Toggle HUD Wireframe Target View",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           -1,                 -1, COMPUTER_TAB, 0, "Top-Down View",                          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           -1,                 -1, COMPUTER_TAB, 0, "Target Padlock View",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false }, // (Swifty) Toggle for VM_TRACK
+	{             KEY_SHIFTED | KEY_O,              -1, COMPUTER_TAB, true,  "Toggle HUD",                             CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_3,              -1, SHIP_TAB,     true,  "Right Thrust",                           CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_1,              -1, SHIP_TAB,     true,  "Left Thrust",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_PADPLUS,        -1, SHIP_TAB,     true,  "Up Thrust",                              CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{             KEY_SHIFTED | KEY_PADENTER,       -1, SHIP_TAB,     true,  "Down Thrust",                            CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{ KEY_ALTED | KEY_SHIFTED | KEY_Q,              -1, COMPUTER_TAB, true,  "Toggle HUD Wireframe Target View",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           -1,                 -1, COMPUTER_TAB, false, "Top-Down View",                          CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           -1,                 -1, COMPUTER_TAB, false, "Target Padlock View",                    CC_TYPE_TRIGGER,    -1, -1, 0, false, false }, // (Swifty) Toggle for VM_TRACK
 	// Auto Navigation Systen
-	{ KEY_ALTED |               KEY_A,              -1, COMPUTER_TAB, 0, "Toggle Auto Pilot",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_N,              -1, COMPUTER_TAB, 0, "Cycle Nav Points",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED |               KEY_G,              -1, SHIP_TAB,     0, "Toggle Gliding",                         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{                           KEY_O,              -1, WEAPON_TAB,   0, "Cycle Primary Weapon Firing Rate",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_1,              -1, COMPUTER_TAB, 0, "Custom Control 1",                       CC_TYPE_TRIGGER,    -1, -1, 0, true,  false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_2,              -1, COMPUTER_TAB, 0, "Custom Control 2",                       CC_TYPE_TRIGGER,    -1, -1, 0, true,  false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_3,              -1, COMPUTER_TAB, 0, "Custom Control 3",                       CC_TYPE_TRIGGER,    -1, -1, 0, true,  false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_4,              -1, COMPUTER_TAB, 0, "Custom Control 4",                       CC_TYPE_TRIGGER,    -1, -1, 0, true,  false },
-	{ KEY_ALTED | KEY_SHIFTED | KEY_5,              -1, COMPUTER_TAB, 0, "Custom Control 5",                       CC_TYPE_TRIGGER,    -1, -1, 0, true,  false },
-	{                           -1,                 -1, -1,           0, "",                                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false }
+	{ KEY_ALTED |               KEY_A,              -1, COMPUTER_TAB, false, "Toggle Auto Pilot",                      CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_N,              -1, COMPUTER_TAB, false, "Cycle Nav Points",                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{ KEY_ALTED |               KEY_G,              -1, SHIP_TAB,     false, "Toggle Gliding",                         CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           KEY_O,              -1, WEAPON_TAB,   false, "Cycle Primary Weapon Firing Rate",       CC_TYPE_TRIGGER,    -1, -1, 0, false, false },
+	{                           -1,                 -1, -1,           false, "",                                       CC_TYPE_TRIGGER,    -1, -1, 0, false, false }
 };

 const char *Scan_code_text_german[] = {
@@ -613,6 +586,7 @@ void control_config_common_load_overrides();
 void control_config_common_init()
 {
 	for (int i=0; i<CCFG_MAX; i++) {
+		Control_config[i].disabled = false;
 		Control_config[i].continuous_ongoing = false;
 	}

@@ -869,7 +843,7 @@ void control_config_common_load_overrides()
                        * short key_default;
                        * short joy_default;
                        * char tab;
-                        * int indexXSTR;
+                        * bool hasXSTR;
                        * char type;
                        */

@@ -911,7 +885,7 @@ void control_config_common_load_overrides()

 						if (optional_string("$Has XStr:")) {
 							stuff_int(&iTemp);
-							r_ccConfig.indexXSTR = iTemp;
+							r_ccConfig.hasXSTR = (iTemp == 1);
 						}

 						if (optional_string("$Type:")) {
@@ -83,33 +83,24 @@ void cutscene_init()

 			if (optional_string("$cd:"))
 			{
-				// CD option isn't needed anymore. Consume the token and ignore it
+				// Option isn't needed anymore. Consume the token and ignore it
+
 				int junk;
 				stuff_int(&junk);
 			}

-			cutinfo.flags.reset();
+			cutinfo.viewable = false;

 			if (isFirstCutscene)
 			{
 				isFirstCutscene = false;
-				// The original code assumes the first movie is the intro, so make it viewable
-				cutinfo.flags.set(Cutscene::Cutscene_Flags::Viewable);
+				// The original code assumes the first movie is the intro, so always viewable
+				cutinfo.viewable = true;
 			}

 			if (optional_string("$Always Viewable:"))
 			{
-				bool flag;
-				stuff_boolean(&flag);
-				if (flag)
-					cutinfo.flags.set(Cutscene::Cutscene_Flags::Always_viewable);
-			}
-			if (optional_string("$Never Viewable:"))
-			{
-				bool flag;
-				stuff_boolean(&flag);
-				if (flag)
-					cutinfo.flags.set(Cutscene::Cutscene_Flags::Never_viewable);
+				stuff_boolean(&cutinfo.viewable);
 			}

 			Cutscenes.push_back(cutinfo);
@@ -152,7 +143,7 @@ void cutscene_mark_viewable(const char* filename)
 		// see if the stripped filename matches the cutscene filename
 		if (strstr(cut_file, file) != NULL)
 		{
-			cut->flags.set(Cutscene::Cutscene_Flags::Viewable);
+			cut->viewable = true;
 			return;
 		}
 		i++;
@@ -450,9 +441,9 @@ void cutscenes_screen_init()
 	Cutscene_list.clear();

 	int u = 0;
-	for (auto cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut, ++u)
+	for (SCP_vector<cutscene_info>::iterator cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut, u++)
 	{
-		if (cut->flags[Cutscene::Cutscene_Flags::Viewable, Cutscene::Cutscene_Flags::Always_viewable] && !cut->flags[Cutscene::Cutscene_Flags::Never_viewable])
+		if ((*cut).viewable)
 		{
 			Cutscene_list.push_back(u);
 		}
@@ -10,28 +10,15 @@
 #ifndef _FREESPACE_CUTSCENES_SCREEN_HEADER_FILE
 #define _FREESPACE_CUTSCENES_SCREEN_HEADER_FILE

-#include "globalincs/flagset.h"
 #include "globalincs/globals.h"
 #include "globalincs/pstypes.h"

-namespace Cutscene
-{
-	FLAG_LIST(Cutscene_Flags)
-	{
-		Viewable = 0,
-		Always_viewable,
-		Never_viewable,
-
-		NUM_VALUES
-	};
-}
-
 typedef struct cutscene_info
 {
 	char filename[MAX_FILENAME_LEN];
 	char name[NAME_LENGTH];
 	char* description;
-	flagset<Cutscene::Cutscene_Flags> flags;
+	bool viewable;
 } cutscene_info;

 extern SCP_vector<cutscene_info> Cutscenes;
@@ -126,7 +126,7 @@ void AudioDecoder::handleDecodedFrame(AVFrame* frame) {
 		auto ret = av_samples_alloc(m_outData, &m_outLinesize, OUT_NUM_CHANNELS, m_outNumSamples,
 									OUT_SAMPLE_FORMAT, 1);
 		if (ret < 0) {
-			mprintf(("FFMPEG: Failed to allocate samples!!!\n"));
+			mprintf(("FFMPEG: Failed to allocate samples!!!"));
 			return;
 		}

@@ -286,7 +286,7 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st

 	if (status->subtitleStream == nullptr) {
 		// We don't have an external subtitle stream or loading from that file has failed
-		auto& current_language = Lcl_languages[Lcl_current_lang == LCL_UNTRANSLATED ? LCL_DEFAULT : Lcl_current_lang];
+		auto& current_language = Lcl_languages[Lcl_current_lang];
 		for (uint32_t i = 0; i < ctx->nb_streams; ++i) {
 			auto test_stream = ctx->streams[i];

@@ -428,7 +428,7 @@ std::unique_ptr<InputStream> openInputStream(const SCP_string& name) {

 std::unique_ptr<InputStream> openSubtitleStream(const SCP_string& name)
 {
-	auto& current_language = Lcl_languages[Lcl_current_lang == LCL_UNTRANSLATED ? LCL_DEFAULT : Lcl_current_lang];
+	auto& current_language = Lcl_languages[Lcl_current_lang];

 	for (auto ext : CHECKED_SUBT_EXTENSIONS) {
 		SCP_string fileName;
@@ -10,11 +10,9 @@


 #ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #endif

-#include "freespace.h"
 #include "globalincs/pstypes.h"
 #include "globalincs/alphacolors.h"
 #include "globalincs/systemvars.h"
@@ -29,7 +27,6 @@
 #include "io/timer.h"
 #include "io/key.h"
 #include "mod_table/mod_table.h"
-#include "network/multi.h"

 extern int Game_mode;
 extern int Is_standalone;
@@ -201,10 +198,6 @@ void movie_display_loop(Player* player, PlaybackState* state) {
 	// Use a dedicated listener here since we want to listen for the KEYUP event
 	auto key_handle = os::events::addEventListener(SDL_KEYUP, os::events::DEFAULT_LISTENER_WEIGHT - 10, listener);

-	// slight hack to make sure that game_set_frametime() doesn't also try to cap the framerate
-	auto fpsCapSave = Cmdline_NoFPSCap;
-	Cmdline_NoFPSCap = 1;
-
 	auto lastDisplayTimestamp = timer_get_microseconds();
 	while (state->playing) {
 		TRACE_SCOPE(tracing::CutsceneStep);
@@ -223,16 +216,6 @@ void movie_display_loop(Player* player, PlaybackState* state) {

 		processEvents();

-		// NOTE: This does not update mission time! If movies get enabled in places
-		//       other than through cutscenes then some refactoring should be done
-		//       to account for normal time progression rather than just timestamps
-		game_set_frametime(-1);
-
-		// maybe do multi processing
-		if ( (Game_mode & GM_MULTIPLAYER) && Net_player && (Net_player->flags & NETINFO_FLAG_DO_NETWORKING) ) {
-			multi_do_frame();
-		}
-
 		if (passed < sleepTime) {
 			auto sleep = sleepTime - passed;

@@ -240,12 +223,7 @@ void movie_display_loop(Player* player, PlaybackState* state) {
 		}
 	}

-	Cmdline_NoFPSCap = fpsCapSave;
-
 	os::events::removeEventListener(key_handle);
-
-	// flush keys so we don't pass anything to the current state
-	key_flush();
 }

 }
@@ -264,11 +242,6 @@ bool play(const char* name) {
 		return false;
 	}

-	// for multiplayer, change the state in my netplayer structure
-	if ( (Game_mode & GM_MULTIPLAYER) && Net_player ) {
-		Net_player->state = NETPLAYER_STATE_CUTSCENE;
-	}
-
 	// clear the screen and hide the mouse cursor
 	io::mouse::CursorManager::get()->pushStatus();
 	io::mouse::CursorManager::get()->showCursor(false);
@@ -27,15 +27,13 @@ using namespace cutscene;

 const int MAX_AUDIO_BUFFERS = 15;

-std::unique_ptr<Decoder> findDecoder(__UNUSED const SCP_string& name, __UNUSED const PlaybackProperties& properties) {
-#ifdef WITH_FFMPEG
+std::unique_ptr<Decoder> findDecoder(const SCP_string& name, const PlaybackProperties& properties) {
 	{
 		std::unique_ptr<Decoder> ffmpeg(new ::cutscene::ffmpeg::FFMPEGDecoder());
 		if (ffmpeg->initialize(name, properties)) {
 			return ffmpeg;
 		}
 	}
-#endif

 	return nullptr;
 }
@@ -26,30 +26,10 @@ static inline int is_power_of_two(int w, int h)
 	return ( (w && !(w & (w-1))) && (h && !(h & (h-1))) );
 }

-// This function is used to verify that the file format specified in the DX10 Header
-// is supported by the OpenGL extensions
-bool dds_read_dx10_header(CFILE* dds_file, DDS_HEADER_DXT10* header) 
-{
-	header->dxgiFormat			= static_cast<DXGI_FORMAT>(cfread_uint(dds_file));
-	header->resourceDimension	= static_cast<D3D10_RESOURCE_DIMENSION>(cfread_uint(dds_file));
-	header->miscFlag			= cfread_uint(dds_file);
-	header->arraySize			= cfread_uint(dds_file);
-	header->miscFlags2			= cfread_uint(dds_file);
-
-	switch (header->dxgiFormat) {
-	case DXGI_FORMAT::DXGI_FORMAT_BC7_TYPELESS:
-	case DXGI_FORMAT::DXGI_FORMAT_BC7_UNORM:
-	case DXGI_FORMAT::DXGI_FORMAT_BC7_UNORM_SRGB:
-		return true;
-	default:
-		return false;
-	}
-}

 int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *height, int *bpp, int *compression_type, int *levels, size_t *size, ubyte *palette)
 {
-	DDS_HEADER dds_header;
-	DDS_HEADER_DXT10 dds_header_dx10;
+	DDSURFACEDESC2 dds_header;
 	int code = 0;
 	CFILE *ddsfile;
 	char real_name[MAX_FILENAME_LEN];
@@ -103,22 +83,17 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 	for (i = 0; i < 11; i++)
 		cfread_uint(ddsfile);

-	dds_header.ddspf.dwSize				= cfread_uint(ddsfile);
-	dds_header.ddspf.dwFlags			= cfread_uint(ddsfile);
-	dds_header.ddspf.dwFourCC			= cfread_uint(ddsfile);
-	dds_header.ddspf.dwRGBBitCount		= cfread_uint(ddsfile);
-	dds_header.ddspf.dwRBitMask			= cfread_uint(ddsfile);
-	dds_header.ddspf.dwGBitMask			= cfread_uint(ddsfile);
-	dds_header.ddspf.dwBBitMask			= cfread_uint(ddsfile);
-	dds_header.ddspf.dwABitMask			= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwSize				= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwFlags				= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwFourCC				= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwRGBBitCount		= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwRBitMask			= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwGBitMask			= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwBBitMask			= cfread_uint(ddsfile);
+	dds_header.ddpfPixelFormat.dwRGBAlphaBitMask	= cfread_uint(ddsfile);

-	dds_header.dwCaps		= cfread_uint(ddsfile);
-	dds_header.dwCaps2		= cfread_uint(ddsfile);
-
-	// Unused but need them checked for later
-	dds_header.dwCaps3		= cfread_uint(ddsfile);
-	dds_header.dwCaps4		= cfread_uint(ddsfile);
-	dds_header.dwReserved2	= cfread_uint(ddsfile);
+	dds_header.ddsCaps.dwCaps1		= cfread_uint(ddsfile);
+	dds_header.ddsCaps.dwCaps2		= cfread_uint(ddsfile);

 	// sanity
 	if (dds_header.dwDepth == 0)
@@ -132,12 +107,12 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 	d_depth = dds_header.dwDepth;

 	// calculate the type and size of the data
-	if (dds_header.ddspf.dwFlags & DDPF_FOURCC) {
+	if (dds_header.ddpfPixelFormat.dwFlags & DDPF_FOURCC) {
 		// did I mention lately that I hate Microsoft?
 		// this is here to fix the situation where Microsoft doesn't follow their own docs
-		if ( !(dds_header.dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH) ) || dds_header.dwPitchOrLinearSize <= 0 ) {
+		if ( dds_header.dwPitchOrLinearSize <= 0 ) {
 			// calculate the block size, mult by 8 for DXT1, 16 for DXT3 & 5
-			d_size = ((dds_header.dwWidth + 3)/4) * ((dds_header.dwHeight + 3)/4) * ((dds_header.dwDepth + 3)/4) * ((dds_header.ddspf.dwFourCC == FOURCC_DXT1) ? 8 : 16);
+			d_size = ((dds_header.dwWidth + 3)/4) * ((dds_header.dwHeight + 3)/4) * ((dds_header.dwDepth + 3)/4) * ((dds_header.ddpfPixelFormat.dwFourCC == FOURCC_DXT1) ? 8 : 16);
 		} else {
 			d_size = dds_header.dwPitchOrLinearSize;
 		}
@@ -155,11 +130,11 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 				d_height = 1;

 			// size of data block (4x4)
-			d_size += ((d_width + 3) / 4) * ((d_height + 3) / 4) * ((dds_header.ddspf.dwFourCC == FOURCC_DXT1) ? 8 : 16);
+			d_size += ((d_width + 3) / 4) * ((d_height + 3) / 4) * ((dds_header.ddpfPixelFormat.dwFourCC == FOURCC_DXT1) ? 8 : 16);
 		}

-		if ( dds_header.dwCaps2 & DDSCAPS2_CUBEMAP ) {
-			if ( !(dds_header.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) ) {
+		if ( dds_header.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP ) {
+			if ( !(dds_header.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) ) {
 				retval = DDS_ERROR_CUBEMAP_FACES;
 				ct = DDS_DXT_INVALID;
 				goto Done;
@@ -175,7 +150,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 		Assert( d_size > 0 );
 		*size = d_size;

-		switch (dds_header.ddspf.dwFourCC) {
+		switch (dds_header.ddpfPixelFormat.dwFourCC) {
 			case FOURCC_DXT1:
 				bits = 24;
 				ct = (is_cubemap) ? DDS_CUBEMAP_DXT1 : DDS_DXT1;
@@ -199,18 +174,6 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 				goto Done;
 				break;

-			case FOURCC_DX10:
-				if (dds_read_dx10_header(ddsfile, &dds_header_dx10)) {
-					// Currently only BC7 is supported
-					bits = 32;
-					ct = DDS_BC7;
-				} else {
-					retval = DDS_ERROR_UNSUPPORTED;
-					ct = DDS_DXT_INVALID;
-					goto Done;
-				}
-				break;
-
 			// none of the above
 			default:
 				retval = DDS_ERROR_INVALID_FORMAT;
@@ -218,8 +181,8 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 				goto Done;
 				break;
 		}
-	} else if ( dds_header.ddspf.dwFlags & (DDPF_RGB | DDPF_PALETTEINDEXED8) ) {
-		d_size += d_width * d_height * d_depth * (dds_header.ddspf.dwRGBBitCount / 8);
+	} else if ( dds_header.ddpfPixelFormat.dwFlags & (DDPF_RGB | DDPF_PALETTEINDEXED8) ) {
+		d_size += d_width * d_height * d_depth * (dds_header.ddpfPixelFormat.dwRGBBitCount / 8);

 		// calculate full data size for all mipmap levels
 		for (i = 1; i < (int)dds_header.dwMipMapCount; i++) {
@@ -236,13 +199,13 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 			if (d_depth < 1)
 				d_depth = 1;

-			d_size += d_width * d_height * d_depth * (dds_header.ddspf.dwRGBBitCount / 8);
+			d_size += d_width * d_height * d_depth * (dds_header.ddpfPixelFormat.dwRGBBitCount / 8);
 		}

 		Assert( d_size > 0 );

-		if ( dds_header.dwCaps2 & DDSCAPS2_CUBEMAP ) {
-			if ( !(dds_header.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) ) {
+		if ( dds_header.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP ) {
+			if ( !(dds_header.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) ) {
 				retval = DDS_ERROR_CUBEMAP_FACES;
 				ct = DDS_DXT_INVALID;
 				goto Done;
@@ -257,7 +220,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh

 		*size = d_size;
 		
-		bits = dds_header.ddspf.dwRGBBitCount;
+		bits = dds_header.ddpfPixelFormat.dwRGBBitCount;
 		ct = (is_cubemap) ? DDS_CUBEMAP_UNCOMPRESSED : DDS_UNCOMPRESSED;
 	} else {
 		// it's not a readable format
@@ -294,7 +257,7 @@ int dds_read_header(const char *filename, CFILE *img_cfp, int *width, int *heigh
 		*levels = dds_header.dwMipMapCount;

 	if (palette && (bits == 8)) {
-		cfseek(ddsfile, (ct == DDS_BC7) ? DX10_OFFSET : DDS_OFFSET, CF_SEEK_SET);
+		cfseek(ddsfile, DDS_OFFSET, CF_SEEK_SET);
 		cfread(palette, 1, 1024, ddsfile);
 	}

@@ -344,7 +307,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type)
 		return retval;
 	}

-	cfseek(cfp, (ct == DDS_BC7) ? DX10_OFFSET : DDS_OFFSET, CF_SEEK_SET);
+	cfseek(cfp, DDS_OFFSET, CF_SEEK_SET);

 	// read in the data
 	cfread(data, 1, (int)size, cfp);
@@ -362,7 +325,7 @@ int dds_read_bitmap(const char *filename, ubyte *data, ubyte *bpp, int cf_type)
 // NOTE: we only support, uncompressed, 24-bit RGB and 32-bit RGBA images here!!
 void dds_save_image(int width, int height, int bpp, int num_mipmaps, ubyte *data, int cubemap, const char *filename)
 {
-	DDS_HEADER dds_header;
+	DDSURFACEDESC2 dds_header;
 	char real_filename[MAX_FILENAME_LEN];

 	if (data == NULL) {
@@ -371,7 +334,7 @@ void dds_save_image(int width, int height, int bpp, int num_mipmaps, ubyte *data
 	}

 	// header size check
-	if (sizeof(DDS_HEADER) != 124) {
+	if (sizeof(DDSURFACEDESC2) != 124) {
 		Int3();
 		return;
 	}
@@ -414,7 +377,7 @@ void dds_save_image(int width, int height, int bpp, int num_mipmaps, ubyte *data
 		num_mipmaps = 1;

 	// we have a filename and file handle, so now lets create our DDS header...
-	memset( &dds_header, 0, sizeof(DDS_HEADER) );
+	memset( &dds_header, 0, sizeof(DDSURFACEDESC2) );

 	uint flags = (DDSD_CAPS | DDSD_PITCH | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT);
 	uint pixel_flags = DDPF_RGB;
@@ -443,22 +406,22 @@ void dds_save_image(int width, int height, int bpp, int num_mipmaps, ubyte *data
 	dds_header.dwDepth				= 0;
 	dds_header.dwMipMapCount		= num_mipmaps;

-	dds_header.ddspf.dwSize				= 32;
-	dds_header.ddspf.dwFlags				= pixel_flags;
-	dds_header.ddspf.dwFourCC				= 0;
-	dds_header.ddspf.dwRGBBitCount		= bpp;
-	dds_header.ddspf.dwRBitMask			= 0x00ff0000;
-	dds_header.ddspf.dwGBitMask			= 0x0000ff00;
-	dds_header.ddspf.dwBBitMask			= 0x000000ff;
-	dds_header.ddspf.dwABitMask	= (bpp == 32) ? 0xff000000 : 0x00000000;
+	dds_header.ddpfPixelFormat.dwSize				= 32;
+	dds_header.ddpfPixelFormat.dwFlags				= pixel_flags;
+	dds_header.ddpfPixelFormat.dwFourCC				= 0;
+	dds_header.ddpfPixelFormat.dwRGBBitCount		= bpp;
+	dds_header.ddpfPixelFormat.dwRBitMask			= 0x00ff0000;
+	dds_header.ddpfPixelFormat.dwGBitMask			= 0x0000ff00;
+	dds_header.ddpfPixelFormat.dwBBitMask			= 0x000000ff;
+	dds_header.ddpfPixelFormat.dwRGBAlphaBitMask	= (bpp == 32) ? 0xff000000 : 0x00000000;

-	dds_header.dwCaps		= caps1;
-	dds_header.dwCaps2		= caps2;
+	dds_header.ddsCaps.dwCaps1		= caps1;
+	dds_header.ddsCaps.dwCaps2		= caps2;

 	// now save it all...
 	uint dds_id = DDS_FILECODE;
 	cfwrite(&dds_id, 1, 4, image);
-	cfwrite(&dds_header, 1, sizeof(DDS_HEADER), image);
+	cfwrite(&dds_header, 1, sizeof(DDSURFACEDESC2), image);

 	int faces = (cubemap) ? 6 : 1;
 	int f_width = width;
@@ -18,21 +18,20 @@
 #define DDS_ERROR_CUBEMAP_FACES			7		// file is a cubemap, but doesn't have all six faces


-#define DDS_DXT_INVALID                -1
+#define DDS_DXT_INVALID				-1
 #define DDS_UNCOMPRESSED				0
 #define DDS_DXT1						1
 #define DDS_DXT3						3
 #define DDS_DXT5						5
-#define DDS_BC7							7
 #define DDS_CUBEMAP_UNCOMPRESSED		10
 #define DDS_CUBEMAP_DXT1				11
 #define DDS_CUBEMAP_DXT3				13
 #define DDS_CUBEMAP_DXT5				15

 #ifndef MAKEFOURCC
-	#define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
-				((uint)(ubyte)(ch0) | ((uint)(ubyte)(ch1) << 8) |   \
-				((uint)(ubyte)(ch2) << 16) | ((uint)(ubyte)(ch3) << 24 ))
+    #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
+                ((uint)(ubyte)(ch0) | ((uint)(ubyte)(ch1) << 8) |   \
+                ((uint)(ubyte)(ch2) << 16) | ((uint)(ubyte)(ch3) << 24 ))
 #endif //defined(MAKEFOURCC)

 // FOURCC codes for DX compressed-texture pixel formats
@@ -41,7 +40,6 @@
 #define FOURCC_DXT3  (MAKEFOURCC('D','X','T','3'))
 #define FOURCC_DXT4  (MAKEFOURCC('D','X','T','4'))
 #define FOURCC_DXT5  (MAKEFOURCC('D','X','T','5'))
-#define FOURCC_DX10  (MAKEFOURCC('D','X','1','0'))

 #define DDS_FILECODE	0x20534444	// "DDS " in file

@@ -82,198 +80,60 @@
 									  DDSCAPS2_CUBEMAP_NEGATIVEZ )

 #pragma pack(1)
-enum class DXGI_FORMAT : uint {
-	DXGI_FORMAT_UNKNOWN,
-	DXGI_FORMAT_R32G32B32A32_TYPELESS,
-	DXGI_FORMAT_R32G32B32A32_FLOAT,
-	DXGI_FORMAT_R32G32B32A32_UINT,
-	DXGI_FORMAT_R32G32B32A32_SINT,
-	DXGI_FORMAT_R32G32B32_TYPELESS,
-	DXGI_FORMAT_R32G32B32_FLOAT,
-	DXGI_FORMAT_R32G32B32_UINT,
-	DXGI_FORMAT_R32G32B32_SINT,
-	DXGI_FORMAT_R16G16B16A16_TYPELESS,
-	DXGI_FORMAT_R16G16B16A16_FLOAT,
-	DXGI_FORMAT_R16G16B16A16_UNORM,
-	DXGI_FORMAT_R16G16B16A16_UINT,
-	DXGI_FORMAT_R16G16B16A16_SNORM,
-	DXGI_FORMAT_R16G16B16A16_SINT,
-	DXGI_FORMAT_R32G32_TYPELESS,
-	DXGI_FORMAT_R32G32_FLOAT,
-	DXGI_FORMAT_R32G32_UINT,
-	DXGI_FORMAT_R32G32_SINT,
-	DXGI_FORMAT_R32G8X24_TYPELESS,
-	DXGI_FORMAT_D32_FLOAT_S8X24_UINT,
-	DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS,
-	DXGI_FORMAT_X32_TYPELESS_G8X24_UINT,
-	DXGI_FORMAT_R10G10B10A2_TYPELESS,
-	DXGI_FORMAT_R10G10B10A2_UNORM,
-	DXGI_FORMAT_R10G10B10A2_UINT,
-	DXGI_FORMAT_R11G11B10_FLOAT,
-	DXGI_FORMAT_R8G8B8A8_TYPELESS,
-	DXGI_FORMAT_R8G8B8A8_UNORM,
-	DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
-	DXGI_FORMAT_R8G8B8A8_UINT,
-	DXGI_FORMAT_R8G8B8A8_SNORM,
-	DXGI_FORMAT_R8G8B8A8_SINT,
-	DXGI_FORMAT_R16G16_TYPELESS,
-	DXGI_FORMAT_R16G16_FLOAT,
-	DXGI_FORMAT_R16G16_UNORM,
-	DXGI_FORMAT_R16G16_UINT,
-	DXGI_FORMAT_R16G16_SNORM,
-	DXGI_FORMAT_R16G16_SINT,
-	DXGI_FORMAT_R32_TYPELESS,
-	DXGI_FORMAT_D32_FLOAT,
-	DXGI_FORMAT_R32_FLOAT,
-	DXGI_FORMAT_R32_UINT,
-	DXGI_FORMAT_R32_SINT,
-	DXGI_FORMAT_R24G8_TYPELESS,
-	DXGI_FORMAT_D24_UNORM_S8_UINT,
-	DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
-	DXGI_FORMAT_X24_TYPELESS_G8_UINT,
-	DXGI_FORMAT_R8G8_TYPELESS,
-	DXGI_FORMAT_R8G8_UNORM,
-	DXGI_FORMAT_R8G8_UINT,
-	DXGI_FORMAT_R8G8_SNORM,
-	DXGI_FORMAT_R8G8_SINT,
-	DXGI_FORMAT_R16_TYPELESS,
-	DXGI_FORMAT_R16_FLOAT,
-	DXGI_FORMAT_D16_UNORM,
-	DXGI_FORMAT_R16_UNORM,
-	DXGI_FORMAT_R16_UINT,
-	DXGI_FORMAT_R16_SNORM,
-	DXGI_FORMAT_R16_SINT,
-	DXGI_FORMAT_R8_TYPELESS,
-	DXGI_FORMAT_R8_UNORM,
-	DXGI_FORMAT_R8_UINT,
-	DXGI_FORMAT_R8_SNORM,
-	DXGI_FORMAT_R8_SINT,
-	DXGI_FORMAT_A8_UNORM,
-	DXGI_FORMAT_R1_UNORM,
-	DXGI_FORMAT_R9G9B9E5_SHAREDEXP,
-	DXGI_FORMAT_R8G8_B8G8_UNORM,
-	DXGI_FORMAT_G8R8_G8B8_UNORM,
-	DXGI_FORMAT_BC1_TYPELESS,
-	DXGI_FORMAT_BC1_UNORM,
-	DXGI_FORMAT_BC1_UNORM_SRGB,
-	DXGI_FORMAT_BC2_TYPELESS,
-	DXGI_FORMAT_BC2_UNORM,
-	DXGI_FORMAT_BC2_UNORM_SRGB,
-	DXGI_FORMAT_BC3_TYPELESS,
-	DXGI_FORMAT_BC3_UNORM,
-	DXGI_FORMAT_BC3_UNORM_SRGB,
-	DXGI_FORMAT_BC4_TYPELESS,
-	DXGI_FORMAT_BC4_UNORM,
-	DXGI_FORMAT_BC4_SNORM,
-	DXGI_FORMAT_BC5_TYPELESS,
-	DXGI_FORMAT_BC5_UNORM,
-	DXGI_FORMAT_BC5_SNORM,
-	DXGI_FORMAT_B5G6R5_UNORM,
-	DXGI_FORMAT_B5G5R5A1_UNORM,
-	DXGI_FORMAT_B8G8R8A8_UNORM,
-	DXGI_FORMAT_B8G8R8X8_UNORM,
-	DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM,
-	DXGI_FORMAT_B8G8R8A8_TYPELESS,
-	DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,
-	DXGI_FORMAT_B8G8R8X8_TYPELESS,
-	DXGI_FORMAT_B8G8R8X8_UNORM_SRGB,
-	DXGI_FORMAT_BC6H_TYPELESS,
-	DXGI_FORMAT_BC6H_UF16,
-	DXGI_FORMAT_BC6H_SF16,
-	DXGI_FORMAT_BC7_TYPELESS,
-	DXGI_FORMAT_BC7_UNORM,
-	DXGI_FORMAT_BC7_UNORM_SRGB,
-	DXGI_FORMAT_AYUV,
-	DXGI_FORMAT_Y410,
-	DXGI_FORMAT_Y416,
-	DXGI_FORMAT_NV12,
-	DXGI_FORMAT_P010,
-	DXGI_FORMAT_P016,
-	DXGI_FORMAT_420_OPAQUE,
-	DXGI_FORMAT_YUY2,
-	DXGI_FORMAT_Y210,
-	DXGI_FORMAT_Y216,
-	DXGI_FORMAT_NV11,
-	DXGI_FORMAT_AI44,
-	DXGI_FORMAT_IA44,
-	DXGI_FORMAT_P8,
-	DXGI_FORMAT_A8P8,
-	DXGI_FORMAT_B4G4R4A4_UNORM,
-	DXGI_FORMAT_P208,
-	DXGI_FORMAT_V208,
-	DXGI_FORMAT_V408,
-	DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE,
-	DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE,
-	DXGI_FORMAT_FORCE_UINT
-};
+// these structures are the headers for a dds file
+/*typedef struct _DDPIXELFORMAT {
+	uint	dwSize;
+	uint	dwFlags;
+	uint	dwFourCC;
+	uint	dwRGBBitCount;
+	uint	dwRBitMask;
+	uint 	dwGBitMask;
+	uint 	dwBBitMask;
+	uint	dwRGBAlphaBitMask;
+} DDPIXELFORMAT;

-/* Potentially useful for later stuff - (DahBlount)
-typedef enum D3D10_RESOURCE_MISC_FLAG : uint {
-	D3D10_RESOURCE_MISC_GENERATE_MIPS,
-	D3D10_RESOURCE_MISC_SHARED,
-	D3D10_RESOURCE_MISC_TEXTURECUBE,
-	D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX,
-	D3D10_RESOURCE_MISC_GDI_COMPATIBLE
-};
-*/
+typedef struct _DDSCAPS2
+{
+	uint		dwCaps1;
+	uint		dwCaps2;
+	uint		Reserved[2];
+} DDSCAPS2;*/

-enum class D3D10_RESOURCE_DIMENSION : uint {
-	D3D10_RESOURCE_DIMENSION_UNKNOWN,
-	D3D10_RESOURCE_DIMENSION_BUFFER,
-	D3D10_RESOURCE_DIMENSION_TEXTURE1D,
-	D3D10_RESOURCE_DIMENSION_TEXTURE2D,
-	D3D10_RESOURCE_DIMENSION_TEXTURE3D
-};
-
-/* This is set in shaders for the most part - (DahBlount)
-typedef enum DDS_ALPHA_MODE : uint {
-	DDS_ALPHA_MODE_UNKNOWN,
-	DDS_ALPHA_MODE_STRAIGHT,
-	DDS_ALPHA_MODE_PREMULTIPLIED,
-	DDS_ALPHA_MODE_OPAQUE,
-	DDS_ALPHA_MODE_CUSTOM
-};
-*/
-
-typedef struct {
-	uint           dwSize;
-	uint           dwFlags;
-	uint           dwHeight;
-	uint           dwWidth;
-	uint           dwPitchOrLinearSize;
-	uint           dwDepth;
-	uint           dwMipMapCount;
-	uint           dwReserved1[11];
+typedef struct _DDSURFACEDESC2
+{
+	uint			dwSize;				// size of the DDSURFACEDESC structure
+	uint			dwFlags;			// determines what fields are valid
+	uint			dwHeight;			// height of surface to be created
+	uint			dwWidth;			// width of input surface
+	uint			dwPitchOrLinearSize;
+	uint			dwDepth;
+	uint			dwMipMapCount;
+	uint			dwReserved1[11];

 	struct {
-		uint dwSize;
-		uint dwFlags;
-		uint dwFourCC;
-		uint dwRGBBitCount;
-		uint dwRBitMask;
-		uint dwGBitMask;
-		uint dwBBitMask;
-		uint dwABitMask;
-	} ddspf;
+		uint	dwSize;
+		uint	dwFlags;
+		uint	dwFourCC;
+		uint	dwRGBBitCount;
+		uint	dwRBitMask;
+		uint 	dwGBitMask;
+		uint 	dwBBitMask;
+		uint	dwRGBAlphaBitMask;
+	} ddpfPixelFormat;

-	uint           dwCaps;
-	uint           dwCaps2;
-	uint           dwCaps3;
-	uint           dwCaps4;
-	uint           dwReserved2;
-} DDS_HEADER;
+	struct {
+		uint		dwCaps1;
+		uint		dwCaps2;
+		uint		Reserved[2];
+	} ddsCaps;

-typedef struct {
-	DXGI_FORMAT              dxgiFormat;
-	D3D10_RESOURCE_DIMENSION resourceDimension;
-	uint                     miscFlag;
-	uint                     arraySize;
-	uint                     miscFlags2;
-} DDS_HEADER_DXT10;
+//	DDPIXELFORMAT	ddpfPixelFormat;
+//	DDSCAPS2		ddsCaps;			// direct draw surface capabilities
+	uint			dwReserved2;
+} DDSURFACEDESC2;
 #pragma pack()

-#define DDS_OFFSET						4+sizeof(DDS_HEADER)		//place where the data starts -- should be 128
-#define DX10_OFFSET						DDS_OFFSET+sizeof(DDS_HEADER_DXT10)		// Unless a DX10 header is present
+#define DDS_OFFSET						4+sizeof(DDSURFACEDESC2)		//place where the data starts -- should be 128

 //reads a dds header
 //returns one of the error values