Don't reset target restrictions during table load

Prevents an issue with load order causing target restrictions to be reset.

.circleci/config.yml

@@ -0,0 +1,182 @@
+version: 2
+
+references:
+  container_config: &container_config
+    docker:
+      - image: "debian:stretch"
+        working_directory: /root/build
+
+  restore_repo: &restore_repo
+    restore_cache:
+      keys:
+        - source-repo-{{ .Branch }}-{{ .Revision }}
+        - source-repo-{{ .Branch }}
+        - source-repo
+
+  cmake_configure: &cmake_configure
+    run:
+      name: Creating Build Files
+      command: |
+        mkdir build
+        cd build
+
+        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
+
+        eval $CC --version
+
+        export CXXFLAGS
+        export CFLAGS
+        CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
+        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON ..
+
+  compile: &compile
+    run:
+      name: Compiling Source code
+      command: |
+        cd build
+        ninja -k 20 all
+
+  run_tests: &run_tests
+    run:
+      name: Run unit tests
+      command: |
+        ./build/bin/unittests --gtest_shuffle
+
+  compile_steps: &compile_steps
+    steps:
+      - *restore_repo
+      - *cmake_configure
+      - *compile
+      - *run_tests
+jobs:
+  checkout_code:
+    <<: *container_config
+    steps:
+      - run:
+          name: Installing Git
+          command: 'apt-get update && apt-get -yq install git'
+      - *restore_repo
+      - checkout
+      - run:
+          name: Updating submodules
+          command: 'git submodule update --init --recursive'
+      - save_cache:
+          key: source-repo-{{ .Branch }}-{{ .Revision }}
+          paths:
+            - .
+
+  build_gcc_lowest_debug:
+    docker:
+      - image: asarium/fso_compile:gcc-lowest
+        working_directory: /root/build
+    environment:
+      CC: gcc
+      CXX: g++
+      CONFIGURATION: Debug
+    <<: *compile_steps
+
+  build_gcc_lowest_release:
+    docker:
+      - image: asarium/fso_compile:gcc-lowest
+        working_directory: /root/build
+    environment:
+      CC: gcc
+      CXX: g++
+      CONFIGURATION: Release
+    <<: *compile_steps
+
+  build_gcc_latest_debug:
+    docker:
+      - image: asarium/fso_compile:gcc-latest
+        working_directory: /root/build
+    environment:
+      CC: gcc
+      CXX: g++
+      CONFIGURATION: Debug
+    <<: *compile_steps
+
+  build_gcc_latest_release:
+    docker:
+      - image: asarium/fso_compile:gcc-latest
+        working_directory: /root/build
+    environment:
+      CC: gcc
+      CXX: g++
+      CONFIGURATION: Release
+    <<: *compile_steps
+
+  build_clang_latest_debug:
+    docker:
+      - image: asarium/fso_compile:clang-latest
+        working_directory: /root/build
+    environment:
+      CC: clang-8
+      CXX: clang++-8
+      CONFIGURATION: Debug
+    <<: *compile_steps
+
+  build_clang_latest_release:
+    docker:
+      - image: asarium/fso_compile:clang-latest
+        working_directory: /root/build
+    environment:
+      CC: clang-8
+      CXX: clang++-8
+      CONFIGURATION: Release
+    <<: *compile_steps
+
+  build_clang_lowest_debug:
+    docker:
+      - image: asarium/fso_compile:clang-lowest
+        working_directory: /root/build
+    environment:
+      CC: clang
+      CXX: clang++
+      CONFIGURATION: Debug
+    <<: *compile_steps
+
+  build_clang_lowest_release:
+    docker:
+      - image: asarium/fso_compile:clang-lowest
+        working_directory: /root/build
+    environment:
+      CC: clang
+      CXX: clang++
+      CONFIGURATION: Release
+    <<: *compile_steps
+
+workflows:
+  version: 2
+
+  build_test:
+    jobs:
+      - checkout_code
+      - build_gcc_lowest_debug:
+          requires:
+            - checkout_code
+      - build_gcc_lowest_release:
+          requires:
+            - checkout_code
+      - build_gcc_latest_debug:
+          requires:
+            - checkout_code
+      - build_gcc_latest_release:
+          requires:
+            - checkout_code
+      - build_clang_latest_debug:
+          requires:
+            - checkout_code
+      - build_clang_latest_release:
+          requires:
+            - checkout_code
+      - build_clang_lowest_debug:
+          requires:
+            - checkout_code
+      - build_clang_lowest_release:
+          requires:
+            - checkout_code

.clang-format

@@ -1,25 +1,27 @@
 ---
 Language:        Cpp
+Standard: Cpp11
 # BasedOnStyle:  LLVM
 AccessModifierOffset: -2
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: true
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: false
+AlignEscapedNewlines: Left
 AlignOperands:   true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
+AllowAllArgumentsOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: true
-BinPackArguments: true
-BinPackParameters: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
 BraceWrapping:   
   AfterClass:      false
   AfterControlStatement: false
@@ -47,17 +49,20 @@ Cpp11BracedListStyle: true
 DerivePointerAlignment: false
 DisableFormat:   false
 ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Regroup
 IncludeCategories:
   - Regex:           '^(<.*\.(h|hh|hpp)>)$' # Includes of external libraries
-    Priority:        4
-  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
     Priority:        5
-  - Regex:           '^"[^/]*\.(h)"$' # Local includes
+  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
+    Priority:        6
+  - Regex:           '^"globalincs\/.*\.h"$' # globalincs always come first
     Priority:        1
-  - Regex:           '^".*\.(h)"$' # standard engine includes
+  - Regex:           '^"[^/]*\.(h)"$' # Local includes
     Priority:        2
-  - Regex:           '.*' # Catch all in case something is unhandled above
+  - Regex:           '^".*\.(h)"$' # standard engine includes
     Priority:        3
+  - Regex:           '.*' # Catch all in case something is unhandled above
+    Priority:        4
 IncludeIsMainRegex: '$'
 IndentCaseLabels: false
 IndentWidth:     4
@@ -92,8 +97,7 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
 TabWidth:        4
-UseTab:          ForIndentation
+UseTab:          ForContinuationAndIndentation
 ...
 

.clang-tidy

@@ -4,13 +4,27 @@ modernize-*,\
 -modernize-raw-string-literal,\
 -modernize-use-using,\
 -modernize-make-unique,\
+-modernize-use-trailing-return-type,\
+-modernize-avoid-c-arrays,\
 performance-*,\
 -performance-type-promotion-in-math-fn,\
 misc-*,\
 -misc-macro-parentheses,\
 -misc-misplaced-widening-cast,\
 -misc-static-assert,\
--modernize-make-unique,\
+-misc-unused-parameters,\
+-misc-non-private-member-variables-in-classes,\
+readability-*,\
+-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,\
+-readability-else-after-return,\
 "
 WarningsAsErrors: ''
 HeaderFilterRegex: 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$'
@@ -20,5 +34,7 @@ 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
 ...
 

.dockerignore

@@ -0,0 +1,2 @@
+/build
+/.git

.editorconfig

@@ -5,3 +5,7 @@ indent_style = tab
 
 [*.sdr]
 indent_style = tab
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2

.gitattributes

@@ -0,0 +1,7 @@
+# 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

.github/workflows/pr-workflow.yaml

@@ -0,0 +1,130 @@
+name: Check a pull request
+
+on: [pull_request]
+
+jobs:
+  build_linux:
+    strategy:
+      matrix:
+        configuration: [Debug, Release]
+        compiler: [gcc-5, gcc-9, clang-4.0]
+    name: Linux
+    runs-on: ubuntu-16.04
+    steps:
+      - name: Prepare Environment
+        env:
+          DEBIAN_FRONTEND: noninteractive
+        run: |
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test
+          sudo add-apt-repository ppa:beineri/opt-qt571-xenial
+          sudo add-apt-repository ppa:msulikowski/valgrind # For fixing a bug with valgrind 3.11 which does not recognize the rdrand instruction
+          sudo apt-get -yq update
+          sudo apt-get -yq install cmake ninja-build libopenal-dev libreadline6-dev libpng12-dev libjpeg62-dev liblua5.1-0-dev libjansson-dev libsdl2-dev libfreetype6-dev valgrind qt57base g++-5 g++-9 clang-4.0 clang-tidy-4.0 libc++-dev libc++abi-dev
+          # Fix a header bug present in ubuntu...
+          sudo ln -s /usr/include/libcxxabi/__cxxabi_config.h /usr/include/c++/v1/__cxxabi_config.h
+      - uses: actions/checkout@v1
+        name: Checkout
+        with:
+          submodules: true
+      - name: Configure CMake
+        env:
+          CONFIGURATION: ${{ matrix.configuration }}
+          COMPILER: ${{ matrix.compiler }}
+        run: |
+          if [ "$COMPILER" = "gcc-5" ]; then
+            export CC=gcc-5
+            export CXX=g++-5
+          fi
+          if [ "$COMPILER" = "gcc-9" ]; then
+            export CC=gcc-9
+            export CXX=g++-9
+          fi
+          if [ "$COMPILER" = "clang-4.0" ]; then
+            export CC=clang-4.0
+            export CXX=clang++-4.0
+          fi
+
+          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
+
+          mkdir build
+          cd build
+
+          export CXXFLAGS
+          export CFLAGS
+          CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
+          eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
+      - name: Compile
+        working-directory: ./build
+        run: ninja -k 20 all
+      - name: Run Tests
+        working-directory: ./build
+        env:
+          CONFIGURATION: ${{ matrix.configuration }}
+        run: |
+          if [ "$CONFIGURATION" = "Debug" ]; then
+              valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
+                  --suppressions="$GITHUB_WORKSPACE/ci/travis/valgrind.supp" ./bin/unittests --gtest_shuffle
+          else
+              ./bin/unittests --gtest_shuffle
+          fi
+  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: 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" -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

.github/workflows/standalone-image-workflow.yaml

@@ -0,0 +1,48 @@
+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 }}

.gitignore

@@ -257,3 +257,4 @@ CMakeSettings.json
 # This gets ignored by one of the rules above for some reason...
 !/code/scripting/lua/LuaConvert.h
 !/code/debugconsole/
+!/docker/build

.travis.yml

@@ -1,10 +1,11 @@
 language: bash
 sudo: required
-dist: trusty
+dist: xenial
 cache:
   directories:
     - $HOME/cmake-3.8
     - $HOME/.ccache
+    - $HOME/curl_cache
 addons:
   apt:
     packages: &global_deps
@@ -17,7 +18,6 @@ addons:
       - libjansson-dev
       - libsdl2-dev
       - libfreetype6-dev
-      - valgrind
       - qt57base
   coverity_scan:
     project:
@@ -36,13 +36,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 FS2DOWNLOADS_USER and FS2DOWNLOADS_PASSWORD
-    - secure: "h6GbMX2jLsW1bS9fCM9fthOSJ1nfQQIRWi6EUH2p8u4NFLD5Bfi/C8JhQPKHUzyo3wvKkSHl+PsW7bgr1oXLusRwAur/dtv2N3imqvtbfIz305b00hZlsvbcYmQmUzQFSAdOGShK57JJ5aKQKccaUBP25KqB7Q+JaqBRdaMBS54="
-    - secure: "fUDAPAUUaaYZy8I4zU3SJ0JcK7aw4eb6eTdaEr7LyNyTMSfPgwY6P1MrbSQC0lJNQIUQ5ffjdxE5g7D7OYpoJF9L14ni4UY8t2QASt7kmpgcYihmjeuYy8FQXgmFG8CTxiWBPKTybZJ7voQcvIvRaNG7b2wM9PMfc5lRIondB6c="
+    # These declarations set DATACORDER_USER and DATACORDER_PASSWORD
+    - secure: "dpBH/dDN3bmU/NFlh+2v9isNx9wX0ocoRy+W+kBXRH32sosUGp26REhMqgVRpBNP5oxPBU8ic5bEogxAYWCB+0xUygBbkxAwyMPgoA34s0OXdTCY/ofw14ni8qqV2Ffy7fQJbP/jkMURyiMHx3kBTxNv3YjxKJqLnOuOMlQLpT8="
+    - secure: "tLMRBD1Ufp5iKNwlqPDVbbuczgusaXNoBJyAnPATpJq2YwlkW4j3PqP9rW5vd85+52xam2EOP20w9PoBR5J6FLdiXRu4Lf7yCEhSHFAgowVqQj8QcJpPlyXr90bM4emFGrGqpdxVwxyQ5AFhKwLuEZKsI14GYLN+UMEwpNCMing="
 deploy:
   - provider: releases
     api_key:
-      secure: "Wdt4Ccefo7a0ZDjEJQJgpghh7n72FtNJuKSAPUvoz4gtEX6Ct9J8yJI1t9V3jE3CTbbLJ21/Q6eZRDfT7UfNJe5DdepoJsP9DeFhKMWqQCq+AChqQWlm0KeZAffJoJreL8vXYhnRYcLT9ceZHEH6AqwN9TPV+xJziGPISAkYNZ8="
+      secure: "q619+eQTe7lv8UVphK4OIzU8Jw84KBbVkuprN2sWIubRcV3IbZr2+WahJoUMt+nyhiy3YjDYtstO2ZgkxupwnZgwGUBVIiD1c4SPuyy+HTjNMOtiVsEUHT2hf+xPAemWpTlK5HcwhMmHAOh6rt6dEj57QOg0gcmGiwD/tCbEriA="
     skip_cleanup: true
     file_glob: true
     file: "/tmp/builds/*"
@@ -72,33 +72,43 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
             - *global_deps
             - g++-5
     - os: linux
-      env: CONFIGURATION="Debug" CC=gcc-8 CXX=g++-8
+      env: CONFIGURATION="Debug" CC=gcc-9 CXX=g++-9
       addons:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
-            - g++-8
+            - g++-9
             - *global_deps
     - os: linux
-      env: CONFIGURATION="Debug" CC=clang-4.0 CXX=clang++-4.0 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      env: CONFIGURATION="Debug" CC=clang-4.0 CXX=clang++-4.0 CMAKE_OPTIONS="-DCLANG_USE_LIBCXX=ON"
       addons:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - llvm-toolchain-xenial-8
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
             - *global_deps
             - clang-4.0
-            - clang-tidy-4.0
             - libc++-dev
+            - libc++abi-dev
+    - os: linux
+      env: CONFIGURATION="Debug" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-9
       script:
         - ./ci/travis/script.sh
         - ./ci/travis/clang_tidy.sh
@@ -116,32 +126,46 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
             - *global_deps
             - g++-5
     - os: linux
-      env: CONFIGURATION="Release" CC=gcc-8 CXX=g++-8
+      env: CONFIGURATION="Release" CC=gcc-9 CXX=g++-9
       addons:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
-            - g++-8
+            - g++-9
             - *global_deps
     - os: linux
-      env: CONFIGURATION="Release" CC=clang-4.0 CXX=clang++-4.0
+      env: CONFIGURATION="Release" CC=clang-4.0 CXX=clang++-4.0 CMAKE_OPTIONS="-DCLANG_USE_LIBCXX=ON"
       addons:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-            - sourceline: 'ppa:beineri/opt-qt571-trusty'
+            - llvm-toolchain-xenial-8
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
           packages:
             - *global_deps
             - clang-4.0
             - libc++-dev
+            - libc++abi-dev
+    - os: linux
+      env: CONFIGURATION="Release" CC=clang-9 CXX=clang++-9 CMAKE_OPTIONS="-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:beineri/opt-qt571-xenial'
+          packages:
+            - *global_deps
+            - g++-9
+      script:
+        - ./ci/travis/script.sh
+        - ./ci/travis/clang_tidy.sh
     - os: osx
       env: CONFIGURATION="Release"
 
@@ -149,14 +173,10 @@ matrix:
       env: CONFIGURATION="Release" CMAKE_TOOLSET=v141_xp CMAKE_GENERATOR="Visual Studio 15 2017"
     - os: windows
       env: CONFIGURATION="Release" CMAKE_TOOLSET="" CMAKE_GENERATOR="Ninja"
-  # As long as Windows is still experimental on Travis CI, allow failures
+  # There is a GCC compiler bug with MinGW that causes compilation failures on Windows at the moment
   allow_failures:
-    - os: windows
-      env: CONFIGURATION="Debug" CMAKE_TOOLSET=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

AUTHORS

@@ -1,29 +0,0 @@
-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

About.md

@@ -0,0 +1,41 @@
+## 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.) 

Authors.md

@@ -0,0 +1,8 @@
+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

CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 include(cmake/util.cmake)
 
 # Set a few policies
-set_policy(CMP0051 OLD)
+set_policy(CMP0051 NEW)
 set_policy(CMP0053 NEW)
 set_policy(CMP0054 NEW)
 
@@ -117,6 +117,10 @@ 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)
+
 MARK_AS_ADVANCED(FORCE FSO_CMAKE_DEBUG)
 MARK_AS_ADVANCED(FORCE FSO_BUILD_INCLUDED_LIBS)
 MARK_AS_ADVANCED(FORCE FSO_USE_OPENALSOFT)
@@ -125,6 +129,8 @@ 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)
 
 # Include cotire file from https://github.com/sakra/cotire/
 include(cotire)
@@ -197,3 +203,5 @@ 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}")

Changelog.md

@@ -1,23 +1,131 @@
+# 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...)
 ==================================================================
@@ -351,7 +459,7 @@ http://www.hard-light.net/forums/index.php?topic=85700.0
 	(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
 
@@ -1886,3 +1994,4 @@ NOTE:
 
 # generated by cvs2cl.pl
 # cvs2cl.pl -r -S --utc -f ChangeLog2
+```

Copying.md

@@ -1,14 +1,15 @@
 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
+>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."
+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.
 
+See [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing) for more information.

INSTALL

@@ -1,29 +0,0 @@
-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

Readme.md

@@ -7,36 +7,5 @@ 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>
 
-### 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.
+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.

UpdatingDocumentation.md

@@ -0,0 +1,18 @@
+#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)

appveyor.yml

@@ -9,11 +9,11 @@ environment:
     - BuildID: 0
       CMAKE_GENERATOR: Visual Studio 14 2015
       PlatformToolset: v140_xp
-      QT_DIR: C:\Qt\5.9.5\msvc2015
+      QT_DIR: C:\Qt\5.9\msvc2015
     - BuildID: 1
       CMAKE_GENERATOR: Visual Studio 14 2015 Win64
       PlatformToolset: v140_xp
-      QT_DIR: C:\Qt\5.9.5\msvc2015_64
+      QT_DIR: C:\Qt\5.9\msvc2015_64
 before_build:
   - git submodule update --init --recursive
 build_script:
@@ -24,7 +24,7 @@ test_script:
 deploy:
     - provider: GitHub
       auth_token:
-          secure: 3kV4efHXwRnfXzmJPRAOs8D7+MhwXUXYeayI/P5y114L09kJa6b6L70beXdW7yYr
+          secure: h55Scpy+3vmo1Yb7WlSIGA4d9DRnsbzUYc2LYsQdByQHZHbqrqjBpicH0D2FFLEO
       on:
           ReleaseBuild: true        # deploy on release push only
 
@@ -40,25 +40,23 @@ deploy:
           NightlyBuild: true        # deploy on nightly push only
 
     - provider: FTP
-      protocol: ftp
-      host: swc.fs2downloads.com
-      username: 
-        secure: EXg2ADoKzMduZF90ip2Q0g==
+      protocol: sftp
+      host: porphyrion.feralhosting.com
+      username:
+        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
       password:
-        secure: x0LL0uY9yBAQ7JTARhQ6AA==
-      folder: swc.fs2downloads.com/builds/nightly/$(VersionName)
-      beta: true
+        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
+      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$(VersionName)
       on:
           NightlyBuild: true        # deploy on nightly push only
 
     - provider: FTP
-      protocol: ftp
-      host: swc.fs2downloads.com
-      username: 
-        secure: EXg2ADoKzMduZF90ip2Q0g==
+      protocol: sftp
+      host: porphyrion.feralhosting.com
+      username:
+        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
       password:
-        secure: x0LL0uY9yBAQ7JTARhQ6AA==
-      folder: swc.fs2downloads.com/builds/test/$(VersionName)
-      beta: true
+        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
+      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$(VersionName)
       on:
           TestBuild: true        # deploy on test build push only

ci/appveyor/build.ps1

@@ -14,7 +14,7 @@ $NightlyConfigurations = @(
 		PackageType="Win64";
 		Toolset="v140_xp";
 		SimdType="SSE2";
-		QtDir="C:\Qt\5.9.5\msvc2015_64";
+		QtDir="C:\Qt\5.9\msvc2015_64";
 		SourcePackage=$false;
 	},
 	[BuildConfig]@{ 
@@ -22,7 +22,7 @@ $NightlyConfigurations = @(
 		PackageType="Win32";
 		Toolset="v140_xp";
 		SimdType="SSE2";
-		QtDir="C:\Qt\5.9.5\msvc2015";
+		QtDir="C:\Qt\5.9\msvc2015";
 		SourcePackage=$false;
 	}
 )
@@ -32,7 +32,7 @@ $ReleaseConfigurations = @(
 		PackageType="Win32";
 		Toolset="v140_xp";
 		SimdType="SSE2";
-		QtDir="C:\Qt\5.9.5\msvc2015";
+		QtDir="C:\Qt\5.9\msvc2015";
 		SourcePackage=$true;
 	}
 	[BuildConfig]@{
@@ -40,7 +40,7 @@ $ReleaseConfigurations = @(
 		PackageType="Win32-AVX";
 		Toolset="v140_xp";
 		SimdType="AVX";
-		QtDir="C:\Qt\5.9.5\msvc2015";
+		QtDir="C:\Qt\5.9\msvc2015";
 		SourcePackage=$false;
 	}
 	[BuildConfig]@{
@@ -48,7 +48,7 @@ $ReleaseConfigurations = @(
 		PackageType="Win64";
 		Toolset="v140_xp";
 		SimdType="SSE2";
-		QtDir="C:\Qt\5.9.5\msvc2015_64";
+		QtDir="C:\Qt\5.9\msvc2015_64";
 		SourcePackage=$false;
 	}
 	[BuildConfig]@{
@@ -56,7 +56,7 @@ $ReleaseConfigurations = @(
 		PackageType="Win64-AVX";
 		Toolset="v140_xp";
 		SimdType="AVX";
-		QtDir="C:\Qt\5.9.5\msvc2015_64";
+		QtDir="C:\Qt\5.9\msvc2015_64";
 		SourcePackage=$false;
 	}
 )
@@ -134,6 +134,7 @@ 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")
@@ -145,8 +146,11 @@ if ($DeployBuild) {
     	}
 	}
 
-    7z a "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
+    7z a -xr'!*.pdb' "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
     Push-AppveyorArtifact "$($PackageName)-builds-$($buildConfig.PackageType).zip"
+
+	7z a "$($PackageName)-debug-$($buildConfig.PackageType).7z" "$env:APPVEYOR_BUILD_FOLDER/../install/*.pdb"
+	Push-AppveyorArtifact "$($PackageName)-debug-$($buildConfig.PackageType).7z"
 } else {
 	cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="ON" -DFSO_BUILD_TESTS="ON" -DMSVC_SIMD_INSTRUCTIONS=SSE2 `
 	-DFSO_BUILD_QTFRED=ON -DQT5_INSTALL_ROOT="$env:QT_DIR" -DFSO_BUILD_FRED2="ON" `

ci/travis/before_install.sh

@@ -3,8 +3,14 @@
 set -ex
 
 if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    # Nothing to do here
-    :
+    export DEBIAN_FRONTEND=noninteractive
+
+    sudo add-apt-repository -y "ppa:msulikowski/valgrind" # For fixing a bug with valgrind 3.11 which does not recognize the rdrand instruction
+
+    wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+    sudo add-apt-repository -y 'deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+
+    sudo apt-get -yq update
 elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
     # Nothing to do here
     :

ci/travis/before_script.sh

@@ -18,10 +18,6 @@ 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"

ci/travis/clang-tidy-diff.py

@@ -2,10 +2,9 @@
 #
 #===- 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.
+# 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
 #
 #===------------------------------------------------------------------------===#
 
@@ -25,117 +24,245 @@ Example usage for git/svn users:
 """
 
 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 = 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('--')]
 
-  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)
 
-  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
 
-  # 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
 
-    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])
 
-    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)
 
-  if len(lines_by_file) == 0:
-    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)
 
-  line_filter_json = json.dumps(
-    [{"name" : name, "lines" : lines_by_file[name]} for name in lines_by_file],
-    separators = (',', ':'))
+    tmpdir = None
+    if yaml and args.export_fixes:
+        tmpdir = tempfile.mkdtemp()
 
-  quote = "";
-  if sys.platform == 'win32':
-    line_filter_json=re.sub(r'"', r'"""', line_filter_json)
-  else:
-    quote = "'";
+    # Tasks for clang-tidy.
+    task_queue = queue.Queue(max_task_count)
+    # A lock for console output.
+    lock = threading.Lock()
 
-  # 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)
+    # 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)
 
-  sys.exit(subprocess.call(' '.join(command), shell=True))
 
 if __name__ == '__main__':
-  main()
+    main()

ci/travis/clang_tidy.sh

@@ -12,8 +12,8 @@ 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 | \
+    -regex '(code|freespace2|qtfred|testsrc|build|tools)\/.*\.(cpp|h)' \
+    -clang-tidy-binary /usr/bin/clang-tidy-9 -j$(nproc) -quiet 2>/dev/null | \
     tee clang-tidy-output.txt
 
 if [[ -n $(grep "warning: " clang-tidy-output.txt) ]] || [[ -n $(grep "error: " clang-tidy-output.txt) ]]; then

ci/travis/ftp_deploy.sh

@@ -10,27 +10,62 @@ if [[ ! "$(curl -V)" == *"sftp"* ]]; then
 
     if [ "$TRAVIS_OS_NAME" = "linux" ]; then
 
-        # Since the Travis CI people are not capable of enabling SSH/SCP support for their libcurl we need to build that manually...
-        # These commands are based on the tutorial from here: http://zeroset.mnim.org/2013/03/14/sftp-support-for-curl-in-ubuntu-12-10-quantal-quetzal-and-later/
-        mkdir /tmp/curl
-        cd /tmp/curl
-        sudo apt-get update
-        sudo apt-get install build-essential debhelper libssh2-1-dev libgnutls-dev libidn11-dev libkrb5-dev libldap2-dev libnss3-dev librtmp-dev libtool openssh-server quilt
-        apt-get source curl
-        sudo apt-get build-dep curl
+        if [ -f ~/curl_cache/curl*.deb ]; then
+            cd ~/curl_cache
+            sudo dpkg -i libcurl3*.deb
+            sudo dpkg -i curl*.deb
+        else
+            # Since the Travis CI people are not capable of enabling SSH/SCP support for their libcurl we need to build that manually...
+            # These commands are based on the tutorial from here: http://zeroset.mnim.org/2013/03/14/sftp-support-for-curl-in-ubuntu-12-10-quantal-quetzal-and-later/
+            mkdir /tmp/curl
+            cd /tmp/curl
+            sudo apt-get update
+            sudo apt-get install build-essential debhelper libssh2-1-dev libgnutls-dev libidn11-dev libkrb5-dev libldap2-dev libnss3-dev librtmp-dev libtool openssh-server quilt
+            apt-get source curl
+            sudo apt-get build-dep curl
 
-        cd curl-*
-        export DEB_BUILD_OPTIONS="nocheck"
-        sudo dpkg-buildpackage -uc -us -j"$(grep -c ^processor /proc/cpuinfo)"
+            cd curl-*
+            export DEB_BUILD_OPTIONS="nocheck"
+            sudo dpkg-buildpackage -uc -us -j"$(grep -c ^processor /proc/cpuinfo)"
 
-        cd ..
-        dpkg -l | grep curl
-        ls -al
-        sudo dpkg -i libcurl3*.deb
-        sudo dpkg -i curl*.deb
+            cd ..
+            dpkg -l | grep curl
+            ls -al
+
+            if [ ! -d ~/curl_cache ]; then
+                mkdir ~/curl_cache
+            fi
+
+            cp libcurl3*.deb curl*.deb ~/curl_cache
+
+            sudo dpkg -i libcurl3*.deb
+            sudo dpkg -i curl*.deb
+        fi
     elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-        brew install curl --with-libssh2
-        export PATH="/usr/local/opt/curl/bin:$PATH"
+        brew install libssh2
+        
+        if [ -d ~/curl_cache/curl ]; then
+            cd ~/curl_cache/curl
+            sudo make install
+        else
+            mkdir /tmp/curl
+            cd /tmp/curl
+
+            curl -LO "https://curl.haxx.se/download/curl-7.64.0.tar.bz2"
+            tar -xjf curl-7.64.0.tar.bz2
+
+            cd curl-7.64.0
+            ./configure --disable-debug --disable-dependency-tracking --disable-silent-rules --with-libssh2 --with-darwinssl --without-ca-bundle --without-ca-path
+            make -j"$(sysctl hw.logicalcpu | cut -d " " -f 2)"
+
+            if [ ! -d ~/curl_cache ]; then
+                mkdir ~/curl_cache
+            fi
+
+            cp -a . ~/curl_cache/curl
+            sudo make install
+        fi
+        export PATH=/usr/local/bin:$PATH
     fi
 
     # After
@@ -42,13 +77,13 @@ cd /tmp/builds
 
 for file in *; do
     if [ "$TEST_BUILD" = true ]; then
-        # 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
+        # Upload to datacorder
+        curl -k "sftp://porphyrion.feralhosting.com/www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
     else
         # Upload to indiegames
         curl -k "sftp://scp.indiegames.us/~/public_html/builds/nightly/$VERSION_NAME/" --user "$INDIEGAMES_USER:$INDIEGAMES_PASSWORD" -T "$file" --ftp-create-dirs
 
-        # Upload to fs2downloads
-        curl -k "ftp://swc.fs2downloads.com/swc.fs2downloads.com/builds/nightly/$VERSION_NAME/" --user "$FS2DOWNLOADS_USER:$FS2DOWNLOADS_PASSWORD" -T "$file" --ftp-create-dirs
+        # Upload to datacorder
+        curl -k "sftp://porphyrion.feralhosting.com/~/www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$VERSION_NAME/" --user "$DATACORDER_USER:$DATACORDER_PASSWORD" -T "$file" --ftp-create-dirs
     fi
 done

ci/travis/install.sh

@@ -1,9 +1,11 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 set -ex
 
 FILENAME=
 if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    export DEBIAN_FRONTEND=noninteractive
+
     if [ ! -d "$HOME/cmake-3.8/bin" ]; then
         # If the cache does not currently contain CMake then download and install it
     	mkdir -p $HOME/cmake-3.8/
@@ -11,7 +13,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
     
@@ -22,6 +24,17 @@ 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
     

ci/travis/script.sh

@@ -7,7 +7,6 @@ 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

ci/travis/valgrind.supp

@@ -41,3 +41,124 @@
    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
+}
+{
+   <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
+}

cmake/AppRun.in

@@ -1,4 +1,4 @@
 #!/bin/sh
 HERE=$(dirname $(readlink -f "${0}"))
 export LD_LIBRARY_PATH="${HERE}"/lib:"$LD_LIBRARY_PATH"
-"${HERE}"/bin/$<TARGET_FILE_NAME:Freespace2> $@
+exec "${HERE}"/bin/$<TARGET_FILE_NAME:Freespace2> $@

cmake/platform-unix.cmake

@@ -3,7 +3,7 @@ INCLUDE(util)
 
 MESSAGE(STATUS "Configuring UNIX specific things and stuff...")
 
-target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL)
+target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL _REENTRANT)
 
 # Set RPATH
 set(CMAKE_SKIP_BUILD_RPATH TRUE)

cmake/platform-win32.cmake

@@ -8,7 +8,7 @@ SET(WIN32_LIBS
 	odbccp32
 	vfw32
 	winmm
-	wsock32
+	ws2_32
 	psapi
 )
 

cmake/platformChecks.cmake

@@ -10,8 +10,8 @@ include(CheckSymbolExists)
 include(CheckCXXSymbolExists)
 include(CheckTypeSize)
 
-CHECK_INCLUDE_FILE("execinfo.h" HAVE_EXECINFO_H)
-CHECK_INCLUDE_FILE_CXX("cxxabi.h" HAVE_CXXAPI_H)
+CHECK_INCLUDE_FILE("execinfo.h" SCP_HAVE_EXECINFO_H)
+CHECK_INCLUDE_FILE_CXX("cxxabi.h" SCP_HAVE_CXXAPI_H)
 
 CHECK_TYPE_SIZE("max_align_t" MAX_ALIGN_T)
 
@@ -31,18 +31,18 @@ CHECK_TYPE_SIZE("U'b'" UNICODE_CHAR_LITERAL LANGUAGE CXX)
 set(CMAKE_REQUIRED_FLAGS)
 
 
-CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strncasecmp HAVE_STRNCASECMP)
+CHECK_FUNCTION_EXISTS(strcasecmp SCP_HAVE_STRCASECMP)
+CHECK_FUNCTION_EXISTS(strncasecmp SCP_HAVE_STRNCASECMP)
 
-CHECK_FUNCTION_EXISTS(_stricmp HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strnicmp HAVE__STRNICMP)
+CHECK_FUNCTION_EXISTS(_stricmp SCP_HAVE__STRICMP)
+CHECK_FUNCTION_EXISTS(_strnicmp SCP_HAVE__STRNICMP)
 
-CHECK_FUNCTION_EXISTS(strlwr HAVE_STRLWR)
+CHECK_FUNCTION_EXISTS(strlwr SCP_HAVE_STRLWR)
 
-CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)
+CHECK_INCLUDE_FILE("strings.h" SCP_HAVE_STRINGS_H)
 
-check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
-check_symbol_exists(_snprintf "stdio.h" HAVE__SNPRINTF)
+check_symbol_exists(snprintf "stdio.h" SCP_HAVE_SNPRINTF)
+check_symbol_exists(_snprintf "stdio.h" SCP_HAVE__SNPRINTF)
 
 set(PLATFORM_CHECK_HEADER "${GENERATED_SOURCE_DIR}/platformChecks.h")
 CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/platformChecks.h.in "${PLATFORM_CHECK_HEADER}")

cmake/platformChecks.h.in

@@ -3,29 +3,28 @@
 #define __PLATFORM_CHECKS_H__
 #pragma once
 
-#cmakedefine HAVE_EXECINFO_H
-#cmakedefine HAVE_CXXAPI_H
-#cmakedefine HAVE_MAX_ALIGN_T
-#cmakedefine HAVE_STD_MAX_ALIGN_T
+#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_STD_IS_TRIVIALLY_COPYABLE
-#cmakedefine HAVE_STD_IS_TRIVIALLY_COPYABLE_ARRAY
+#cmakedefine01 HAVE_STD_IS_TRIVIALLY_COPYABLE
 
 #cmakedefine01 IS_64BIT
 
-#cmakedefine01 HAVE_STRCASECMP
-#cmakedefine01 HAVE_STRNCASECMP
-#cmakedefine01 HAVE__STRICMP
-#cmakedefine01 HAVE__STRNICMP
+#cmakedefine01 SCP_HAVE_STRCASECMP
+#cmakedefine01 SCP_HAVE_STRNCASECMP
+#cmakedefine01 SCP_HAVE__STRICMP
+#cmakedefine01 SCP_HAVE__STRNICMP
 
-#cmakedefine01 HAVE_STRLWR
+#cmakedefine01 SCP_HAVE_STRLWR
 
-#cmakedefine01 HAVE_STRINGS_H
+#cmakedefine01 SCP_HAVE_STRINGS_H
 
 #cmakedefine01 HAVE_CHAR32_T
 #cmakedefine01 HAVE_UNICODE_CHAR_LITERAL
 
-#cmakedefine01 HAVE_SNPRINTF
-#cmakedefine01 HAVE__SNPRINTF
+#cmakedefine01 SCP_HAVE_SNPRINTF
+#cmakedefine01 SCP_HAVE__SNPRINTF
 
 #endif // __PLATFORM_CHECKS_H__

cmake/toolchain-apple-clang.cmake

@@ -9,8 +9,6 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -funroll-loops -fsigned-char -Wno-
 # Omit "conversion from string literal to 'char *' is deprecated" warnings.
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-write-strings")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-function")
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated -Wno-char-subscripts")
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")

cmake/toolchain-clang.cmake

@@ -7,6 +7,8 @@ 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")
@@ -19,6 +21,10 @@ if(DEFINED ENV{CFLAGS})
 	set(C_BASE_FLAGS $ENV{CFLAGS})
 endif()
 
+if (CLANG_USE_LIBCXX)
+	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -stdlib=libc++")
+endif()
+
 # Initialize with an empty string to make sure we always get a clean start
 set(COMPILER_FLAGS "")
 
@@ -66,8 +72,6 @@ set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
 
 set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
 
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-unused-function")
-
 # Dear Clang, please tell us if a function does not return a value since that part of the standard is stupid!
 set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
 
@@ -95,6 +99,10 @@ 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()

cmake/toolchain-gcc.cmake

@@ -78,8 +78,6 @@ set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
 
 set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
 
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-unused-function")
-
 # Dear GCC, please tell us if a function does not return a value since that part of the standard is stupid!
 set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
 

cmake/toolchain-msvc.cmake

@@ -37,21 +37,23 @@ 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 /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_C_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
+set(CMAKE_CXX_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
 
 set(CMAKE_EXE_LINKER_FLAGS "/MANIFEST /DYNAMICBASE:NO /SAFESEH:NO /ERRORREPORT:PROMPT /NOLOGO")
 set(CMAKE_STATIC_LINKER_FLAGS "")
 
 # Release
-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_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_STATIC_LINKER_FLAGS_RELEASE "/LTCG")
 
 globally_enable_extra_compiler_warnings()
@@ -63,8 +65,6 @@ 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)

cmake/version.cmake

@@ -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 3)
-set_if_not_defined(FSO_VERSION_MINOR 8)
-set_if_not_defined(FSO_VERSION_BUILD 1)
+set_if_not_defined(FSO_VERSION_MAJOR 20)
+set_if_not_defined(FSO_VERSION_MINOR 1)
+set_if_not_defined(FSO_VERSION_BUILD 0)
 
 # A numeric revision e.g. the CI build number
 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}")

code/CMakeLists.txt

@@ -28,7 +28,9 @@ TARGET_LINK_LIBRARIES(code PUBLIC ${JPEG_LIBS})
 
 TARGET_LINK_LIBRARIES(code PUBLIC sdl2)
 
-TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)
+if (FSO_BUILD_WITH_FFMPEG)
+	TARGET_LINK_LIBRARIES(code PUBLIC ffmpeg)
+endif()
 
 TARGET_LINK_LIBRARIES(code PUBLIC utfcpp)
 
@@ -41,6 +43,10 @@ target_link_libraries(code PUBLIC discord-rpc)
 
 target_link_libraries(code PUBLIC libRocket)
 
+target_link_libraries(code PUBLIC pcp)
+
+target_link_libraries(code PUBLIC vulkan-hpp)
+
 enable_clang_tidy(code)
 
 IF (FSO_USE_SPEECH)
@@ -77,6 +83,14 @@ else()
 	ENDIF()
 endif()
 
+if (FSO_RELEASE_LOGGING)
+	target_compile_definitions(code PUBLIC SCP_RELEASE_LOGGING)
+endif()
+
+if (FSO_BUILD_WITH_FFMPEG)
+	target_compile_definitions(code PUBLIC WITH_FFMPEG)
+endif()
+
 include(util)
 configure_cotire(code)
 

code/ai/ai.cpp

@@ -18,8 +18,7 @@
 #include "ship/ship.h"
 
 
-int Total_goal_target_names = 0;
-char Goal_target_names[MAX_GOAL_TARGET_NAMES][NAME_LENGTH];
+SCP_vector<char *> Goal_target_names;
 ai_info Ai_info[MAX_AI_INFO];
 ai_info *Player_ai;
 
@@ -82,22 +81,25 @@ void set_wingnum(int objnum, int wingnum)
 	Ai_info[ai_index].wing = wingnum;
 }
 
-char *ai_get_goal_target_name(const char *name, int *index)
+const char *ai_get_goal_target_name(const char *name, int *index)
 {
-	Assert(name != NULL);
-	Assert(index != NULL);
-	int i;
+	Assertion(name != nullptr && index != nullptr, "Arguments cannot be null!");
 
-	for (i=0; i < Total_goal_target_names; i++)
+	for (int i = 0; i < static_cast<int>(Goal_target_names.size()); ++i) {
 		if (!stricmp(name, Goal_target_names[i])) {
 			*index = i;
 			return Goal_target_names[i];
 		}
+	}
 
-	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];
+	*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();
 }

code/ai/ai.h

@@ -83,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
 
-	char	*target_name;		// name of the thing that this goal acts upon
+	const char *target_name;	// name of the thing that this goal acts upon
 	int		target_name_index;	// index of goal_target_name in Goal_target_names[][]
 	waypoint_list *wp_list;		// waypoints that this ship might fly.
 	int target_instance;		// instance of thing this ship might be chasing (currently only used for weapons; note, not the same as objnum!)
@@ -93,19 +93,17 @@ 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 {
-		char	*name;
+		const char *name;
 		int	index;
 	} docker;
 	
 	union {
-		char	*name;
+		const 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
@@ -513,8 +511,6 @@ 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);
@@ -556,7 +552,8 @@ void ai_process( object * obj, int ai_index, float frametime );
 int get_wingnum(int objnum);
 
 void set_wingnum(int objnum, int wingnum);
-char *ai_get_goal_target_name(const char *name, int *index);
+const char *ai_get_goal_target_name(const char *name, int *index);
+void ai_clear_goal_target_names();
 
 extern void init_ai_system(void);
 extern void ai_attack_object(object *attacker, object *attacked, ship_subsys *ssp, int ship_info_index = -1);
@@ -587,13 +584,10 @@ extern void get_absolute_wing_pos_autopilot( vec3d *result_pos, object *leader_o
 
 //	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);
-extern void ai_set_evade_object(object *objp, object *other_objp);
 extern void ai_set_guard_wing(object *objp, int wingnum);
 extern void ai_warp_out(object *objp, vec3d *vp);
 extern void ai_attack_wing(object *attacker, int wingnum);
 extern void ai_deathroll_start(object *ship_obj);
-extern void ai_fly_in_formation(int wing_num);		//	Force wing to fly in formation.
-extern void ai_disband_formation(int wing_num);		//	Force wing to disband formation flying.
 extern int set_target_objnum(ai_info *aip, int objnum);
 extern void ai_form_on_wing(object *objp, object *goal_objp);
 extern void ai_do_stay_near(object *objp, object *other_obj, float dist);
@@ -646,8 +640,6 @@ extern void ai_do_objects_repairing_stuff( object *repaired_obj, object *repair_
 //	Move to a position relative to a dock bay using thrusters.
 extern float dock_orient_and_approach(object *docker_objp, int docker_index, object *dockee_objp, int dockee_index, int dock_mode, rotating_dockpoint_info *rdinfo = NULL);
 
-extern int find_danger_weapon(object *sobjp, float dtime, float *atime, float dot_threshhold);
-
 void ai_set_mode_warp_out(object *objp, ai_info *aip);
 
 // prototyped by Goober5000

code/ai/ai_flags.h

@@ -51,14 +51,19 @@ namespace AI {
 	};
 
 	FLAG_LIST(Maneuver_Override_Flags) {
-		Full,		//	Full sexp control
+		Full_rot,	//	full sexp control over pitch/bank/heading rotation
 		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,			//	vertical movement
-		Sideways,	//	horizontal movement
-		Forward,	//	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
+		Never_expire,				// don't clear the maneuver when the timestamp is up
 
 		NUM_VALUES
 	};
@@ -79,13 +84,17 @@ 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,
@@ -110,6 +119,7 @@ namespace AI {
         Smart_shield_management,
         Smart_subsystem_targeting_for_turrets,
         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_additive_weapon_velocity,

code/ai/ai_profiles.cpp

@@ -7,11 +7,11 @@
 
 
 
-#include "globalincs/pstypes.h"
-#include "def_files/def_files.h"
 #include "ai/ai_profiles.h"
+#include "def_files/def_files.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"
@@ -371,10 +371,16 @@ 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);
@@ -391,6 +397,8 @@ 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);
@@ -435,6 +443,8 @@ void parse_ai_profiles_tbl(const char *filename)
 
 				set_flag(profile, "$ai guards specific ship in wing:", AI::Profile_Flags::Ai_guards_specific_ship_in_wing);
 
+				set_flag(profile, "$support don't add primaries:", AI::Profile_Flags::Support_dont_add_primaries);
+
 				profile->ai_path_mode = AI_PATH_MODE_NORMAL;
 				if (optional_string("$ai path mode:"))
 				{
@@ -515,10 +525,6 @@ 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()
@@ -626,4 +632,22 @@ 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);
+	}
+	// 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);
+	}
 }

code/ai/aicode.cpp

@@ -58,11 +58,15 @@
 #include "physics/physics.h"
 #include "playerman/player.h"
 #include "render/3d.h"
+#include "scripting/api/objs/waypoint.h"
+#include "scripting/api/objs/wing.h"
+#include "scripting/scripting.h"
 #include "ship/afterburner.h"
 #include "ship/awacs.h"
 #include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "ship/shiphit.h"
+#include "ship/subsysdamage.h"
 #include "weapon/beam.h"
 #include "weapon/flak.h"
 #include "weapon/swarm.h"
@@ -271,7 +275,7 @@ typedef struct {
 	int team;
 	int weapon_index;
 	int max_fire_count;
-	char	*shipname;
+	const char *shipname;
 } huge_fire_info;
 
 SCP_vector<huge_fire_info> Ai_huge_fire_info;
@@ -1312,7 +1316,9 @@ ship_subsys *set_targeted_subsys(ai_info *aip, ship_subsys *new_subsys, int pare
 		}
 
 		if ( aip == Player_ai ) {
-			hud_lock_reset(0.5f);
+			if (aip->last_subsys_target != aip->targeted_subsys) {
+				hud_lock_reset(0.5f);
+			}
 		}
 
 	} else {
@@ -1345,6 +1351,7 @@ void ai_object_init(object * obj, int ai_index)
 	aip->wing = -1;		//	Member of what wing? -1 means none.
 	aip->ai_class = Ship_info[Ships[obj->instance].ship_info_index].ai_class;
 	aip->behavior = AIM_NONE;
+	aip->mode = aip->behavior;
 }
 
 /**
@@ -4586,6 +4593,12 @@ void ai_waypoints()
 					ai_mission_wing_goal_complete( Ships[Pl_objp->instance].wingnum, &(aip->goals[aip->active_goal]) );
 					mission_log_add_entry( LOG_WAYPOINTS_DONE, Wings[Ships[Pl_objp->instance].wingnum].name, aip->wp_list->get_name(), -1 );
 				}
+				// adds scripting hook for 'On Waypoints Done' --wookieejedi
+				Script_system.SetHookObject("Ship", &Objects[Ships[Pl_objp->instance].objnum]);
+				Script_system.SetHookVar("Wing", 'o', scripting::api::l_Wing.Set(Ships[Pl_objp->instance].wingnum));
+				Script_system.SetHookVar("Waypointlist", 'o', scripting::api::l_WaypointList.Set(scripting::api::waypointlist_h(aip->wp_list)));
+				Script_system.RunCondition(CHA_ONWAYPOINTSDONE);
+				Script_system.RemHookVars(3, "Ship", "Wing", "Waypointlist");
 			}
 		}
 	}
@@ -4640,7 +4653,7 @@ void ai_fly_to_ship()
 		{
 			if (aip->mode == AIM_FLY_TO_SHIP || aip->goals[i].ai_mode == AI_GOAL_FLY_TO_SHIP)
 			{
-				mprintf(("Ship '%s' told to fly to target ship '%s'",
+				mprintf(("Ship '%s' told to fly to target ship '%s'\n",
 					Ships[Pl_objp->instance].ship_name,
 					aip->goals[i].target_name));
 			}
@@ -5214,7 +5227,7 @@ static int ai_select_primary_weapon_OLD(const object *objp, Weapon::Info_Flags f
 	ship	*shipp = &Ships[objp->instance];
 	ship_weapon *swp = &shipp->weapons;
 
-	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < static_cast<int>(Ship_info.size()));
+	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < ship_info_size());
 
 	if (flags == Weapon::Info_Flags::Puncture) {
 		if (swp->current_primary_bank >= 0) {
@@ -5303,16 +5316,14 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 		return ai_select_primary_weapon_OLD(objp, flags);
 	}
 
-	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < static_cast<int>(Ship_info.size()));
+	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < ship_info_size());
 	
 	//made it so it only selects puncture weapons if the active goal is to disable something -Bobboau
 	if ((flags == Weapon::Info_Flags::Puncture) && (Ai_info[shipp->ai_index].goals[0].ai_mode & (AI_GOAL_DISARM_SHIP | AI_GOAL_DISABLE_SHIP))) 
 	{
 		if (swp->current_primary_bank >= 0) 
 		{
-			int	bank_index;
-
-			bank_index = swp->current_primary_bank;
+			int	bank_index = swp->current_primary_bank;
 
 			if (Weapon_info[swp->primary_bank_weapons[bank_index]].wi_flags[Weapon::Info_Flags::Puncture]) 
 			{
@@ -5321,11 +5332,9 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 		}
 		for (int i=0; i<swp->num_primary_banks; i++) 
 		{
-			int	weapon_info_index;
+			int	weapon_info_index = swp->primary_bank_weapons[i];
 
-			weapon_info_index = swp->primary_bank_weapons[i];
-
-			if (weapon_info_index > -1)
+			if (weapon_info_index >= 0)
 			{
 				if (Weapon_info[weapon_info_index].wi_flags[Weapon::Info_Flags::Puncture]) 
 				{
@@ -5336,44 +5345,51 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 		}
 	}
 
-	if ( (other_objp->type == OBJ_SHIP) && (Ship_info[Ships[other_objp->instance].ship_info_index].is_big_or_huge() ) ) 
+	auto other_is_ship = (other_objp->type == OBJ_SHIP);
+	float enemy_remaining_shield = get_shield_pct(other_objp);
+
+	if ( other_is_ship && (Ship_info[Ships[other_objp->instance].ship_info_index].is_big_or_huge() ) )
 	{
 		//Check if we have a capital+ weapon on board
 		for (int i = 0; i < swp->num_primary_banks; i++)
 		{
-			if (swp->primary_bank_weapons[i] > -1)		// Make sure there is a weapon in the bank
+			if (swp->primary_bank_weapons[i] >= 0)		// Make sure there is a weapon in the bank
 			{
-				if (Weapon_info[swp->primary_bank_weapons[i]].wi_flags[Weapon::Info_Flags::Capital_plus])
+				auto wip = &Weapon_info[swp->primary_bank_weapons[i]];
+				if (wip->wi_flags[Weapon::Info_Flags::Capital_plus])
 				{
-					swp->current_primary_bank = i;
-					nprintf(("AI", "%i: Ship %s selecting weapon %s\n", Framecount, Ships[objp->instance].ship_name, Weapon_info[swp->primary_bank_weapons[i]].name));
-					return i;
+					// handle shielded big/huge ships (non FS-verse)
+					// only pick capital+ if the target has no shields; or the weapon is an ok shield-breaker anyway
+					if (enemy_remaining_shield <= 0.05f || (wip->shield_factor * 1.33f > wip->armor_factor))
+					{
+						swp->current_primary_bank = i;
+						nprintf(("AI", "%i: Ship %s selecting weapon %s (capital+) vs target %s\n", Framecount, Ships[objp->instance].ship_name, wip->name, Ships[other_objp->instance].ship_name));
+						return i;
+					}
 				}
 			}
 		}
 	}
 
-	float enemy_remaining_shield = get_shield_pct(other_objp);
-
 	// Is the target shielded by say only 5%?
 	if (enemy_remaining_shield <= 0.05f)	
 	{
 		// Then it is safe to start using a heavy hull damage weapon such as the maxim
-		int i;
 		float i_hullfactor_prev = 0;		// Previous weapon bank hull factor (this is the safe way to do it)
 		int i_hullfactor_prev_bank = -1;	// Bank which gave us this hull factor
 
 		// Find the weapon with the highest hull * damage / fire delay factor
-		for (i = 0; i < swp->num_primary_banks; i++)
+		for (int i = 0; i < swp->num_primary_banks; i++)
 		{
-			if (swp->primary_bank_weapons[i] > -1)		// Make sure there is a weapon in the bank
+			if (swp->primary_bank_weapons[i] >= 0)		// Make sure there is a weapon in the bank
 			{
-				if ((((Weapon_info[swp->primary_bank_weapons[i]].armor_factor) * (Weapon_info[swp->primary_bank_weapons[i]].damage)) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait) > i_hullfactor_prev)
+				auto wip = &Weapon_info[swp->primary_bank_weapons[i]];
+				if ((((wip->armor_factor) * (wip->damage)) / wip->fire_wait) > i_hullfactor_prev)
 				{
-					if ( !(Weapon_info[swp->primary_bank_weapons[i]].wi_flags[Weapon::Info_Flags::Capital_plus]) )
+					if ( !(wip->wi_flags[Weapon::Info_Flags::Capital_plus]) )
 					{
 						// This weapon is the new candidate
-						i_hullfactor_prev = ( ((Weapon_info[swp->primary_bank_weapons[i]].armor_factor) * (Weapon_info[swp->primary_bank_weapons[i]].damage)) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait );
+						i_hullfactor_prev = ( ((wip->armor_factor) * (wip->damage)) / wip->fire_wait );
 						i_hullfactor_prev_bank = i;
 					}
 				}
@@ -5384,6 +5400,7 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 			i_hullfactor_prev_bank = 0;		// Just switch to the first one
 		}
 		swp->current_primary_bank = i_hullfactor_prev_bank;		// Select the best weapon
+		nprintf(("AI", "%i: Ship %s selecting weapon %s (no shields) vs target %s\n", Framecount, shipp->ship_name, Weapon_info[swp->primary_bank_weapons[i_hullfactor_prev_bank]].name, (other_is_ship ? Ships[other_objp->instance].ship_name : "non-ship") ));
 		return i_hullfactor_prev_bank;							// Return
 	}
 
@@ -5392,26 +5409,23 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 	{
 		if (swp->current_primary_bank >= 0) 
 		{
-			int	bank_index;
+			auto wip = &Weapon_info[swp->primary_bank_weapons[swp->current_primary_bank]];
 
-			bank_index = swp->current_primary_bank;
-
-			if ((Weapon_info[swp->primary_bank_weapons[bank_index]].wi_flags[Weapon::Info_Flags::Pierce_shields]) && !(Weapon_info[swp->primary_bank_weapons[bank_index]].wi_flags[Weapon::Info_Flags::Capital_plus]))
+			if ((wip->wi_flags[Weapon::Info_Flags::Pierce_shields]) && !(wip->wi_flags[Weapon::Info_Flags::Capital_plus]))
 			{
+				nprintf(("AI", "%i: Ship %s selecting weapon %s (>10%% shields)\n", Framecount, shipp->ship_name, wip->name));
 				return swp->current_primary_bank;
 			}
 		}
 		for (int i=0; i<swp->num_primary_banks; i++) 
 		{
-			int	weapon_info_index;
-
-			weapon_info_index = swp->primary_bank_weapons[i];
-
-			if (weapon_info_index > -1)
+			if (swp->primary_bank_weapons[i] >= 0)
 			{
-				if ((Weapon_info[weapon_info_index].wi_flags[Weapon::Info_Flags::Pierce_shields]) && !(Weapon_info[swp->primary_bank_weapons[i]].wi_flags[Weapon::Info_Flags::Capital_plus])) 
+				auto wip = &Weapon_info[swp->primary_bank_weapons[i]];
+				if ((wip->wi_flags[Weapon::Info_Flags::Pierce_shields]) && !(wip->wi_flags[Weapon::Info_Flags::Capital_plus]))
 				{
 					swp->current_primary_bank = i;
+					nprintf(("AI", "%i: Ship %s selecting weapon %s (>10%% shields)\n", Framecount, shipp->ship_name, wip->name));
 					return i;
 				}
 			}
@@ -5421,61 +5435,63 @@ int ai_select_primary_weapon(object *objp, object *other_objp, Weapon::Info_Flag
 	// Is the target shielded by less then 50%?
 	if (enemy_remaining_shield <= 0.50f)	
 	{
-		// Should be using best balanced shield gun
-		int i;
-		float i_hullfactor_prev = 0;		// Previous weapon bank hull factor (this is the safe way to do it)
-		int i_hullfactor_prev_bank = -1;	// Bank which gave us this hull factor
+		// Should be using best balanced shield/hull gun
+		float i_balancedfactor_prev = 0;	// Previous weapon bank "balanced" factor (this is the safe way to do it)
+		int i_balancedfactor_prev_bank = -1;	// Bank which gave us this "balanced" factor
 		// Find the weapon with the highest average hull and shield * damage / fire delay factor
-		for (i = 0; i < swp->num_primary_banks; i++)
+		for (int i = 0; i < swp->num_primary_banks; i++)
 		{
-			if (swp->primary_bank_weapons[i] > -1)		// Make sure there is a weapon in the bank
+			if (swp->primary_bank_weapons[i] >= 0)		// Make sure there is a weapon in the bank
 			{
-				if ((((Weapon_info[swp->primary_bank_weapons[i]].armor_factor + Weapon_info[swp->primary_bank_weapons[i]].shield_factor) * Weapon_info[swp->primary_bank_weapons[i]].damage) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait) > i_hullfactor_prev)
+				auto wip = &Weapon_info[swp->primary_bank_weapons[i]];
+				if ((((wip->armor_factor + wip->shield_factor) * wip->damage) / wip->fire_wait) > i_balancedfactor_prev)
 				{
-					if ( !(Weapon_info[swp->primary_bank_weapons[i]].wi_flags[Weapon::Info_Flags::Capital_plus]) )
+					if ( !(wip->wi_flags[Weapon::Info_Flags::Capital_plus]) )
 					{
 						// This weapon is the new candidate
-						i_hullfactor_prev = ((((Weapon_info[swp->primary_bank_weapons[i]].armor_factor + Weapon_info[swp->primary_bank_weapons[i]].shield_factor) * Weapon_info[swp->primary_bank_weapons[i]].damage) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait));
-						i_hullfactor_prev_bank = i;
+						i_balancedfactor_prev = ((((wip->armor_factor + wip->shield_factor) * wip->damage) / wip->fire_wait));
+						i_balancedfactor_prev_bank = i;
 					}
 				}
 			}
 		}
-		if (i_hullfactor_prev_bank == -1)		// In the unlikely instance we don't find at least 1 candidate weapon
+		if (i_balancedfactor_prev_bank == -1)		// In the unlikely instance we don't find at least 1 candidate weapon
 		{
-			i_hullfactor_prev_bank = 0;		// Just switch to the first one
+			i_balancedfactor_prev_bank = 0;		// Just switch to the first one
 		}
-		swp->current_primary_bank = i_hullfactor_prev_bank;		// Select the best weapon
-		return i_hullfactor_prev_bank;							// Return
+		swp->current_primary_bank = i_balancedfactor_prev_bank;		// Select the best weapon
+		nprintf(("AI", "%i: Ship %s selecting weapon %s (<50%% shields)\n", Framecount, shipp->ship_name, Weapon_info[swp->primary_bank_weapons[i_balancedfactor_prev_bank]].name));
+		return i_balancedfactor_prev_bank;							// Return
 	}
 	else
 	{
 		// Should be using best shield destroying gun
-		int i;
-		float i_hullfactor_prev = 0;		// Previous weapon bank hull factor (this is the safe way to do it)
-		int i_hullfactor_prev_bank = -1;	// Bank which gave us this hull factor
+		float i_shieldfactor_prev = 0;		// Previous weapon bank shield factor (this is the safe way to do it)
+		int i_shieldfactor_prev_bank = -1;	// Bank which gave us this shield factor
 		// Find the weapon with the highest average hull and shield * damage / fire delay factor
-		for (i = 0; i < swp->num_primary_banks; i++)
+		for (int i = 0; i < swp->num_primary_banks; i++)
 		{
-			if (swp->primary_bank_weapons[i] > -1)		// Make sure there is a weapon in the bank
+			if (swp->primary_bank_weapons[i] >= 0)		// Make sure there is a weapon in the bank
 			{
-				if ((((Weapon_info[swp->primary_bank_weapons[i]].shield_factor) * Weapon_info[swp->primary_bank_weapons[i]].damage) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait) > i_hullfactor_prev)
+				auto wip = &Weapon_info[swp->primary_bank_weapons[i]];
+				if ((((wip->shield_factor) * wip->damage) / wip->fire_wait) > i_shieldfactor_prev)
 				{
-					if ( !(Weapon_info[swp->primary_bank_weapons[i]].wi_flags[Weapon::Info_Flags::Capital_plus]) )
+					if ( !(wip->wi_flags[Weapon::Info_Flags::Capital_plus]) )
 					{
 						// This weapon is the new candidate
-						i_hullfactor_prev = ( ((Weapon_info[swp->primary_bank_weapons[i]].shield_factor) * (Weapon_info[swp->primary_bank_weapons[i]].damage)) / Weapon_info[swp->primary_bank_weapons[i]].fire_wait );
-						i_hullfactor_prev_bank = i;
+						i_shieldfactor_prev = ( ((wip->shield_factor) * (wip->damage)) / wip->fire_wait );
+						i_shieldfactor_prev_bank = i;
 					}
 				}
 			}
 		}
-		if (i_hullfactor_prev_bank == -1)		// In the unlikely instance we don't find at least 1 candidate weapon
+		if (i_shieldfactor_prev_bank == -1)		// In the unlikely instance we don't find at least 1 candidate weapon
 		{
-			i_hullfactor_prev_bank = 0;		// Just switch to the first one
+			i_shieldfactor_prev_bank = 0;		// Just switch to the first one
 		}
-		swp->current_primary_bank = i_hullfactor_prev_bank;		// Select the best weapon
-		return i_hullfactor_prev_bank;							// Return
+		swp->current_primary_bank = i_shieldfactor_prev_bank;		// Select the best weapon
+		nprintf(("AI", "%i: Ship %s selecting weapon %s (>50%% shields)\n", Framecount, shipp->ship_name, Weapon_info[swp->primary_bank_weapons[i_shieldfactor_prev_bank]].name));
+		return i_shieldfactor_prev_bank;							// Return
 	}
 }
 
@@ -5491,31 +5507,35 @@ void set_primary_weapon_linkage(object *objp)
 	weapon_info *wip;
 
 	shipp = &Ships[objp->instance];
+
+	if (Num_weapons > (int) (MAX_WEAPONS * 0.75f)) {
+		if (shipp->flags[Ship::Ship_Flags::Primary_linked]) {
+			nprintf(("AI", "Frame %i, ship %s: Unlinking primaries.\n", Framecount, shipp->ship_name));
+			shipp->flags.remove(Ship::Ship_Flags::Primary_linked);
+		}
+		return;		//	If low on slots, don't link.
+	}
+
 	sip = &Ship_info[shipp->ship_info_index];
 	aip	= &Ai_info[shipp->ai_index];
 	swp = &shipp->weapons;
 
-    shipp->flags.remove(Ship::Ship_Flags::Primary_linked);
+	shipp->flags.remove(Ship::Ship_Flags::Primary_linked);
 
 	// AL: ensure target is a ship!
 	if ( (aip->target_objnum != -1) && (Objects[aip->target_objnum].type == OBJ_SHIP) ) {
 		// If trying to destroy a big ship (i.e., not disable/disarm), always unleash all weapons
 		if ( Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index].is_big_ship() ) {
-			if ( aip->targeted_subsys == NULL ) {
-                shipp->flags.set(Ship::Ship_Flags::Primary_linked);
-                shipp->flags.set(Ship::Ship_Flags::Secondary_dual_fire);
+			if ( aip->targeted_subsys == nullptr ) {
+				if (!sip->flags[Ship::Info_Flags::No_primary_linking] ) {
+					shipp->flags.set(Ship::Ship_Flags::Primary_linked);
+				}
+				shipp->flags.set(Ship::Ship_Flags::Secondary_dual_fire);
 				return;
 			}
 		}
 	}
 
-	if (Num_weapons > (int) (MAX_WEAPONS * 0.75f) || sip->flags[Ship::Info_Flags::No_primary_linking]) {
-		if (shipp->flags[Ship::Ship_Flags::Primary_linked])
-			nprintf(("AI", "Frame %i, ship %s: Unlinking primaries.\n", Framecount, shipp->ship_name));
-        shipp->flags.remove(Ship::Ship_Flags::Primary_linked);
-		return;		//	If low on slots or primary linking disallowed, don't link.
-	}
-
 	// AL 2-11-98: If ship has a disarm or disable goal, don't link unless both weapons are
 	//					puncture weapons
 	if ( (aip->active_goal != AI_GOAL_NONE) && (aip->active_goal != AI_ACTIVE_GOAL_DYNAMIC) )
@@ -5617,7 +5637,7 @@ int ai_fire_primary_weapon(object *objp)
 	ai_info		*aip;
 	object		*enemy_objp;
 
-	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < static_cast<int>(Ship_info.size()));
+	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < ship_info_size());
 
 	aip = &Ai_info[shipp->ai_index];
 
@@ -5655,7 +5675,16 @@ int ai_fire_primary_weapon(object *objp)
 	float	dot;
 	vec3d	v2t;
 
-	if ( !(vm_vec_mag_quick(&G_predicted_pos) < AICODE_SMALL_MAGNITUDE ) && !(aip->submode == SM_AVOID) ) {
+	bool condition;
+	if (The_mission.ai_profile->flags[AI::Profile_Flags::Fix_ramming_stationary_targets_bug]) {
+		// fixed by Mantis 3147 - Avoid bashing orientation if trying to avoid a collision.
+		condition = !(vm_vec_mag_quick(&G_predicted_pos) < AICODE_SMALL_MAGNITUDE) && (aip->submode != SM_AVOID);
+	} else {
+		// retail behavior
+		condition = !(vm_vec_mag_quick(&G_predicted_pos) < AICODE_SMALL_MAGNITUDE);
+	}
+
+	if ( condition ) {
 		if ( vm_vec_cmp(&G_predicted_pos, &G_fire_pos) ) {
 			vm_vec_normalized_dir(&v2t, &G_predicted_pos, &G_fire_pos);
 			dot = vm_vec_dot(&v2t, &objp->orient.vec.fvec);
@@ -6043,7 +6072,7 @@ int ai_fire_secondary_weapon(object *objp)
 	shipp = &Ships[objp->instance];
 	swp = &shipp->weapons;
 
-	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < static_cast<int>(Ship_info.size()));
+	Assert( shipp->ship_info_index >= 0 && shipp->ship_info_index < ship_info_size());
 
 	//	Select secondary weapon.
 	current_bank = swp->current_secondary_bank;
@@ -7478,32 +7507,6 @@ void ai_set_guard_wing(object *objp, int wingnum)
 	}
 }
 
-//	Make object *objp guard object *other_objp.
-//	To be called from the goals code.
-void ai_set_evade_object(object *objp, object *other_objp)
-{
-	ship		*shipp;
-	ai_info	*aip;
-	int		other_objnum;
-
-	Assert(objp->type == OBJ_SHIP);
-	Assert(objp->instance >= 0);
-
-	shipp = &Ships[objp->instance];
-
-	Assert(shipp->ai_index >= 0);
-
-	aip = &Ai_info[shipp->ai_index];
-
-	other_objnum = OBJ_INDEX(other_objp);
-	Assert(other_objnum >= 0);
-
-	Assert(other_objnum != Ships[aip->shipnum].objnum);	//	make sure not targeting self
-	aip->target_objnum = other_objnum;
-
-	aip->mode = AIM_EVADE;
-}
-
 //	Make objp guard other_objp
 //	If other_objp is a member of a wing, objp will guard that whole wing
 //	UNLESS objp is also a member of the wing!
@@ -8231,9 +8234,15 @@ void ai_chase()
 	if ((real_dot_to_enemy < 0.25f) || (aip->target_time < 1.0f)) {
 		predicted_enemy_pos = enemy_pos;
 	} else if (aip->ai_flags[AI::AI_Flags::Seek_lock]) {
-		set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, &aip->last_aim_enemy_pos, &aip->last_aim_enemy_vel, aip);	// Set G_fire_pos
-		predicted_enemy_pos = enemy_pos;
-		G_predicted_pos = predicted_enemy_pos;
+		if (The_mission.ai_profile->flags[AI::Profile_Flags::Fix_ramming_stationary_targets_bug]) {
+			// fixed by Mantis 3147 - Bash orientation if aspect seekers are equipped.
+			set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, &aip->last_aim_enemy_pos, &aip->last_aim_enemy_vel, aip);	// Set G_fire_pos
+			predicted_enemy_pos = enemy_pos;
+			G_predicted_pos = predicted_enemy_pos;
+		} else {
+			// retail behavior
+			predicted_enemy_pos = enemy_pos;
+		}
 	} else {
 		//	Set predicted_enemy_pos.
 		//	See if attacking a subsystem.
@@ -10692,7 +10701,7 @@ void ai_dock()
 			char *goal_dock_path_name = model_get(goal_sip->model_num)->paths[aip->mp_index].name;
 
 			mprintf(("Ship class %s has only %i points on dock path \"%s\".  Recommended minimum number of points is 4.  "\
-				"Docking along that path will look strange.  You may wish to edit the model.", goal_ship_class_name, aip->path_length, goal_dock_path_name));
+				"Docking along that path will look strange.  You may wish to edit the model.\n", goal_ship_class_name, aip->path_length, goal_dock_path_name));
 		}
 
 		aip->submode = AIS_DOCK_1;
@@ -11538,53 +11547,6 @@ void render_wing_phantoms_all()
 
 #endif
 
-//	Hook from goals code to AI.
-//	Force a wing to fly in formation.
-//	Sets AIF_FORMATION bit in ai_flags.
-//	wingnum		Wing to force to fly in formation
-void ai_fly_in_formation(int wingnum)
-{
-	object	*objp;
-	ship		*shipp;
-	ship_obj	*so;
-
-	for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
-		objp = &Objects[so->objnum];
-		Assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));
-
-		shipp = &Ships[objp->instance];
-		Assert((shipp->ai_index >= 0) && (shipp->ai_index < MAX_AI_INFO));
-
-		if (Ai_info[shipp->ai_index].wing == wingnum) {
-			Ai_info[shipp->ai_index].ai_flags.set(AI::AI_Flags::Formation_wing);
-			Ai_info[shipp->ai_index].ai_flags.remove(AI::AI_Flags::Formation_object);
-		}
-	}
-}
-
-//	Hook from goals code to AI.
-//	Force a wing to abandon formation flying.
-//	Clears AIF_FORMATION bit in ai_flags.
-//	wingnum		Wing to force to fly in formation
-void ai_disband_formation(int wingnum)
-{
-	object	*objp;
-	ship		*shipp;
-	ship_obj	*so;
-
-	for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
-		objp = &Objects[so->objnum];
-		Assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));
-
-		shipp = &Ships[objp->instance];
-		Assert((shipp->ai_index >= 0) && (shipp->ai_index < MAX_AI_INFO));
-
-		if (Ai_info[shipp->ai_index].wing == wingnum) {
-			Ai_info[shipp->ai_index].ai_flags.remove(AI::AI_Flags::Formation_wing);
-		}
-	}
-}
-
 float	Leader_chaos = 0.0f;
 int Chaos_frame = -1;
 
@@ -12606,13 +12568,13 @@ int ai_acquire_emerge_path(object *pl_objp, int parent_objnum, int allowed_path_
 	polymodel *pm = model_get( Ship_info[parent_shipp->ship_info_index].model_num );
 	ship_bay *bay = pm->ship_bay;
 
-	if ( bay == NULL ) {
-		WarningEx(LOCATION, "Ship %s was set to arrive from fighter bay on object %s, but no fighter bay exists on that ships' model (%s).\n", shipp->ship_name, parent_shipp->ship_name, pm->filename);
+	if ( bay == nullptr ) {
+		Warning(LOCATION, "Ship %s was set to arrive from fighter bay on object %s, but no fighter bay exists on that ships' model (%s).\n", shipp->ship_name, parent_shipp->ship_name, pm->filename);
 		return -1;
 	}
 
 	if ( bay->num_paths <= 0 ) {
-		WarningEx(LOCATION, "Ship %s was set to arrive from fighter bay on object %s, but no fighter bay paths exist on that ships' model (%s).\n", shipp->ship_name, parent_shipp->ship_name, pm->filename);
+		Warning(LOCATION, "Ship %s was set to arrive from fighter bay on object %s, but no fighter bay paths exist on that ships' model (%s).\n", shipp->ship_name, parent_shipp->ship_name, pm->filename);
 		return -1;
 	}
 
@@ -13359,7 +13321,7 @@ void ai_warp_out(object *objp)
 	case AIS_WARP_2:			//	Make sure won't collide with any object.
 		if (timestamp_elapsed(aip->force_warp_time)
 			|| (!collide_predict_large_ship(objp, objp->radius*2.0f + 100.0f)
-			|| (Ship_info[shipp->ship_info_index].warpout_type == WT_HYPERSPACE
+			|| (Warp_params[shipp->warpout_params_index].warp_type == WT_HYPERSPACE
 				&& !collide_predict_large_ship(objp, 100000.0f)))) {
 			aip->submode = AIS_WARP_3;
 			aip->submode_start_time = Missiontime;
@@ -13402,7 +13364,7 @@ void ai_warp_out(object *objp)
 		break;
 	case AIS_WARP_4: {
 		// Only lets the ship warp after waiting for the warpout engage time
-		if ( (Missiontime / 100) >= (aip->submode_start_time / 100 + Ship_info[shipp->ship_info_index].warpout_engage_time) ) {
+		if ( (Missiontime / 100) >= (aip->submode_start_time / 100 + Warp_params[shipp->warpout_params_index].warpout_engage_time) ) {
 			shipfx_warpout_start(objp);
 			aip->submode = AIS_WARP_5;
 			aip->submode_start_time = Missiontime;
@@ -14135,53 +14097,74 @@ void ai_frame(int objnum)
 	}
 }
 
-static void ai_control_info_check(ai_info *aip)
+static void ai_control_info_check(ai_info *aip, physics_info *pi)
 {
-	if(aip->ai_override_flags.none_set())
+	if (aip->ai_override_flags.none_set())
 		return;
 
-	if(timestamp_elapsed(aip->ai_override_timestamp)) {
+	if (!aip->ai_override_flags[AI::Maneuver_Override_Flags::Never_expire] && timestamp_elapsed(aip->ai_override_timestamp))
+	{
 		aip->ai_override_flags.reset();
-	} else {
-		if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Full])
+	}
+	else
+	{
+		if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Full_rot])
 		{
 			AI_ci.pitch = aip->ai_override_ci.pitch;
 			AI_ci.heading = aip->ai_override_ci.heading;
 			AI_ci.bank = aip->ai_override_ci.bank;
-		} else {
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Pitch])
+		}
+		else
+		{
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Pitch])
 			{
 				AI_ci.pitch = aip->ai_override_ci.pitch;
 			}
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Heading])
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Heading])
 			{
 				AI_ci.heading = aip->ai_override_ci.heading;
 			}
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Roll])
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Roll])
 			{
 				AI_ci.bank = aip->ai_override_ci.bank;
 			}
 		}
-		if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Full_lat])
+
+		if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Full_lat])
 		{
 			AI_ci.vertical = aip->ai_override_ci.vertical;
 			AI_ci.sideways = aip->ai_override_ci.sideways;
 			AI_ci.forward = aip->ai_override_ci.forward;
-		} else {
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Up])
+		}
+		else
+		{
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Up])
 			{
 				AI_ci.vertical = aip->ai_override_ci.vertical;
 			}
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Sideways])
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Sideways])
 			{
 				AI_ci.sideways = aip->ai_override_ci.sideways;
 			}
-			if(aip->ai_override_flags[AI::Maneuver_Override_Flags::Forward])
+			if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Forward])
 			{
 				AI_ci.forward = aip->ai_override_ci.forward;
 			}
 		}
+
+		if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Dont_bank_when_turning])
+			AI_ci.control_flags |= CIF_DONT_BANK_WHEN_TURNING;
+		if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Dont_clamp_max_velocity])
+			AI_ci.control_flags |= CIF_DONT_CLAMP_MAX_VELOCITY;
+		if (aip->ai_override_flags[AI::Maneuver_Override_Flags::Instantaneous_acceleration])
+			AI_ci.control_flags |= CIF_INSTANTANEOUS_ACCELERATION;
 	}
+
+	// set physics flag according to whether we are instantaneously accelerating
+	if (AI_ci.control_flags & CIF_INSTANTANEOUS_ACCELERATION)
+		pi->flags |= PF_NO_DAMP;
+	else
+		pi->flags &= ~PF_NO_DAMP;
 }
 
 int Last_ai_obj = -1;
@@ -14236,7 +14219,7 @@ void ai_process( object * obj, int ai_index, float frametime )
 
 	if (rfc == 1) {
 		// Wanderer - sexp based override goes here - only if rfc is valid though
-		ai_control_info_check(aip);
+		ai_control_info_check(aip, &obj->phys_info);
 		vec3d copy_desired_rotvel = obj->phys_info.rotvel;
 		physics_read_flying_controls( &obj->orient, &obj->phys_info, &AI_ci, frametime);
 		// if obj is in formation and not flight leader, don't update rotvel
@@ -14563,6 +14546,9 @@ void process_friendly_hit_message( int message, object *objp )
 	if (Ships[objp->instance].flags[Ship::Ship_Flags::No_builtin_messages]) {
 		index = -1;
 	}
+	if (The_mission.ai_profile->flags[AI::Profile_Flags::Check_comms_for_non_player_ships] && hud_communications_state(&Ships[objp->instance]) <= COMM_DAMAGED) {
+		index = -1;
+	}
 
 	// Karajorma - pick a random ship to send Command messages if command is silenced. 
 	if (index < 0 && (The_mission.flags[Mission::Mission_Flags::No_builtin_command]) ) {

code/ai/aigoals.cpp

@@ -21,6 +21,7 @@
 #include "object/waypoint.h"
 #include "parse/sexp.h"
 #include "playerman/player.h"
+#include "scripting/scripting.h"
 #include "ship/ship.h"
 #include "weapon/weapon.h"
 
@@ -62,31 +63,32 @@ char	Ai_dock_names[MAX_AI_DOCK_NAMES][NAME_LENGTH];
 // Used in objecttypes.tbl to define custom ship types
 ai_goal_list Ai_goal_names[] =
 {
-	{ "Attack ship",			AI_GOAL_CHASE,			0 },
-	{ "Dock",					AI_GOAL_DOCK,			0 },
-	{ "Waypoints",				AI_GOAL_WAYPOINTS,		0 },
-	{ "Waypoints once",			AI_GOAL_WAYPOINTS_ONCE,	0 },
-	{ "Depart",					AI_GOAL_WARP,			0 },
-	{ "Attack subsys",			AI_GOAL_DESTROY_SUBSYSTEM,	0 },
-	{ "Form on wing",			AI_GOAL_FORM_ON_WING,	0 },
-	{ "Undock",					AI_GOAL_UNDOCK,			0 },
-	{ "Attack wing",			AI_GOAL_CHASE_WING,		0 },
-	{ "Guard ship",				AI_GOAL_GUARD,			0 },
-	{ "Disable ship",			AI_GOAL_DISABLE_SHIP,	0 },
-	{ "Disarm ship",			AI_GOAL_DISARM_SHIP,	0 },
-	{ "Attack any",				AI_GOAL_CHASE_ANY,		0 },
-	{ "Ignore ship",			AI_GOAL_IGNORE,			0 },
-	{ "Ignore ship (new)",		AI_GOAL_IGNORE_NEW,		0 },
-	{ "Guard wing",				AI_GOAL_GUARD_WING,		0 },
-	{ "Evade ship",				AI_GOAL_EVADE_SHIP,		0 },
-	{ "Stay near ship",			AI_GOAL_STAY_NEAR_SHIP,	0 },
-	{ "keep safe dist",			AI_GOAL_KEEP_SAFE_DISTANCE,	0 },
-	{ "Rearm ship",				AI_GOAL_REARM_REPAIR,	0 },
-	{ "Stay still",				AI_GOAL_STAY_STILL,		0 },
-	{ "Play dead",				AI_GOAL_PLAY_DEAD,		0 },
-	{ "Attack weapon",			AI_GOAL_CHASE_WEAPON,	0 },
-	{ "Fly to ship",			AI_GOAL_FLY_TO_SHIP,	0 },
-	{ "Attack ship class",		AI_GOAL_CHASE_SHIP_CLASS, 0 },
+	{ "Attack ship",			AI_GOAL_CHASE,					0 },
+	{ "Dock",					AI_GOAL_DOCK,					0 },
+	{ "Waypoints",				AI_GOAL_WAYPOINTS,				0 },
+	{ "Waypoints once",			AI_GOAL_WAYPOINTS_ONCE,			0 },
+	{ "Depart",					AI_GOAL_WARP,					0 },
+	{ "Attack subsys",			AI_GOAL_DESTROY_SUBSYSTEM,		0 },
+	{ "Form on wing",			AI_GOAL_FORM_ON_WING,			0 },
+	{ "Undock",					AI_GOAL_UNDOCK,					0 },
+	{ "Attack wing",			AI_GOAL_CHASE_WING,				0 },
+	{ "Guard ship",				AI_GOAL_GUARD,					0 },
+	{ "Disable ship",			AI_GOAL_DISABLE_SHIP,			0 },
+	{ "Disarm ship",			AI_GOAL_DISARM_SHIP,			0 },
+	{ "Attack any",				AI_GOAL_CHASE_ANY,				0 },
+	{ "Ignore ship",			AI_GOAL_IGNORE,					0 },
+	{ "Ignore ship (new)",		AI_GOAL_IGNORE_NEW,				0 },
+	{ "Guard wing",				AI_GOAL_GUARD_WING,				0 },
+	{ "Evade ship",				AI_GOAL_EVADE_SHIP,				0 },
+	{ "Stay near ship",			AI_GOAL_STAY_NEAR_SHIP,			0 },
+	{ "keep safe dist",			AI_GOAL_KEEP_SAFE_DISTANCE,		0 },
+	{ "Rearm ship",				AI_GOAL_REARM_REPAIR,			0 },
+	{ "Stay still",				AI_GOAL_STAY_STILL,				0 },
+	{ "Play dead",				AI_GOAL_PLAY_DEAD,				0 },
+	{ "Play dead (persistent)",	AI_GOAL_PLAY_DEAD_PERSISTENT,	0 },
+	{ "Attack weapon",			AI_GOAL_CHASE_WEAPON,			0 },
+	{ "Fly to ship",			AI_GOAL_FLY_TO_SHIP,			0 },
+	{ "Attack ship class",		AI_GOAL_CHASE_SHIP_CLASS,		0 },
 };
 
 int Num_ai_goals = sizeof(Ai_goal_names) / sizeof(ai_goal_list);
@@ -267,6 +269,12 @@ 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(1, "Ship");
+
 }
 
 void ai_clear_wing_goals( int wingnum )
@@ -302,7 +310,7 @@ void ai_clear_wing_goals( int wingnum )
 void ai_mission_wing_goal_complete( int wingnum, ai_goal *remove_goalp )
 {
 	int mode, submode, priority, i;
-	char *name;
+	const char *name;
 	ai_goal *aigp;
 	wing *wingp;
 
@@ -380,7 +388,7 @@ void ai_goal_purge_invalid_goals( ai_goal *aigp, ai_goal *goal_list, ai_info *ai
 {
 	int i, j;
 	ai_goal *purge_goal;
-	char *name;
+	const char *name;
 	int mode, ship_index, wingnum;
 
 	// get locals for easer access
@@ -732,6 +740,12 @@ void ai_add_goal_sub_scripting(int type, int mode, int submode, int priority, ch
 		aigp->target_signature = Objects[Weapons[submode].objnum].signature;
 	}
 
+	if ( mode == AI_GOAL_WAYPOINTS_ONCE || mode == AI_GOAL_WAYPOINTS ) {
+		// should be the same as setting via sexp, see ai_add_goal_sub_sexp
+		// set to null so the AI code can setup the new waypoint list, see ai_mission_goal_achievable
+		aigp->wp_list = nullptr;
+	}
+
 	if ( target_name != NULL )
 		aigp->target_name = ai_get_goal_target_name( target_name, &aigp->target_name_index );
 	else
@@ -937,6 +951,11 @@ void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp, char *actor_name )
 		aigp->ai_mode = AI_GOAL_PLAY_DEAD;
 		break;
 
+	case OP_AI_PLAY_DEAD_PERSISTENT:
+		aigp->priority = atoi( CTEXT(CDR(node)) );
+		aigp->ai_mode = AI_GOAL_PLAY_DEAD_PERSISTENT;
+		break;
+
 	case OP_AI_KEEP_SAFE_DISTANCE:
 		aigp->priority = atoi( CTEXT(CDR(node)) );
 		aigp->ai_mode = AI_GOAL_KEEP_SAFE_DISTANCE;
@@ -1126,6 +1145,10 @@ int ai_remove_goal_sexp_sub( int sexp, ai_goal* aigp )
 		goalmode = AI_GOAL_PLAY_DEAD;
 		priority = ( CDR(node) >= 0 ) ? atoi( CTEXT( CDR( node ) ) ) : -1;
 		break;
+	case OP_AI_PLAY_DEAD_PERSISTENT:
+		goalmode = AI_GOAL_PLAY_DEAD_PERSISTENT;
+		priority = ( CDR(node) >= 0 ) ? atoi( CTEXT( CDR( node ) ) ) : -1;
+		break;
 	case OP_AI_KEEP_SAFE_DISTANCE:
 		priority = ( CDR(node) >= 0 ) ? atoi( CTEXT( CDR( node ) ) ) : -1;
 		goalmode = AI_GOAL_KEEP_SAFE_DISTANCE;
@@ -1340,25 +1363,6 @@ void ai_add_goal_ship_internal( ai_info *aip, int goal_type, char *name, int  /*
 		ai_process_mission_orders( Ships[aip->shipnum].objnum, aip );
 }
 
-// function to add an internal goal to a wing.  Mike K says that the goal doesn't need to persist
-// across waves of the wing so we merely need to add the goal to each ship in the wing.  Certain
-// goal are simply not valid for wings (like dock, undock).  Immediate parameter gets passed to add_ship_goal
-// to say whether or not we should process this goal right away
-void ai_add_goal_wing_internal( wing *wingp, int goal_type, char *name, int immediate )
-{
-	int i;
-
-	// be sure we are not trying to issue dock or undock goals to wings
-	Assert ( (goal_type != AI_GOAL_DOCK) && (goal_type != AI_GOAL_UNDOCK) );
-
-	for (i = 0; i < wingp->current_count; i++) {
-		int num = wingp->ship_index[i];
-		if ( num == -1 )			// ship must have been destroyed or departed
-			continue;
-		ai_add_goal_ship_internal(  &Ai_info[Ships[num].ai_index], goal_type, name, -1, -1, immediate);
-	}
-}
-
 // this function copies goals from a wing to an ai_info * from a ship.
 void ai_copy_mission_wing_goal( ai_goal *aigp, ai_info *aip )
 {
@@ -1372,7 +1376,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", Ships[aip->shipnum].ship_name));
+		mprintf(("Unable to assign wing goal to ship %s; the ship goals are already filled to capacity\n", Ships[aip->shipnum].ship_name));
 	}
 }
 
@@ -1401,7 +1405,7 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 	//  these orders are always achievable.
 	if ( (aigp->ai_mode == AI_GOAL_KEEP_SAFE_DISTANCE)
 		|| (aigp->ai_mode == AI_GOAL_CHASE_ANY) || (aigp->ai_mode == AI_GOAL_STAY_STILL)
-		|| (aigp->ai_mode == AI_GOAL_PLAY_DEAD) )
+		|| (aigp->ai_mode == AI_GOAL_PLAY_DEAD) || (aigp->ai_mode == AI_GOAL_PLAY_DEAD_PERSISTENT) )
 		return AI_GOAL_ACHIEVABLE;
 
 	// warp (depart) only achievable if there's somewhere to depart to
@@ -1409,21 +1413,17 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 	{
 		ship *shipp = &Ships[objp->instance];
 
-		// always valid if has subspace drive
-		if (!(shipp->flags[Ship::Ship_Flags::No_subspace_drive]))
+		// always valid if has working subspace drive, not disabled, and not limited by subsystem strength
+		if ( ship_can_warp_full_check(shipp) )
 			return AI_GOAL_ACHIEVABLE;
 
-		// 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;
+		// 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;
 		}
-
-		return AI_GOAL_NOT_KNOWN;
 	}
 
 
@@ -1502,7 +1502,8 @@ 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) {
-				status = mission_log_get_time( LOG_SHIP_SUBSYS_DESTROYED, aigp->target_name, ssp->system_info->subobj_name, 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;
 			} 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));
@@ -1512,12 +1513,36 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 		}
 
 		case AI_GOAL_DISABLE_SHIP:
-			status = mission_log_get_time( LOG_SHIP_DISABLED, aigp->target_name, NULL, NULL );
+		{
+			// 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;
+			}
 			break;
+		}
 
 		case AI_GOAL_DISARM_SHIP:
-			status = mission_log_get_time( LOG_SHIP_DISARMED, aigp->target_name, NULL, NULL );
+		{
+			// 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;
+			}
 			break;
+		}
 
 		// to guard or ignore a ship, the goal cannot continue if the ship being guarded is either destroyed
 		// or has departed.
@@ -1629,7 +1654,7 @@ int ai_mission_goal_achievable( int objnum, ai_goal *aigp )
 			status = SHIP_STATUS_ARRIVED;
 		}
 		// goal ship is still on the arrival list
-		else if ( mission_parse_get_arrival_ship(aigp->target_name) )
+		else if ( mission_check_ship_yet_to_arrive(aigp->target_name) )
 		{
 			status = SHIP_STATUS_NOT_ARRIVED;
 		}
@@ -1895,9 +1920,12 @@ int ai_goal_priority_compare(const void *a, const void *b)
 	// check whether or not the goal override flag is set.  If it is set, then push this goal higher
 	// in the list
 
-	else if ( (ga->flags[AI::Goal_Flags::Goal_override]) && !(gb->flags[AI::Goal_Flags::Goal_override]) )
+	// Goober5000: the ONLY goals we do not override are play-dead and play-dead-persistent,
+	// because the override flag needs to work in any other situation
+
+	else if ( (ga->flags[AI::Goal_Flags::Goal_override]) && !(gb->flags[AI::Goal_Flags::Goal_override]) && !(gb->ai_mode == AI_GOAL_PLAY_DEAD) && !(gb->ai_mode == AI_GOAL_PLAY_DEAD_PERSISTENT) )
 		return -1;
-	else if ( !(ga->flags[AI::Goal_Flags::Goal_override]) && (gb->flags[AI::Goal_Flags::Goal_override]) )
+	else if ( !(ga->flags[AI::Goal_Flags::Goal_override]) && (gb->flags[AI::Goal_Flags::Goal_override]) && !(ga->ai_mode == AI_GOAL_PLAY_DEAD) && !(ga->ai_mode == AI_GOAL_PLAY_DEAD_PERSISTENT))
 		return 1;
 
 	// now normal priority processing
@@ -2290,6 +2318,13 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		aip->submode_start_time = Missiontime;
 		break;
 
+	case AI_GOAL_PLAY_DEAD_PERSISTENT:
+		// same as above, but we don't clear out ship goals
+		aip->mode = AIM_PLAY_DEAD;
+		aip->submode = -1;
+		aip->submode_start_time = Missiontime;
+		break;
+
 	case AI_GOAL_FORM_ON_WING:
 		// for form on wing, we need to clear out all goals for this ship, and then call the form
 		// on wing AI code

code/ai/aigoals.h

@@ -58,16 +58,17 @@ struct ai_goal;
 #define AI_GOAL_FLY_TO_SHIP				(1<<23) // 0x00800000
 #define AI_GOAL_IGNORE_NEW				(1<<24)	// 0x01000000
 #define AI_GOAL_CHASE_SHIP_CLASS		(1<<25)	// 0x02000000
+#define AI_GOAL_PLAY_DEAD_PERSISTENT	(1<<26)	// 0x03000000
 
 // now the masks for ship types
 
 // Goober5000: added AI_GOAL_STAY_NEAR_SHIP and AI_GOAL_KEEP_SAFE_DISTANCE as valid for fighters
 //WMC - Don't need these anymore. Whee!
 /*
-#define AI_GOAL_ACCEPT_FIGHTER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_DESTROY_SUBSYSTEM | AI_GOAL_CHASE_WING | AI_GOAL_GUARD | AI_GOAL_DISABLE_SHIP | AI_GOAL_DISARM_SHIP | AI_GOAL_CHASE_ANY | AI_GOAL_IGNORE | AI_GOAL_IGNORE_NEW | AI_GOAL_GUARD_WING | AI_GOAL_EVADE_SHIP | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE )
+#define AI_GOAL_ACCEPT_FIGHTER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_DESTROY_SUBSYSTEM | AI_GOAL_CHASE_WING | AI_GOAL_GUARD | AI_GOAL_DISABLE_SHIP | AI_GOAL_DISARM_SHIP | AI_GOAL_CHASE_ANY | AI_GOAL_IGNORE | AI_GOAL_IGNORE_NEW | AI_GOAL_GUARD_WING | AI_GOAL_EVADE_SHIP | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE )
 #define AI_GOAL_ACCEPT_BOMBER			( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FIGHTER | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_STEALTH		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FIGHTER | AI_GOAL_STAY_NEAR_SHIP )
-#define AI_GOAL_ACCEPT_TRANSPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_CHASE_WING | AI_GOAL_DOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_UNDOCK | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD| AI_GOAL_STAY_NEAR_SHIP )
+#define AI_GOAL_ACCEPT_TRANSPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_CHASE | AI_GOAL_CHASE_WING | AI_GOAL_DOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_WARP | AI_GOAL_UNDOCK | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_FREIGHTER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_TRANSPORT | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_CRUISER		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_FREIGHTER | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_CORVETTE		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER | AI_GOAL_STAY_NEAR_SHIP )
@@ -75,7 +76,7 @@ struct ai_goal;
 #define AI_GOAL_ACCEPT_AWACS			( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_CAPITAL		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CRUISER & ~(AI_GOAL_DOCK | AI_GOAL_UNDOCK) | AI_GOAL_STAY_NEAR_SHIP )
 #define AI_GOAL_ACCEPT_SUPERCAP		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_CAPITAL | AI_GOAL_STAY_NEAR_SHIP )
-#define AI_GOAL_ACCEPT_SUPPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_DOCK | AI_GOAL_UNDOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD)
+#define AI_GOAL_ACCEPT_SUPPORT		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_DOCK | AI_GOAL_UNDOCK | AI_GOAL_WAYPOINTS | AI_GOAL_WAYPOINTS_ONCE | AI_GOAL_STAY_NEAR_SHIP | AI_GOAL_KEEP_SAFE_DISTANCE | AI_GOAL_STAY_STILL | AI_GOAL_PLAY_DEAD | AI_GOAL_PLAY_DEAD_PERSISTENT )
 #define AI_GOAL_ACCEPT_ESCAPEPOD		( AI_GOAL_FLY_TO_SHIP | AI_GOAL_ACCEPT_TRANSPORT| AI_GOAL_STAY_NEAR_SHIP  )
 */
 
@@ -102,7 +103,7 @@ extern int ai_goal_num(ai_goal *goals);
 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, int wingnum );
-extern void ai_add_goal_sub_sexp( int sexp, int type, ai_goal *aigp );
+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, int wingnum);
@@ -127,6 +128,5 @@ extern char *ai_add_dock_name(const char *str);
 extern int ai_query_goal_valid( int ship, int ai_goal_type );
 
 extern void ai_add_goal_ship_internal( ai_info *aip, int goal_type, char *name, int docker_point, int dockee_point, int immediate = 1 );
-extern void ai_add_goal_wing_internal( wing *wingp, int goal_type, char *name, int immediate = 1 );
 
 #endif

code/ai/aiturret.cpp

@@ -856,11 +856,11 @@ int get_nearest_turret_objnum(int turret_parent_objnum, ship_subsys *turret_subs
 	// flags for weapon types
 	if (beam_flag)
 		eeo.eeo_flags |= EEOF_BEAM;
-	else if (flak_flag)
+	if (flak_flag)
 		eeo.eeo_flags |= EEOF_FLAK;
-	else if (laser_flag)
+	if (laser_flag)
 		eeo.eeo_flags |= EEOF_LASER;
-	else if (missile_flag)
+	if (missile_flag)
 		eeo.eeo_flags |= EEOF_MISSILE;
 
 	eeo.enemy_team_mask = enemy_team_mask;
@@ -1290,7 +1290,9 @@ void ship_get_global_turret_gun_info(object *objp, ship_subsys *ssp, vec3d *gpos
 		model_instance_find_world_point(&tmp_pos, &avg, Ships[objp->instance].model_instance_num, tp->turret_gun_sobj, &objp->orient, &objp->pos);
 
 		if (targetp == nullptr) {
-            Assertion(ssp->turret_enemy_objnum >= 0, "The turret enemy object number %d for %s on ship number %d is invalid.", ssp->turret_enemy_objnum, ssp->sub_name, ssp->parent_objnum);
+			ship* shipp = &Ships[Objects[ssp->parent_objnum].instance];
+            Assertion(ssp->turret_enemy_objnum >= 0, "The turret enemy object number %d for %s on ship name %s is invalid.", ssp->turret_enemy_objnum, ssp->sub_name, 
+																								(shipp->has_display_name()) ? shipp->display_name.c_str() : shipp->ship_name);
             object *lep = &Objects[ssp->turret_enemy_objnum];
 
 			int best_weapon_tidx = turret_select_best_weapon(ssp, lep);
@@ -1301,9 +1303,9 @@ void ship_get_global_turret_gun_info(object *objp, ship_subsys *ssp, vec3d *gpos
 
 			weapon_info *wip = get_turret_weapon_wip(&ssp->weapons, best_weapon_tidx);
 
-			float weapon_system_strength = ship_get_subsystem_strength(&Ships[ssp->parent_objnum], SUBSYSTEM_WEAPONS);
+			float weapon_system_strength = ship_get_subsystem_strength(shipp, SUBSYSTEM_WEAPONS);
 
-            turret_ai_update_aim(&Ai_info[Ships[ssp->parent_objnum].ai_index], &Objects[ssp->turret_enemy_objnum], ssp);
+            turret_ai_update_aim(&Ai_info[shipp->ai_index], &Objects[ssp->turret_enemy_objnum], ssp);
 
 			if ((ssp->targeted_subsys != nullptr) && !(ssp->flags[Ship::Subsystem_Flags::No_SS_targeting])) {
 				vm_vec_unrotate(&enemy_point, &ssp->targeted_subsys->system_info->pnt, &Objects[ssp->turret_enemy_objnum].orient);
@@ -1676,7 +1678,12 @@ void turret_set_next_fire_timestamp(int weapon_num, weapon_info *wip, ship_subsy
 		wait *= wip->burst_delay;
 		turret->weapons.burst_counter[weapon_num]++;
 	} else {
-		wait *= wip->fire_wait;
+		// Random fire delay (DahBlount) used in ship_fire_primary(), added here by wookieejedi to correct oversight
+		if (wip->max_delay != 0.0f && wip->min_delay != 0.0f) {
+			wait *= frand_range(wip->min_delay, wip->max_delay);
+		} else {
+			wait *= wip->fire_wait;
+		}
 		if ((wip->burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Random_length])) {
 			turret->weapons.burst_counter[weapon_num] = (myrand() % wip->burst_shots);
 		} else {
@@ -1805,7 +1812,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 	parent_aip = &Ai_info[Ships[Objects[parent_objnum].instance].ai_index];
 	parent_ship = &Ships[Objects[parent_objnum].instance];
 	wip = get_turret_weapon_wip(&turret->weapons, weapon_num);
-	int turret_weapon_class = WEAPON_INFO_INDEX(wip);
+	int turret_weapon_class = weapon_info_get_index(wip);
 
 #ifndef NDEBUG
 	// moved here from check_ok_to_fire
@@ -2537,7 +2544,6 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 	// Ok, the turret is lined up... now line up a particular gun.
 	bool ok_to_fire = false;
 	bool something_was_ok_to_fire=false;
-	vec3d tv2e;	//so flak can get their jitter without screwing up other guns
 
 	if (in_fov ) {
 
@@ -2574,7 +2580,9 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 				ss->turret_next_fire_pos = ffp_pos;
 			}
 
-            ship_get_global_turret_gun_info(&Objects[parent_objnum], ss, &gpos, &gvec, use_angles, &predicted_enemy_pos);
+			// We're ready to fire... now get down to specifics, like where is the
+			// actual gun point and normal, not just the one for whole turret.
+			ship_get_global_turret_gun_info(&Objects[parent_objnum], ss, &gpos, &gvec, use_angles, &predicted_enemy_pos);
 
 			// Fire in the direction the turret is facing, not right at the target regardless of turret dir.
 			vm_vec_sub(&v2e, &predicted_enemy_pos, &gpos);
@@ -2585,12 +2593,6 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 				wip = get_turret_weapon_wip(&ss->weapons, valid_weapons[0]);
 			else
 				wip = get_turret_weapon_wip(&ss->weapons, valid_weapons[i]);
-
-			// We're ready to fire... now get down to specifics, like where is the
-			// actual gun point and normal, not just the one for whole turret.
-			// moved here as if there are two weapons with indentical fire stamps
-			// they would have shared the fire point.
-			tv2e = gvec;
 	
 			// make sure to reset this for current weapon
 			ok_to_fire = false;
@@ -2598,7 +2600,7 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 			// if the weapon is a flak gun, add some jitter to its aim so it fires in a "cone" 
 			// to make a cool visual effect and make them less lethal
 			if(wip->wi_flags[Weapon::Info_Flags::Flak]){
-				flak_jitter_aim(&tv2e, dist_to_enemy, ship_get_subsystem_strength(shipp, SUBSYSTEM_WEAPONS), wip);
+				flak_jitter_aim(&v2e, dist_to_enemy, ship_get_subsystem_strength(shipp, SUBSYSTEM_WEAPONS), wip);
 			}
 			
 			// Fire if:
@@ -2709,9 +2711,9 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 
 				//Pass along which gun we are using
 				if (tp->flags[Model::Subsystem_Flags::Turret_salvo])
-					turret_fire_weapon(valid_weapons[0], ss, parent_objnum, &gpos, &tv2e, &predicted_enemy_pos);
+					turret_fire_weapon(valid_weapons[0], ss, parent_objnum, &gpos, &v2e, &predicted_enemy_pos);
 				else
-					turret_fire_weapon(valid_weapons[i], ss, parent_objnum, &gpos, &tv2e, &predicted_enemy_pos);
+					turret_fire_weapon(valid_weapons[i], ss, parent_objnum, &gpos, &v2e, &predicted_enemy_pos);
 			} else {
 				// make sure salvo fire mode does not turn into autofire
 				if ((tp->flags[Model::Subsystem_Flags::Turret_salvo]) && ((i + 1) == number_of_firings)) {
@@ -2724,8 +2726,6 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss, int parent_objnum)
 
 		if(!something_was_ok_to_fire)
 		{
-			mprintf(("nothing ok to fire\n"));
-            
 			if (ss->turret_best_weapon >= 0) {
 				//Impose a penalty on turret accuracy for losing site of its goal, or just not being able to fire.
 				turret_update_enemy_in_range(ss, -4*Weapon_info[ss->turret_best_weapon].fire_wait);

code/anim/animplay.cpp

@@ -519,19 +519,6 @@ int anim_show_next_frame(anim_instance *instance, float frametime)
 	return 0;
 }
 
-/**
- * @brief Stop an anim instance that is on the anim_render_list from playing
- */
-int anim_stop_playing(anim_instance* instance)
-{
-	Assert(instance != NULL);
-
-	if ( anim_playing(instance) ) {
-		anim_release_render_instance(instance);
-	}
-	return 0;
-}
-
 /**
  * @brief Free a particular animation instance that is on the anim_render_list.  
  * Do not call this function to free an animation instance in general (use 
@@ -866,20 +853,6 @@ int anim_free(anim *ptr)
 	return 0;
 }
 
-
-/**
- * @brief Return if an anim is playing or not.  
- */
-int anim_playing(anim_instance *ai)
-{
-	Assert(ai != NULL);
-	if ( ai->frame == NULL )
-		return 0;
-	else 
-		return 1;
-}
-
-
 /**
  * @brief Called at the beginning of a mission to initialize any mission dependent anim data.
  * @todo Redundant?
@@ -896,138 +869,6 @@ void anim_level_close()
 	anim_release_all_instances();
 }
 
-/**
- * @brief Write the frames of a .ani file out to disk as .pcx files.
- * @details Use naming convention: filename0000.pcx, filename0001.pcx etc.
- *
- * @return If success 0, or if failed -1
- */
-int anim_write_frames_out(char *filename)
-{
-	anim				*source_anim;
-	anim_instance	*ai;
-	char				root_name[256], pcxname[256];
-	char				buf[64];
-	int				i,j;
-	ubyte				**row_data;
-
-	strcpy_s(root_name, filename);
-	root_name[strlen(filename)-4] = 0;
-
-	source_anim = anim_load(filename);
-	if ( source_anim == NULL ) 
-		return -1;
-
-	ai = init_anim_instance(source_anim, 16);
-
-	row_data = (ubyte**)vm_malloc((source_anim->height+1) * 4);
-
-	for ( i = 0; i < source_anim->total_frames; i++ ) {
-		anim_get_next_raw_buffer(ai, 0, 0, 16);
-		strcpy_s(pcxname, root_name);
-		sprintf(buf,"%04d",i);
-		strcat_s(pcxname, buf);
-
-		for ( j = 0; j < source_anim->height; j++ ) {
-			row_data[j] = &ai->frame[j*source_anim->width];
-		}
-
-
-		pcx_write_bitmap( pcxname,
-								source_anim->width,
-								source_anim->height,
-								row_data,
-								source_anim->palette);
-
-		printf(".");
-
-	}
-	printf("\n");
-	vm_free(row_data);
-	return 0;
-}
-
-/**
- * @brief Display information and statistics about a .ani file.
- * @details This is called when -i switch is on when running ac.exe
- */
-void anim_display_info(char *real_filename)
-{
-	CFILE				*fp;
-	anim				A;
-	float				percent;
-	int				i, uncompressed, compressed, *key_frame_nums=NULL, tmp;
-	char filename[MAX_FILENAME_LEN];
-
-	strcpy_s( filename, real_filename );
-	char *p = strchr( filename, '.' );
-	if ( p ) {
-		*p = 0;
-	}
-	strcat_s( filename, ".ani" );
-
-	fp = cfopen(filename, "rb");
-	if ( !fp ) {
-		printf("Fatal error opening %s", filename);
-		return;
-	}
-
-	anim_read_header(&A, fp);
-
-	if (A.width < 0 || A.height < 0) {
-		Error(LOCATION, "Ani file %s has a faulty header and cannot be loaded.", filename);
-	}
-
-	// read the keyframe frame nums and offsets
-	key_frame_nums = (int*)vm_malloc(sizeof(int)*A.num_keys);
-	Assert(key_frame_nums != NULL);
-	if (key_frame_nums == NULL)
-		return;
-
-	for ( i = 0; i < A.num_keys; i++ ) {
-		key_frame_nums[i] = 0;
-		cfread(&key_frame_nums[i], 2, 1, fp);
-		cfread(&tmp, 4, 1, fp);
-	}
-
-	cfread(&compressed, 4, 1, fp);
-
-	uncompressed = A.width * A.height * A.total_frames;	// 8 bits per pixel
-	percent = i2fl(compressed) / uncompressed * 100.0f;
-
-	printf("%% of uncompressed size:    %.0f%%\n", percent);
-	printf("Width:                     %d\n", A.width);
-	printf("Height:                    %d\n", A.height);
-	printf("Total Frames:              %d\n", A.total_frames);
-
-#ifndef NDEBUG
-	printf("Key Frames:                %d\n", A.num_keys);
-	if ( A.num_keys > 1 && (A.total_frames != A.num_keys) ) {
-		printf("key list: (");
-		for ( i = 0; i < A.num_keys; i++ ) {
-			if ( i < A.num_keys-1 ) 
-				printf("%d, ", key_frame_nums[i]);
-			else
-				printf("%d)\n", key_frame_nums[i]);
-		}
-	}
-#endif
-
-	printf("FPS:                       %d\n", A.fps);
-
-#ifndef NDEBUG
-	printf("Transparent RGB:           (%u,%u,%u)\n", A.xparent_r, A.xparent_g, A.xparent_b); 
-#endif
-
-	printf("ac version:                %d\n", A.version);
-
-	if ( key_frame_nums != NULL ) {
-		vm_free(key_frame_nums);
-	}
-
-	cfclose(fp);
-}
-
 void anim_reverse_direction(anim_instance *ai)
 {
 	int temp;
@@ -1061,16 +902,6 @@ void anim_reverse_direction(anim_instance *ai)
 	}	
 }
 
-void anim_pause(anim_instance *ai)
-{
-	ai->paused = 1;
-}
-
-void anim_unpause(anim_instance *ai)
-{
-	ai->paused = 0;
-}
-
 void anim_ignore_next_frametime()
 {
 	Anim_ignore_frametime=1;

code/anim/animplay.h

@@ -54,19 +54,13 @@ void				anim_render_one(int screen_id, anim_instance *ani, float frametime);
 void				anim_play_init(anim_play_struct *aps, anim *a_info, int x, int y, int max_x = -1, int max_y = -1);
 anim_instance *anim_play(anim_play_struct *aps);
 void				anim_ignore_next_frametime();
-int				anim_stop_playing(anim_instance* anim_instance);
 int				anim_show_next_frame(anim_instance *instance, float frametime);
 void				anim_release_all_instances(int screen_id = 0);
 void				anim_release_render_instance(anim_instance* instance);
 anim			  *anim_load(const char *name, int cf_dir_type = CF_TYPE_ANY, int file_mapped = PAGE_FROM_DISK);
 int				anim_free(anim *ptr);
-int				anim_playing(anim_instance *ai);
-int				anim_write_frames_out(char *filename);
-void				anim_display_info(char *filename);
 void				anim_read_header(anim *ptr, CFILE *fp);
 void				anim_reverse_direction(anim_instance *ai);						// called automatically for ping-ponging, and can also be called externally
-void				anim_pause(anim_instance *ai);
-void				anim_unpause(anim_instance *ai);
 
 int	anim_instance_is_streamed(anim_instance *ai);
 unsigned char anim_instance_get_byte(anim_instance *ai, int offset);

code/anim/packunpack.cpp

@@ -78,52 +78,6 @@ void free_anim_instance(anim_instance *inst)
 	vm_free(inst);	
 }
 
-int anim_get_next_frame(anim_instance *inst)
-{
-	int bm, bitmap_flags;
-	int aabitmap = 0;
-	int bpp = 16;
-
-	if ( anim_instance_is_streamed(inst) ) {
-		if ( inst->file_offset <= 0 ) {
-			return -1;
-		}
-	} else {
-		if (!inst->data)
-			return -1;
-	}
-
-	inst->frame_num++;
-	if (inst->frame_num >= inst->parent->total_frames) {
-		inst->data = NULL;
-		inst->file_offset = inst->parent->file_offset;
-		return -1;
-	}
-
-	bitmap_flags = 0;
-
-	bpp = 16;
-	if(inst->aa_color != NULL){
-		bitmap_flags |= BMP_AABITMAP;
-		aabitmap = 1;
-		bpp = 8;
-	}
-
-	anim_check_for_palette_change(inst);
-
-	BM_SELECT_TEX_FORMAT();
-
-	if ( anim_instance_is_streamed(inst) ) {
-		inst->file_offset = unpack_frame_from_file(inst, inst->frame, inst->parent->width*inst->parent->height, inst->parent->palette_translation, aabitmap, bpp);
-	} else {
-		inst->data = unpack_frame(inst, inst->data, inst->frame, inst->parent->width*inst->parent->height, inst->parent->palette_translation, aabitmap, bpp);
-	}
-
-	bm = bm_create(bpp, inst->parent->width, inst->parent->height, inst->frame, bitmap_flags);
-	bm_unload(bm);
-	return bm;
-}
-
 ubyte *anim_get_next_raw_buffer(anim_instance *inst, int xlate_pal, int aabitmap, int bpp)
 {	
 	if ( anim_instance_is_streamed(inst) ) {
@@ -162,321 +116,6 @@ ubyte *anim_get_next_raw_buffer(anim_instance *inst, int xlate_pal, int aabitmap
 	return inst->frame;
 }
 
-/**
- * @brief Pack key frame
- *
- * @param frame Frame pixel data to pack
- * @param save Memory to store packed data to
- * @param size Number of bytes to pack
- * @param max Maximum number of packed bytes (size of buffer)
- * @param compress_type Compress type
- * @return Actual number of bytes data packed to or -1 if error
- */
-int pack_key_frame(ubyte *frame, ubyte *save, long size, long max, int compress_type)
-{
-	int last = -32768, count = 0;
-	long packed_size = 1;
-
-	switch ( compress_type ) {
-		case PACKING_METHOD_RLE_KEY:
-			*save++ = PACKING_METHOD_RLE_KEY;
-			while (size--) {
-				if (*frame != last || count > 255) {
-					if (packed_size + 3 >= max)
-						return -1;
-
-					if (count < 3) {
-						if (last == packer_code) {
-							*save++ = (ubyte)packer_code;
-							*save++ = (ubyte)(count - 1);
-							packed_size += 2;
-
-						} else
-							while (count--) {
-								*save++ = (ubyte)last;
-								packed_size++;
-							}
-
-					} else {
-						*save++ = (ubyte)packer_code;
-						*save++ = (ubyte)(count - 1);
-						*save++ = (ubyte)last;
-						packed_size += 3;
-					}
-
-					count = 0;
-					last = *frame;
-				}
-
-				count++;
-				frame++;
-			}
-
-			if (packed_size + 3 >= max)
-				return -1;
-
-			if (count < 3) {
-				if (last == packer_code) {
-					*save++ = (ubyte)packer_code;
-					*save++ = (ubyte)(count - 1);
-					packed_size += 2;
-
-				} else
-					while (count--) {
-						*save++ = (ubyte)last;
-						packed_size++;
-					}
-
-			} else {
-				*save++ = (ubyte)packer_code;
-				*save++ = (ubyte)(count - 1);
-				*save++ = (ubyte)last;
-				packed_size += 3;
-			}
-			break;
-
-		case PACKING_METHOD_STD_RLE_KEY: {
-			ubyte *dest_start;
-			int i;
-
-			dest_start = save;
-			count = 1;
-
-			last = *frame++;
-			*save++ = PACKING_METHOD_STD_RLE_KEY;
-			for (i=1; i < size; i++ )	{
-
-				if ( *frame != last ) {
-					if ( count ) {
-
-						if (packed_size + 2 >= max)
-							return -1;
-
-						if ( (count == 1) && !(last & STD_RLE_CODE) ) {
-							*save++ = (ubyte)last;
-							packed_size++;
-							Assert( last != STD_RLE_CODE );
-						}
-						else {
-							count |= STD_RLE_CODE;
-							*save++ = (ubyte)count;
-							*save++ = (ubyte)last;
-							packed_size += 2;
-						}
-					}
-		
-					last = *frame;
-					count = 0;
-				}
-
-				count++;
-				frame++;
-
-				if ( count == 127 ) {
-					count |= STD_RLE_CODE;
-					*save++ = (ubyte)count;
-					*save++ = (ubyte)last;
-					packed_size += 2;
-					count = 0;
-				}
-			}	// end for
-
-			if (count)	{
-
-				if (packed_size + 2 >= max)
-					return -1;
-
-				if ( (count == 1) && !(last & STD_RLE_CODE) ) {
-					*save++ = (ubyte)last;
-					packed_size++;
-					Assert( last != STD_RLE_CODE );
-				}
-				else {
-					count |= STD_RLE_CODE;
-					*save++ = (ubyte)count;
-					*save++ = (ubyte)last;
-					packed_size += 2;
-				}
-			}
-
-			Assert(packed_size == (save-dest_start) );
-			return packed_size;
-			}
-
-		default:
-			Assert(0);
-			return -1;
-			break;
-	} // end switch
-
-	return packed_size;
-}
-
-/**
- * @brief Pack frame
- *
- * @param frame Frame pixel data to pack
- * @param frame2 Previous frame's pixel data
- * @param save Memory to store packed data to
- * @param size Number of bytes to pack
- * @param max Maximum number of packed bytes (size of buffer)
- * @param compress_type Compress type
- * @return Actual number of bytes data packed to or -1 if error
- */
-int pack_frame(ubyte *frame, ubyte *frame2, ubyte *save, long size, long max, int compress_type)
-{
-	int pixel, last = -32768, count = 0, i;
-	long packed_size = 1;
-
-	switch ( compress_type ) {
-		case PACKING_METHOD_RLE:					// Hoffoss RLE regular frame
-			*save++ = PACKING_METHOD_RLE;
-			while (size--) {
-				if (*frame != *frame2++)
-					pixel = *frame;
-				else
-					pixel = transparent_code;
-
-				if (pixel != last || count > 255) {
-					if (packed_size + 3 >= max)
-						return -1;
-
-					if (count < 3) {
-						if (last == packer_code) {
-							*save++ = (ubyte)packer_code;
-							*save++ = (ubyte)(count - 1);
-							packed_size += 2;
-
-						} else
-							while (count--) {
-								*save++ = (ubyte)last;
-								packed_size++;
-							}
-
-					} else {
-						*save++ = (ubyte)packer_code;
-						*save++ = (ubyte)(count - 1);
-						*save++ = (ubyte)last;
-						packed_size += 3;
-					}
-
-					count = 0;
-					last = pixel;
-				}
-
-				frame++;
-				count++;
-			}
-
-			if (packed_size + 3 >= max)
-				return -1;
-
-			if (count < 3) {
-				if (last == packer_code) {
-					*save++ = (ubyte)packer_code;
-					*save++ = (ubyte)(count - 1);
-					packed_size += 2;
-
-				} else
-					while (count--) {
-						*save++ = (ubyte)last;
-						packed_size++;
-					}
-
-			} else {
-				*save++ = (ubyte)(packer_code);
-				*save++ = (ubyte)(count - 1);
-				*save++ = (ubyte)(last);
-				packed_size += 3;
-			}
-			break;
-
-		case PACKING_METHOD_STD_RLE: {		// high bit count regular RLE frame
-
-			ubyte *dest_start;
-
-			dest_start = save;
-			count = 1;
-
-			if (*frame++ != *frame2++)
-				last = *frame;
-			else
-				last = transparent_code;
-
-			*save++ = PACKING_METHOD_STD_RLE;
-			for (i=1; i < size; i++ )	{
-
-				if (*frame != *frame2++)
-					pixel = *frame;
-				else
-					pixel = transparent_code;
-
-				if ( pixel != last ) {
-					if ( count ) {
-
-						if (packed_size + 2 >= max)
-							return -1;
-
-						if ( (count == 1) && !(last & STD_RLE_CODE) ) {
-							*save++ = (ubyte)last;
-							packed_size++;
-							Assert( last != STD_RLE_CODE );
-						}
-						else {
-							count |= STD_RLE_CODE;
-							*save++ = (ubyte)count;
-							*save++ = (ubyte)last;
-							packed_size += 2;
-						}
-					}
-		
-					last = pixel;
-					count = 0;
-				}
-
-				count++;
-				frame++;
-
-				if ( count == 127 ) {
-					count |= STD_RLE_CODE;
-					*save++ = (ubyte)count;
-					*save++ = (ubyte)last;
-					packed_size += 2;
-					count = 0;
-				}
-			}	// end for
-
-			if (count)	{
-
-				if (packed_size + 2 >= max)
-					return -1;
-
-				if ( (count == 1) && !(last & STD_RLE_CODE) ) {
-					*save++ = (ubyte)last;
-					packed_size++;
-					Assert( last != STD_RLE_CODE );
-				}
-				else {
-					count |= STD_RLE_CODE;
-					*save++ = (ubyte)count;
-					*save++ = (ubyte)last;
-					packed_size += 2;
-				}
-			}
-
-			Assert(packed_size == (save-dest_start) );
-			return packed_size;
-			}
-
-		default:
-			Assert(0);
-			return -1;
-			break;
-	} // end switch
-
-	return packed_size;
-}
-
 /**
  * @brief Convert a 24 bit value to a 16 bit value
  * @param bit_24 24 bit value

code/anim/packunpack.h

@@ -97,16 +97,12 @@ typedef struct anim_instance {
 	int		loop_count;		// starts at 0, and is incremented each time it loops
 } anim_instance;
 
-int	pack_key_frame(ubyte *frame, ubyte *save, long size, long max, int compress_type);
-int	pack_frame(ubyte *frame, ubyte *frame2, ubyte *save, long size, long max, int compress_type);
-
 ubyte	*unpack_frame(anim_instance *ai, ubyte *ptr, ubyte *frame, int size, ubyte *pal_translate, int aabitmap, int bpp);
 int unpack_frame_from_file(anim_instance *ai, ubyte *frame, int size, ubyte *pal_translate, int aabitmap, int bpp);
 
 void	anim_init();
 anim_instance *init_anim_instance(anim *ptr, int bpp);
 void	free_anim_instance(anim_instance *inst);
-int	anim_get_next_frame(anim_instance *inst);
 ubyte *anim_get_next_raw_buffer(anim_instance *inst, int xlate_pal, int aabitmap, int bpp);
 void	anim_set_palette(anim *a);
 void	anim_check_for_palette_change(anim_instance *inst);

code/asteroid/asteroid.cpp

@@ -478,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)", asip->name, pm->n_detail_levels));
+				nprintf(("Warning",  "For asteroid '%s', detail level mismatch (POF needs %d)\n", asip->name, pm->n_detail_levels));
 			}
 		}	
 		// Stuff detail level distances.
@@ -1143,8 +1143,6 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 
 		// SET PHYSICS PARAMETERS
 		// already have (hitpos - heavy) and light_cm_pos
-		// get heavy cm pos - already have light_cm_pos
-		asteroid_hit_info->heavy_collision_cm_pos = zero;
 
 		// get r_heavy and r_light
 		asteroid_hit_info->r_heavy = asteroid_hit_info->hit_pos;
@@ -1263,7 +1261,7 @@ static float asteroid_create_explosion(object *objp)
 
 	fireball_scale_multiplier = asteroid_get_fireball_scale_multiplier(objp->instance);
 
-	fireball_objnum = fireball_create( &objp->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(objp), objp->radius*fireball_scale_multiplier, 0, &objp->phys_info.vel );
+	fireball_objnum = fireball_create( &objp->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(objp), objp->radius*fireball_scale_multiplier, false, &objp->phys_info.vel );
 	if ( fireball_objnum > -1 )	{
 		explosion_life = fireball_lifeleft(&Objects[fireball_objnum]);
 	} else {
@@ -1939,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(("Asteroid.tbl as parsed:\n"));
-				mprintf(("%s", iter->c_str()));
+				mprintf(("%s\n", iter->c_str()));
 			}
 #endif
 			Error(LOCATION,

code/autopilot/autopilot.cpp

@@ -122,31 +122,6 @@ vec3d *NavPoint::GetPosition()
 	}
 }
 
-char* NavPoint::GetInternalName()
-{
-	char *NavName;
-	char strtmp[33];
-
-	if (flags & NP_WAYPOINT)
-	{
-		NavName = new char[strlen(((waypoint_list*)target_obj)->get_name())+5];
-		memset(NavName, 0, strlen(((waypoint_list*)target_obj)->get_name())+5);
-		strcpy(NavName, ((waypoint_list*)target_obj)->get_name());
-
-		strcat(NavName, ":");
-		sprintf(strtmp, "%d", waypoint_num);
-		strcat(NavName, strtmp);
-	}
-	else
-	{		
-		NavName = new char[strlen(((ship*)target_obj)->ship_name)+1];
-		memset(NavName, 0, strlen(((ship*)target_obj)->ship_name)+1);
-		strcpy(NavName, ((ship*)target_obj)->ship_name);
-	}
-
-	return NavName;
-}
-
 // ********************************************************************************************
 bool CanAutopilot(vec3d targetPos, bool send_msg)
 {
@@ -243,9 +218,9 @@ bool StartAutopilot()
 			if (shipp->team != Player_ship->team)
 				continue;
 
-			Assertion((shipp->ship_info_index >= 0) && (shipp->ship_info_index < static_cast<int>(Ship_info.size())),
+			Assertion((shipp->ship_info_index >= 0) && (shipp->ship_info_index < 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, static_cast<int>(Ship_info.size()));
+				shipp->ship_name, shipp->ship_info_index, ship_info_size());
 			ship_info *sip = &Ship_info[shipp->ship_info_index];
 
 			if ( !(sip->flags[Ship::Info_Flags::Support]) )
@@ -998,7 +973,6 @@ camera* nav_get_set_camera()
 	return nav_camera.getCamera();
 }
 
-extern int Cmdline_old_collision_sys;
 void nav_warp(bool prewarp=false)
 {
 	/* ok... find our end distance - norm1 is still a unit vector in the
@@ -1053,11 +1027,7 @@ void nav_warp(bool prewarp=false)
 	}
 
 	// retime all collision pairs
-	if ( Cmdline_old_collision_sys ) {
-		obj_all_collisions_retime();
-	} else {
-		obj_collide_retime_cached_pairs();
-	}
+	obj_collide_retime_cached_pairs();
 }
 
 // ********************************************************************************************
@@ -1464,22 +1434,6 @@ bool AddNav_Waypoint(char *Nav, char *WP_Path, int node, int flags)
 }
 
 // ********************************************************************************************
-//Change Flags
-bool Nav_Alt_Flags(char *Nav, int flags)
-{
-	flags &= ~NP_VALIDTYPE; //clear the NP_SHIP and NP_WAYPOINT bits, make sure they haven't been set
-
-	int nav = FindNav(Nav);
-
-	if (nav != -1)
-	{
-		Navs[nav].flags &= NP_VALIDTYPE; // Clear all bits BUT NP_SHIP or NO_WAYPOINT
-		Navs[nav].flags |= flags; // merge
-	}
-
-	return (nav != -1);
-}
-
 //Get Flags
 int Nav_Get_Flags(char *Nav)
 {

code/autopilot/autopilot.h

@@ -36,7 +36,6 @@ public:
 	int waypoint_num; //only used when flags & NP_WAYPOINT
 
 	vec3d *GetPosition();
-	char* GetInternalName();
 
 	void clear()
 	{
@@ -129,9 +128,6 @@ void SelectNav(char *Nav);
 // Deselects any navpoint selected.
 void DeselectNav();
 
-// Set A Nav point to "ZERO"
-void ZeroNav(int i);
-
 // Removes a Nav
 bool DelNavPoint(char *Nav);
 bool DelNavPoint(int nav);
@@ -140,9 +136,6 @@ bool DelNavPoint(int nav);
 bool AddNav_Ship(char *Nav, char *TargetName, int flags); 
 bool AddNav_Waypoint(char *Nav, char *WP_Path, int node, int flags);
 
-//Change Flags
-bool Nav_Alt_Flags(char *Nav, int flags);
-
 // Sexp Accessors
 bool Nav_Set_Flag(char *Nav, int flag);
 bool Nav_UnSet_Flag(char *Nav, int flag);

code/bmpman/bm_internal.h

@@ -67,9 +67,7 @@ struct bitmap_entry {
 	char filename[MAX_FILENAME_LEN];    //!< filename for this bitmap
 
 	uint signature;         //!< a unique signature identifying the data
-	uint palette_checksum;  //!< checksum used to be sure bitmap is in current palette
 	int  handle;            //!< Handle = id*MAX_BITMAPS + bitmapnum
-	int  last_used;         //!< When this bitmap was last used
 
 	BM_TYPE type;             //!< PCX, USER, ANI, etc
 	BM_TYPE comp_type;        //!< What sort of compressed type, BM_TYPE_NONE if not compressed

code/bmpman/bmpman.cpp

@@ -10,12 +10,9 @@
 #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"
@@ -55,14 +52,7 @@ MONITOR(SizeBitmapPage)
 
 // --------------------------------------------------------------------------------------------------------------------
 // Definition of public variables (declared as extern in bmpman.h).
-int GLOWMAP = -1;
-int SPECMAP = -1;
-int SPECGLOSSMAP = -1;
 int ENVMAP = -1;
-int NORMMAP = -1;
-int HEIGHTMAP = -1;
-int MISCMAP = -1;
-int AMBIENTMAP = -1;
 
 size_t bm_texture_ram = 0;
 int Bm_paging = 0;
@@ -80,11 +70,6 @@ const char *bm_ani_ext_list[] = { ".eff", ".ani", ".png" };
 const int BM_ANI_NUM_TYPES = sizeof(bm_ani_type_list) / sizeof(bm_ani_type_list[0]);
 
 void(*bm_set_components)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) = NULL;
-void(*bm_set_components_32)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a) = NULL;
-
-// --------------------------------------------------------------------------------------------------------------------
-// Declaration of protected variables (defined in cmdline.cpp).
-extern int Cmdline_cache_bitmaps;
 
 // --------------------------------------------------------------------------------------------------------------------
 // Definition of public variables (declared as extern in bm_internal.h).
@@ -193,42 +178,6 @@ float bitmap_lookup::map_texture_address(float address)
 	return address - floorf(address);
 }
 
-float bitmap_lookup::get_channel_red(float u, float v)
-{
-	Assert( Bitmap_data != NULL );
-
-	CLAMP(u, 0.0f, 1.0f);
-	CLAMP(v, 0.0f, 1.0f);
-
-	int x = fl2i(map_texture_address(u) * (Width-1));
-	int y = fl2i(map_texture_address(v) * (Height-1));
-
-	return i2fl(Bitmap_data[(y*Width + x)*Num_channels]) / 255.0f;
-}
-
-float bitmap_lookup::get_channel_green(float u, float v)
-{
-	Assert( Bitmap_data != NULL );
-
-	CLAMP(u, 0.0, 1.0f);
-	CLAMP(v, 0.0, 1.0f);
-
-	int x = fl2i(map_texture_address(u) * (Width-1));
-	int y = fl2i(map_texture_address(v) * (Height-1));
-
-	return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 1]) / 255.0f;
-}
-
-float bitmap_lookup::get_channel_blue(float u, float v)
-{
-	Assert( Bitmap_data != NULL );
-
-	int x = fl2i(map_texture_address(u) * (Width-1));
-	int y = fl2i(map_texture_address(v) * (Height-1));
-
-	return i2fl(Bitmap_data[(y*Width + x)*Num_channels + 2]) / 255.0f;
-}
-
 float bitmap_lookup::get_channel_alpha(float u, float v)
 {
 	Assert( Bitmap_data != NULL );
@@ -594,7 +543,6 @@ int bm_create(int bpp, int w, int h, void *data, int flags) {
 	sprintf_safe(entry->filename, "TMP%dx%d+%d", w, h, bpp);
 	entry->type = BM_TYPE_USER;
 	entry->comp_type = BM_TYPE_NONE;
-	entry->palette_checksum = 0;
 
 	entry->bm.w = (short)w;
 	entry->bm.h = (short)h;
@@ -612,7 +560,6 @@ int bm_create(int bpp, int w, int h, void *data, int flags) {
 	entry->signature = Bm_next_signature++;
 
 	entry->handle = n;
-	entry->last_used = -1;
 	entry->mem_taken = (w * h * (bpp >> 3));
 
 	entry->load_count++;
@@ -958,16 +905,6 @@ void bm_get_palette(int handle, ubyte *pal, char *name) {
 	}
 }
 
-uint bm_get_signature(int handle) {
-	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");
-
-	return bm_get_entry(handle)->signature;
-}
-
-size_t bm_get_size(int handle) {
-	return bm_get_entry(handle)->mem_taken;
-}
-
 int bm_get_tcache_type(int num) {
 	if (bm_is_compressed(num))
 		return TCACHE_TYPE_COMPRESSED;
@@ -1268,9 +1205,7 @@ int bm_load(const char *real_filename) {
 	entry->num_mipmaps = mm_lvl;
 	entry->mem_taken = (size_t)bm_size;
 	entry->dir_type = CF_TYPE_ANY;
-	entry->palette_checksum = 0;
 	entry->handle = handle;
-	entry->last_used = -1;
 
 	entry->load_count++;
 
@@ -1733,10 +1668,8 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 		entry->bm.palette = nullptr;
 		entry->type = type;
 		entry->comp_type = c_type;
-		entry->palette_checksum = 0;
 		entry->signature = Bm_next_signature++;
 		entry->handle = n + i;
-		entry->last_used = -1;
 		entry->num_mipmaps = mm_lvl;
 		entry->mem_taken = (size_t)img_size;
 		entry->dir_type = dir_type;
@@ -1979,8 +1912,6 @@ bitmap * bm_lock(int handle, int bpp, ubyte flags, bool nodebug) {
 			// Mark all the bitmaps in this bitmap or animation as recently used
 			auto frame_entry = bm_get_entry(first + i);
 
-			frame_entry->last_used = timer_get_milliseconds();
-
 #ifdef BMPMAN_NDEBUG
 			// Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
 			frame_entry->used_count++;
@@ -1989,9 +1920,6 @@ bitmap * bm_lock(int handle, int bpp, ubyte flags, bool nodebug) {
 			frame_entry->used_flags = flags;
 		}
 	} else {
-		// Mark all the bitmaps in this bitmap or animation as recently used
-		be->last_used = timer_get_milliseconds();
-
 #ifdef BMPMAN_NDEBUG
 		// Mark all the bitmaps in this bitmap or animation as used for the usage tracker.
 		be->used_count++;
@@ -2536,9 +2464,7 @@ int bm_make_render_target(int width, int height, int flags) {
 	entry->mem_taken = (size_t)size;
 	entry->dir_type = CF_TYPE_ANY;
 
-	entry->palette_checksum = 0;
 	entry->handle = n;
-	entry->last_used = -1;
 
 	if (entry->mem_taken) {
 		entry->bm.data = (ptr_u)bm_malloc(n, entry->mem_taken);
@@ -2775,30 +2701,6 @@ void bm_page_in_xparent_texture(int bitmapnum, int nframes) {
 	}
 }
 
-bool bm_page_out(int handle) {
-	auto entry = bm_get_entry(handle);
-
-	// in case it's already been released
-	if (entry->type == BM_TYPE_NONE)
-		return 0;
-
-	// it's possible to hit < 0 here when model_page_out_textures() is
-	// called from anywhere other than in a mission
-	if (entry->preload_count > 0) {
-		nprintf(("BmpMan",
-			 "PAGE-OUT: %s - preload_count remaining: %d\n",
-			 entry->filename,
-			 entry->preload_count));
-
-		// lets decrease it for next time around
-		entry->preload_count--;
-
-		return 0;
-	}
-
-	return (bm_unload(handle) == 1);
-}
-
 void bm_print_bitmaps() {
 #ifdef BMPMAN_NDEBUG
 	for (auto& block : bm_blocks) {
@@ -2884,7 +2786,6 @@ int bm_release(int handle, int clear_render_targets) {
 			// For debugging:
 			strcpy_s(entry->filename, "IVE_BEEN_RELEASED!");
 			entry->signature = 0xDEADBEEF;									// a unique signature identifying the data
-			entry->palette_checksum = 0xDEADBEEF;							// checksum used to be sure bitmap is in current palette
 
 			// bookeeping
 			entry->ref_count = -1;									// Number of locks on bitmap.  Can't unload unless ref_count is 0.
@@ -2911,7 +2812,6 @@ int bm_release(int handle, int clear_render_targets) {
 		// For debugging:
 		strcpy_s(entry->filename, "IVE_BEEN_RELEASED!");
 		entry->signature = 0xDEADBEEF;									// a unique signature identifying the data
-		entry->palette_checksum = 0xDEADBEEF;							// checksum used to be sure bitmap is in current palette
 
 		// bookeeping
 		entry->ref_count = -1;									// Number of locks on bitmap.  Can't unload unless ref_count is 0.
@@ -2953,7 +2853,6 @@ void BM_SELECT_ALPHA_TEX_FORMAT() {
 	Gr_current_alpha = &Gr_ta_alpha;
 
 	// setup pointers
-	bm_set_components_32 = bm_set_components_argb_32_tex;
 	// should always assume that 16-bit is the default request
 	bm_set_components = bm_set_components_argb_16_tex;
 }
@@ -2965,7 +2864,6 @@ void BM_SELECT_SCREEN_FORMAT() {
 	Gr_current_alpha = &Gr_alpha;
 
 	// setup pointers
-	bm_set_components_32 = bm_set_components_argb_32_screen;
 	// should always assume that 16-bit is the default request
 	bm_set_components = bm_set_components_argb_16_screen;
 }
@@ -2977,7 +2875,6 @@ void BM_SELECT_TEX_FORMAT() {
 	Gr_current_alpha = &Gr_t_alpha;
 
 	// setup pointers
-	bm_set_components_32 = bm_set_components_argb_32_tex;
 	// should always assume that 16-bit is the default request
 	bm_set_components = bm_set_components_argb_16_tex;
 }
@@ -3005,29 +2902,6 @@ void bm_set_components_argb_16_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv
 	*((unsigned short*)pixel) |= (unsigned short)(Gr_current_alpha->mask);
 }
 
-void bm_set_components_argb_32_screen(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
-	if (*av == 0) {
-		*((unsigned int*)pixel) = (unsigned int)Gr_current_green->mask;
-		return;
-	}
-
-	*((unsigned int*)pixel) = (unsigned int)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
-	*((unsigned int*)pixel) |= (unsigned int)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
-	*((unsigned int*)pixel) |= (unsigned int)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
-}
-
-void bm_set_components_argb_32_tex(ubyte *pixel, ubyte *rv, ubyte *gv, ubyte *bv, ubyte *av) {
-	if (*av == 0) {
-		*((unsigned int*)pixel) = 0;
-		return;
-	}
-
-	*((unsigned int*)pixel) = (unsigned int)(((int)*rv / Gr_current_red->scale) << Gr_current_red->shift);
-	*((unsigned int*)pixel) |= (unsigned int)(((int)*gv / Gr_current_green->scale) << Gr_current_green->shift);
-	*((unsigned int*)pixel) |= (unsigned int)(((int)*bv / Gr_current_blue->scale) << Gr_current_blue->shift);
-	*((unsigned int*)pixel) |= (unsigned int)(Gr_current_alpha->mask);
-}
-
 void bm_set_low_mem(int mode) {
 	Assert((mode >= 0) && (mode <= 2));
 

code/bmpman/bmpman.h

@@ -113,12 +113,7 @@ extern const BM_TYPE bm_ani_type_list[];   //!< List of valid bitmap animation t
 extern const char *bm_ani_ext_list[];    //!< List of extensions for those types
 extern const int BM_ANI_NUM_TYPES;       //!< Calculated number of bitmap animation types
 
-extern int GLOWMAP;     //!< References a map that is a fully lit version of its index -Bobboau
-extern int SPECMAP;     //!< References a map that is for specular mapping -Bobboau
 extern int ENVMAP;      //!< References a map that is for environment mapping -Bobboau
-extern int NORMMAP;     //!< Normal mapping
-extern int HEIGHTMAP;   //!< Height map for normal mapping
-extern int MISCMAP;     //!< Utility map, to be utilized for various things shader authors can come up with
 
 /**
  * @brief Initilizes the bitmap manager
@@ -167,9 +162,6 @@ public:
 
 	bool valid();
 
-	float get_channel_red(float u, float v);
-	float get_channel_green(float u, float v);
-	float get_channel_blue(float u, float v);
 	float get_channel_alpha(float u, float v);
 };
 
@@ -311,13 +303,6 @@ int bm_load_either(const char *filename, int *nframes = NULL, int *fps = NULL, i
  */
 bitmap* bm_lock(int handle, int bpp, ubyte flags, bool nodebug = false);
 
-/**
- * @brief Returns a unique signiature for the bitmap indexed by handle
- *
- * @details A signature will change when the bitmap's data changes
- */
-uint bm_get_signature(int handle);
-
 /**
  * @brief Returns the image type of the given bitmap handle
  */
@@ -459,15 +444,6 @@ void bm_page_in_xparent_texture(int bitmapnum, int num_frames = 1);
  */
 void bm_page_in_aabitmap(int bitmapnum, int num_frames = 1);
 
-/**
- * @brief Unloads the bitmap indexed by handle that was previously paged-in
- *
- * @returns 0 If the bitmap had already been released, or
- * @returns 0 If the handle is invalid, or
- * @returns 1 If successful
- */
-bool bm_page_out(int handle);
-
 /**
  * @brief Sets BMPMAN's memory mode
  *
@@ -516,16 +492,6 @@ void BM_SELECT_ALPHA_TEX_FORMAT();
  */
 extern void(*bm_set_components)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
 
-/**
- * @brief Functional pointer that references any of the bm_set_components_32 functions.
- *
- * @details The bm_set_components functions packs the RGBA values into the ubyte array referenced by pixel, whose
- * format differs according to its bpp value and presence of an alpha channel. The RGBA values are scaled accordingly.
- *
- * @see bm_set_components
- */
-extern void(*bm_set_components_32)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
-
 /**
  * @brief Sets the 16bpp screen pixel to the specified RGBA value
  *
@@ -533,13 +499,6 @@ extern void(*bm_set_components_32)(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, u
  */
 void bm_set_components_argb_16_screen(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
 
-/**
- * @brief Sets the 32bpp screen pixel to the specified RGBA value
- *
- * @see bm_set_components
- */
-void bm_set_components_argb_32_screen(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
-
 /**
  * @brief Sets the 16bpp texture pixel to the specified RGBA value
  *
@@ -561,15 +520,7 @@ void bm_set_components_argb_32_tex(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, u
  */
 void bm_get_components(ubyte *pixel, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
 
-extern int UNLITMAP; //this holds a reference to a map that is optional used instead of the base map for unlit rendering
-extern int GLOWMAP;	//this holds a reference to a map that is a fully lit version of its index -Bobboau
-extern int SPECMAP;	//this holds a reference to a map that is for specular mapping -Bobboau
-extern int SPECGLOSSMAP;	//this holds a reference to a map that is for specular mapping -Bobboau
 extern int ENVMAP;	//this holds a reference to a map that is for environment mapping -Bobboau
-extern int NORMMAP;	// normal mapping
-extern int HEIGHTMAP;	// height map for normal mapping
-extern int AMBIENTMAP; // ambient occluion map. red channel affects ambient lighting, green channel affects diffuse and specular
-extern int MISCMAP; // Utility map, to be utilized for various things shader authors can come up with
 
 /**
  * @brief Returns the compression type of the bitmap indexed by handle
@@ -581,10 +532,6 @@ int bm_is_compressed(int handle);
  */
 int bm_get_tcache_type(int handle);
 
-/**
- * @brief Gets the size, in bytes, taken up by the bitmap indexed by handle
- */
-size_t bm_get_size(int handle);
 
 /**
  * @brief Gets the number of mipmaps of the indexed texture

code/camera/camera.cpp

@@ -7,9 +7,10 @@
 #include "math/vecmat.h"
 #include "mod_table/mod_table.h"
 #include "model/model.h" //polymodel, model_get
+#include "options/Option.h"
 #include "parse/parselo.h"
 #include "playerman/player.h" //player_get_padlock_orient
-#include "ship/ship.h" //compute_slew_matrix
+#include "ship/ship.h"        //compute_slew_matrix
 
 //*************************IMPORTANT GLOBALS*************************
 float VIEWER_ZOOM_DEFAULT = 0.75f;			//	Default viewer zoom, 0.625 as per multi-lateral agreement on 3/24/97
@@ -24,6 +25,23 @@ SCP_vector<camera*> Cameras;
 camid Current_camera;
 camid Main_camera;
 
+static SCP_string fov_display(float val)
+{
+	auto degrees = fl_degrees(val);
+	SCP_string out;
+	sprintf(out, u8"%.1f\u00B0", degrees);
+	return out;
+}
+auto FovOption = options::OptionBuilder<float>("Graphics.FOV", "Field Of View", "The vertical field of view.")
+                     .category("Graphics")
+                     .range(0.436332f, 1.5708f)
+                     .bind_to(&VIEWER_ZOOM_DEFAULT)
+                     .display(fov_display)
+                     .default_val(0.75f)
+                     .level(options::ExpertLevel::Advanced)
+                     .importance(60)
+                     .finish();
+
 //*************************CLASS: camera*************************
 //This is where the camera class beings! :D
 camera::camera(const char *in_name, int in_signature)
@@ -145,7 +163,7 @@ void camera::set_object_target(object *objp, int n_object_target_submodel)
  * Custom function receives the already-modified current position value.
  * It should be replaced or added to as the custom function modifier sees fit.
  */
-void camera::set_custom_position_function(void (*n_func_custom_position)(camera *cam, vec3d *camera_pos))
+void camera::set_custom_position_function(void (*n_func_custom_position)(camera* /*cam*/, vec3d* /*camera_pos*/))
 {
 	func_custom_position = n_func_custom_position;
 }
@@ -154,7 +172,7 @@ void camera::set_custom_position_function(void (*n_func_custom_position)(camera
  * Custom function receives the already-modified current orientation value.
  * It should be replaced or added to as the custom function modifier sees fit.
  */
-void camera::set_custom_orientation_function(void (*n_func_custom_orientation)(camera *cam, matrix *camera_ori))
+void camera::set_custom_orientation_function(void (*n_func_custom_orientation)(camera* /*cam*/, matrix* /*camera_ori*/))
 {
 	func_custom_orientation = n_func_custom_orientation;
 }
@@ -185,13 +203,6 @@ void camera::set_position(vec3d *in_position, float in_translation_time, float i
 	pos_z.setAVD(in_position->xyz.z, in_translation_time, in_translation_acceleration_time, in_translation_deceleration_time, in_end_velocity);
 }
 
-void camera::set_translation_velocity(vec3d *in_velocity, float in_acceleration_time)
-{
-	pos_x.setVD(in_acceleration_time, in_acceleration_time, in_velocity->xyz.x);
-	pos_y.setVD(in_acceleration_time, in_acceleration_time, in_velocity->xyz.y);
-	pos_z.setVD(in_acceleration_time, in_acceleration_time, in_velocity->xyz.z);
-}
-
 void camera::set_rotation(matrix *in_orientation, float in_rotation_time, float in_rotation_acceleration_time, float in_rotation_deceleration_time)
 {
 	if(in_orientation != NULL && in_rotation_time == 0.0f && in_rotation_acceleration_time == 0.0f && in_rotation_deceleration_time == 0.0f)
@@ -245,11 +256,6 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 	set_rotation(&temp_matrix, in_rotation_time, in_rotation_acceleration_time, in_rotation_deceleration_time);
 }
 
-void camera::set_rotation_velocity(angles * /*in_rotation_rate*/, float  /*in_acceleration_time*/)
-{
-	Error(LOCATION, "This function is disabled until further notice.");
-}
-
 void camera::do_frame(float  /*in_frametime*/)
 {
 

code/camera/camera.h

@@ -17,7 +17,6 @@
 
 class camera
 {
-	friend class avd_camera;
 protected:
 	char name[NAME_LENGTH];
 	int sig;
@@ -60,12 +59,10 @@ public:
 	void set_fov(float in_fov, float in_fov_time = 0.0f, float in_fov_acceleration_time = 0.0f, float in_deceleration_time = 0.0f);
 
 	void set_position(vec3d *in_position = NULL, float in_translation_time = 0.0f, float in_translation_acceleration_time = 0.0f, float in_translation_deceleration_time = 0.0f, float in_end_velocity = 0.0f);
-	void set_translation_velocity(vec3d *in_velocity, float in_acceleration_time = 0.0f);
 
 	void set_rotation(matrix *in_orientation = NULL, float in_rotation_time = 0.0f, float in_rotation_acceleration_time = 0.0f, float in_rotation_deceleration_time = 0.0f);
 	void set_rotation(angles *in_angles, float in_rotation_time = 0.0f, float in_rotation_acceleration_time = 0.0f, float in_rotation_deceleration_time = 0.0f);
 	void set_rotation_facing(vec3d *in_target, float in_rotation_time = 0.0f, float in_rotation_acceleration_time = 0.0f, float in_rotation_deceleration_time = 0.0f);
-	void set_rotation_velocity(angles *in_rotation_rate, float in_acceleration_time = 0.0f);
 
 	//Get
 	const char* get_name() { return name; }

code/cfile/cfile.cpp

@@ -57,7 +57,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",						CF_TYPE_DATA	},
+	{ CF_TYPE_TABLES,				"data" DIR_SEPARATOR_STR "tables",											".tbl .tbm .lua",						CF_TYPE_DATA	},
 	{ CF_TYPE_SOUNDS,				"data" DIR_SEPARATOR_STR "sounds",											".wav .ogg",						CF_TYPE_DATA	},
 	{ CF_TYPE_SOUNDS_8B22K,			"data" DIR_SEPARATOR_STR "sounds" DIR_SEPARATOR_STR "8b22k",				".wav .ogg",						CF_TYPE_SOUNDS	},
 	{ CF_TYPE_SOUNDS_16B11K,		"data" DIR_SEPARATOR_STR "sounds" DIR_SEPARATOR_STR "16b11k",				".wav .ogg",						CF_TYPE_SOUNDS	},
@@ -101,8 +101,7 @@ static int Cfile_stack_pos = 0;
 
 static char Cfile_stack[CFILE_STACK_MAX][CFILE_ROOT_DIRECTORY_LEN];
 
-Cfile_block Cfile_block_list[MAX_CFILE_BLOCKS];
-static CFILE Cfile_list[MAX_CFILE_BLOCKS];
+std::array<CFILE, MAX_CFILE_BLOCKS> Cfile_block_list;
 
 static const char *Cfile_cdrom_dir = NULL;
 
@@ -201,7 +200,6 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)
 
 	strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1);
 	buf[CFILE_ROOT_DIRECTORY_LEN - 1] = '\0';
-	size_t i = strlen(buf);
 
 	// are we in a root directory?		
 	if(cfile_in_root_dir(buf)){
@@ -229,9 +227,8 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)
 	strcpy_s(Cfile_root_dir, buf);
 	strcpy_s(Cfile_user_dir, os_get_config_path().c_str());
 
-	for (i = 0; i < MAX_CFILE_BLOCKS; i++) {
-		Cfile_block_list[i].type = CFILE_BLOCK_UNUSED;
-	}
+	// Initialize the block list with proper data
+	Cfile_block_list.fill({});
 
 	// 32 bit CRC table init
 	cf_chksum_long_init();
@@ -242,16 +239,6 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir)
 	return 0;
 }
 
-// Call this if pack files got added or removed or the
-// cdrom changed.  This will refresh the list of filenames 
-// stored in packfiles and on the cdrom.
-void cfile_refresh()
-{
-	cf_build_secondary_filelist(Cfile_cdrom_dir);
-}
-
-
-
 #ifdef _WIN32
 // Changes to a drive if valid.. 1=A, 2=B, etc
 // If flag, then changes to it.
@@ -643,9 +630,6 @@ void cf_create_directory(int dir_type, uint32_t location_flags)
 	}
 }
 
-
-extern int game_cd_changed();
-
 // cfopen()
 //
 // parameters:  *filepath ==> name of file to open (may be path+name)
@@ -878,14 +862,14 @@ CFILE *ctmpfile()
 static int cfget_cfile_block()
 {	
 	int i;
-	Cfile_block *cb;
+	CFILE* cfile;
 
 	for ( i = 0; i < MAX_CFILE_BLOCKS; i++ ) {
-		cb = &Cfile_block_list[i];
-		if ( cb->type == CFILE_BLOCK_UNUSED ) {
-			cb->data = NULL;
-			cb->fp = NULL;
-			cb->type = CFILE_BLOCK_USED;
+		cfile = &Cfile_block_list[i];
+		if (cfile->type == CFILE_BLOCK_UNUSED) {
+			cfile->data = nullptr;
+			cfile->fp = nullptr;
+			cfile->type = CFILE_BLOCK_USED;
 			return i;
 		}
 	}
@@ -913,39 +897,36 @@ int cfclose( CFILE * cfile )
 	int result;
 
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
 
 	result = 0;
-	if ( cb->data && cb->mem_mapped ) {
+	if ( cfile->data && cfile->mem_mapped ) {
 		// close memory mapped file
 #if defined _WIN32
-		result = UnmapViewOfFile((void*)cb->data);
+		result = UnmapViewOfFile((void*)cfile->data);
 		Assert(result);
-		result = CloseHandle(cb->hInFile);		
+		result = CloseHandle(cfile->hInFile);
 		Assert(result);	// Ensure file handle is closed properly
-		result = CloseHandle(cb->hMapFile);		
+		result = CloseHandle(cfile->hMapFile);
 		Assert(result);	// Ensure file handle is closed properly
 		result = 0;
 #elif defined SCP_UNIX
 		// FIXME: result is wrong after munmap() but it is successful
-		//result = munmap(cb->data, cb->data_length);
+		//result = munmap(cfile->data, cfile->data_length);
 		//Assert(result);
 		// This const_cast is safe since the pointer returned by mmap was also non-const
-		munmap(const_cast<void*>(cb->data), cb->data_length);
-		if ( cb->fp != NULL)
-			result = fclose(cb->fp);
+		munmap(const_cast<void*>(cfile->data), cfile->data_length);
+		if ( cfile->fp != nullptr)
+			result = fclose(cfile->fp);
 #endif
 
-	} else if ( cb->fp != NULL )	{
-		Assert(cb->fp != NULL);
-		result = fclose(cb->fp);
+	} else if ( cfile->fp != nullptr )	{
+		Assert(cfile->fp != nullptr);
+		result = fclose(cfile->fp);
 	} else {
 		// VP  do nothing
 	}
 
-	cb->type = CFILE_BLOCK_UNUSED;
+	cfile->type = CFILE_BLOCK_UNUSED;
 	return result;
 }
 
@@ -955,13 +936,8 @@ int cf_is_valid(CFILE *cfile)
 	if(cfile == NULL)
 		return 0;
 
-	//Does it have a valid ID?
-	if(cfile->id < 0 || cfile->id >= MAX_CFILE_BLOCKS)
-		return 0;
-
 	//Is it used?
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-	if(cb->type != CFILE_BLOCK_USED && (cb->fp != NULL || cb->data != NULL))
+	if (cfile->type != CFILE_BLOCK_USED && (cfile->fp != nullptr || cfile->data != nullptr))
 		return 0;
 
 	//It's good, as near as we can tell.
@@ -986,20 +962,15 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, FILE *fp, int t
 		fclose(fp);
 		return NULL;
 	} else {
-		CFILE *cfp;
-		Cfile_block *cfbp;
-		cfbp = &Cfile_block_list[cfile_block_index];
-		cfp = &Cfile_list[cfile_block_index];
-		cfp->id = cfile_block_index;
-		cfp->version = 0;
-		cfbp->data = NULL;
-		cfbp->mem_mapped = false;
-		cfbp->fp = fp;
-		cfbp->dir_type = type;
-		cfbp->max_read_len = 0;
+		CFILE *cfp = &Cfile_block_list[cfile_block_index];
+		cfp->data = nullptr;
+		cfp->mem_mapped = false;
+		cfp->fp = fp;
+		cfp->dir_type = type;
+		cfp->max_read_len = 0;
 
-		cfbp->source_file = source;
-		cfbp->line_num = line;
+		cfp->source_file = source;
+		cfp->line_num = line;
 		
 		int pos = ftell(fp);
 		if(pos == -1L)
@@ -1027,21 +998,16 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, FILE *fp, int
 		fclose(fp);
 		return NULL;
 	} else {
-		CFILE *cfp;
-		Cfile_block *cfbp;
-		cfbp = &Cfile_block_list[cfile_block_index];
-	
-		cfp = &Cfile_list[cfile_block_index];
-		cfp->id = cfile_block_index;
-		cfp->version = 0;
-		cfbp->data = NULL;
-		cfbp->fp = fp;
-		cfbp->mem_mapped = false;
-		cfbp->dir_type = type;
-		cfbp->max_read_len = 0;
+		CFILE *cfp = &Cfile_block_list[cfile_block_index];
 
-		cfbp->source_file = source;
-		cfbp->line_num = line;
+		cfp->data = nullptr;
+		cfp->fp = fp;
+		cfp->mem_mapped = false;
+		cfp->dir_type = type;
+		cfp->max_read_len = 0;
+
+		cfp->source_file = source;
+		cfp->line_num = line;
 
 		cf_init_lowlevel_read_code(cfp,offset, size, 0 );
 
@@ -1073,44 +1039,39 @@ static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, FILE *fp
 		return NULL;
 	}
 	else {
-		CFILE *cfp;
-		Cfile_block *cfbp;
-		cfbp = &Cfile_block_list[cfile_block_index];
+		CFILE *cfp = &Cfile_block_list[cfile_block_index];
 
-		cfp = &Cfile_list[cfile_block_index];
-		cfp->id = cfile_block_index;
-		cfp->version = 0;
-		cfbp->max_read_len = 0;
-		cfbp->fp = NULL;
-		cfbp->mem_mapped = true;
+		cfp->max_read_len = 0;
+		cfp->fp = nullptr;
+		cfp->mem_mapped = true;
 #if defined _WIN32
-		cfbp->hInFile = hFile;
+		cfp->hInFile = hFile;
 #endif
-		cfbp->dir_type = type;
+		cfp->dir_type = type;
 
-		cfbp->source_file = source;
-		cfbp->line_num = line;
+		cfp->source_file = source;
+		cfp->line_num = line;
 
 		cf_init_lowlevel_read_code(cfp, 0, 0, 0 );
 #if defined _WIN32
-		cfbp->hMapFile = CreateFileMapping(cfbp->hInFile, NULL, PAGE_READONLY, 0, 0, NULL);
-		if (cfbp->hMapFile == NULL) { 
+		cfp->hMapFile = CreateFileMapping(cfp->hInFile, NULL, PAGE_READONLY, 0, 0, NULL);
+		if (cfp->hMapFile == NULL) {
 			nprintf(("Error", "Could not create file-mapping object.\n")); 
 			return NULL;
 		} 
 	
-		cfbp->data = (ubyte*)MapViewOfFile(cfbp->hMapFile, FILE_MAP_READ, 0, 0, 0);
-		Assert( cfbp->data != NULL );		
+		cfp->data = (ubyte*)MapViewOfFile(cfp->hMapFile, FILE_MAP_READ, 0, 0, 0);
+		Assert( cfp->data != NULL );
 #elif defined SCP_UNIX
-		cfbp->fp = fp;
-		cfbp->data_length = filelength( fileno(fp) );
-		cfbp->data = mmap(NULL,						// start
-								cfbp->data_length,	// length
-								PROT_READ,				// prot
-								MAP_SHARED,				// flags
-								fileno(fp),				// fd
-								0);						// offset
-		Assert( cfbp->data != NULL );		
+		cfp->fp = fp;
+		cfp->data_length = filelength(fileno(fp));
+		cfp->data = mmap(nullptr,                        // start
+		                 cfp->data_length,    // length
+		                 PROT_READ,                // prot
+		                 MAP_SHARED,                // flags
+		                 fileno(fp),                // fd
+		                 0);                        // offset
+		Assert(cfp->data != nullptr);
 #endif
 
 		return cfp;
@@ -1126,23 +1087,18 @@ static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const vo
 		return NULL;
 	}
 	else {
-		CFILE *cfp;
-		Cfile_block *cfbp;
-		cfbp = &Cfile_block_list[cfile_block_index];
+		CFILE *cfp = &Cfile_block_list[cfile_block_index];
 
-		cfp = &Cfile_list[cfile_block_index];
-		cfp->id = cfile_block_index;
-		cfp->version = 0;
-		cfbp->max_read_len = 0;
-		cfbp->fp = NULL;
-		cfbp->mem_mapped = false;
-		cfbp->dir_type = dir_type;
+		cfp->max_read_len = 0;
+		cfp->fp = nullptr;
+		cfp->mem_mapped = false;
+		cfp->dir_type = dir_type;
 
-		cfbp->source_file = source;
-		cfbp->line_num = line;
+		cfp->source_file = source;
+		cfp->line_num = line;
 
 		cf_init_lowlevel_read_code(cfp, 0, size, 0 );
-		cfbp->data = data;
+		cfp->data = data;
 
 		return cfp;
 	}
@@ -1150,7 +1106,7 @@ static CFILE *cf_open_memory_fill_cfblock(const char* source, int line, const vo
 
 int cf_get_dir_type(CFILE *cfile)
 {
-	return Cfile_block_list[cfile->id].dir_type;
+	return cfile->dir_type;
 }
 
 // cf_returndata() returns the data pointer for a memory-mapped file that is associated
@@ -1161,22 +1117,8 @@ int cf_get_dir_type(CFILE *cfile)
 const void *cf_returndata(CFILE *cfile)
 {
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
-	Assert(cb->data != NULL);
-	return cb->data;
-}
-
-
-
-// version number of opened file.  Will be 0 unless you put something else here after you
-// open a file.  Once set, you can use minimum version numbers with the read functions.
-void cf_set_version( CFILE * cfile, int version )
-{
-	Assert(cfile != NULL);
-
-	cfile->version = version;
+	Assert(cfile->data != nullptr);
+	return cfile->data;
 }
 
 // cutoff point where cfread() will throw an error when it hits this limit
@@ -1184,27 +1126,21 @@ void cf_set_version( CFILE * cfile, int version )
 void cf_set_max_read_len( CFILE * cfile, size_t len )
 {
 	Assert( cfile != NULL );
-	Assert( (cfile->id >= 0) && (cfile->id < MAX_CFILE_BLOCKS) );
-
-	Cfile_block *cb = &Cfile_block_list[cfile->id];
 
 	if (len) {
-		cb->max_read_len = cb->raw_position + len;
+		cfile->max_read_len = cfile->raw_position + len;
 	} else {
-		cb->max_read_len = 0;
+		cfile->max_read_len = 0;
 	}
 }
 
 // routines to read basic data types from CFILE's.  Put here to
 // simplify mac/pc reading from cfiles.
 
-float cfread_float(CFILE *file, int ver, float deflt)
+float cfread_float(CFILE* file, float deflt)
 {
 	float f;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &f, sizeof(f), 1, file) != 1)
 		return deflt;
 
@@ -1212,13 +1148,10 @@ float cfread_float(CFILE *file, int ver, float deflt)
 	return f;
 }
 
-int cfread_int(CFILE *file, int ver, int deflt)
+int cfread_int(CFILE* file, int deflt)
 {
 	int i;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &i, sizeof(i), 1, file) != 1)
 		return deflt;
 
@@ -1226,13 +1159,10 @@ int cfread_int(CFILE *file, int ver, int deflt)
 	return i;
 }
 
-uint cfread_uint(CFILE *file, int ver, uint deflt)
+uint cfread_uint(CFILE* file, uint deflt)
 {
 	uint i;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &i, sizeof(i), 1, file) != 1)
 		return deflt;
 
@@ -1240,13 +1170,10 @@ uint cfread_uint(CFILE *file, int ver, uint deflt)
 	return i;
 }
 
-short cfread_short(CFILE *file, int ver, short deflt)
+short cfread_short(CFILE* file, short deflt)
 {
 	short s;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &s, sizeof(s), 1, file) != 1)
 		return deflt;
 
@@ -1254,13 +1181,10 @@ short cfread_short(CFILE *file, int ver, short deflt)
 	return s;
 }
 
-ushort cfread_ushort(CFILE *file, int ver, ushort deflt)
+ushort cfread_ushort(CFILE* file, ushort deflt)
 {
 	ushort s;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &s, sizeof(s), 1, file) != 1)
 		return deflt;
 
@@ -1268,58 +1192,26 @@ ushort cfread_ushort(CFILE *file, int ver, ushort deflt)
 	return s;
 }
 
-ubyte cfread_ubyte(CFILE *file, int ver, ubyte deflt)
+ubyte cfread_ubyte(CFILE* file, ubyte deflt)
 {
 	ubyte b;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &b, sizeof(b), 1, file) != 1)
 		return deflt;
 
 	return b;
 }
 
-void cfread_vector(vec3d *vec, CFILE *file, int ver, vec3d *deflt)
-{
-	if (file->version < ver) {
-		if (deflt)
-			*vec = *deflt;
-		else
-			vec->xyz.x = vec->xyz.y = vec->xyz.z = 0.0f;
-
-		return;
-	}
-
-	vec->xyz.x = cfread_float(file, ver, deflt ? deflt->xyz.x : 0.0f);
-	vec->xyz.y = cfread_float(file, ver, deflt ? deflt->xyz.y : 0.0f);
-	vec->xyz.z = cfread_float(file, ver, deflt ? deflt->xyz.z : 0.0f);
-}
-	
-void cfread_angles(angles *ang, CFILE *file, int ver, angles *deflt)
-{
-	if (file->version < ver) {
-		if (deflt)
-			*ang = *deflt;
-		else
-			ang->p = ang->b = ang->h = 0.0f;
-
-		return;
-	}
-
-	ang->p = cfread_float(file, ver, deflt ? deflt->p : 0.0f);
-	ang->b = cfread_float(file, ver, deflt ? deflt->b : 0.0f);
-	ang->h = cfread_float(file, ver, deflt ? deflt->h : 0.0f);
+void cfread_vector(vec3d* vec, CFILE* file, vec3d* deflt) {
+	vec->xyz.x = cfread_float(file, deflt ? deflt->xyz.x : 0.0f);
+	vec->xyz.y = cfread_float(file, deflt ? deflt->xyz.y : 0.0f);
+	vec->xyz.z = cfread_float(file, deflt ? deflt->xyz.z : 0.0f);
 }
 
-char cfread_char(CFILE *file, int ver, char deflt)
+char cfread_char(CFILE* file, char deflt)
 {
 	char b;
 
-	if (file->version < ver)
-		return deflt;
-
 	if (cfread( &b, sizeof(b), 1, file) != 1)
 		return deflt;
 
@@ -1400,28 +1292,6 @@ int cfwrite_ubyte(ubyte b, CFILE *file)
 	return cfwrite(&b, sizeof(b), 1, file);
 }
 
-int cfwrite_vector(vec3d *vec, CFILE *file)
-{
-	if(!cfwrite_float(vec->xyz.x, file)){
-		return 0;
-	}
-	if(!cfwrite_float(vec->xyz.y, file)){
-		return 0;
-	}
-	return cfwrite_float(vec->xyz.z, file);
-}
-
-int cfwrite_angles(angles *ang, CFILE *file)
-{
-	if(!cfwrite_float(ang->p, file)){
-		return 0;
-	}
-	if(!cfwrite_float(ang->b, file)){
-		return 0;
-	}
-	return cfwrite_float(ang->h, file);
-}
-
 int cfwrite_char(char b, CFILE *file)
 {
 	return cfwrite( &b, sizeof(b), 1, file);
@@ -1454,22 +1324,18 @@ int cfwrite_string_len(const char *buf, CFILE *file)
 }
 
 // Get the filelength
-int cfilelength( CFILE * cfile )
-{
+int cfilelength(CFILE* cfile) {
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
 
 	// TODO: return length of memory mapped file
-	Assert( !cb->mem_mapped );
+	Assert(!cfile->mem_mapped);
+
+	// cfile->size gets set at cfopen
 
-	// cb->size gets set at cfopen
-	
 	// The rest of the code still uses ints, do an overflow check to detect cases where this fails
-	Assertion(cb->size <= static_cast<size_t>(std::numeric_limits<int>::max()),
-		"Integer overflow in cfilelength! A file is too large (but I don't know which...).");
-	return (int) cb->size;
+	Assertion(cfile->size <= static_cast<size_t>(std::numeric_limits<int>::max()),
+	          "Integer overflow in cfilelength! A file is too large (but I don't know which...).");
+	return (int) cfile->size;
 }
 
 // cfwrite() writes to the file
@@ -1485,15 +1351,13 @@ int cfwrite(const void *buf, int elsize, int nelem, CFILE *cfile)
 	if(buf == NULL || elsize == 0 || nelem == 0)
 		return 0;
 
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-
-	if(cb->lib_offset != 0)
+	if(cfile->lib_offset != 0)
 	{
 		Error(LOCATION, "Attempt to write to a VP file (unsupported)");
 		return 0;
 	}
 
-	if(cb->data != NULL)
+	if(cfile->data != nullptr)
 	{
 		Warning(LOCATION, "Writing is not supported for mem-mapped files");
 		return EOF;
@@ -1502,16 +1366,16 @@ int cfwrite(const void *buf, int elsize, int nelem, CFILE *cfile)
 	size_t bytes_written = 0;
 	size_t size = elsize * nelem;
 
-	bytes_written = fwrite(buf, 1, size, cb->fp);
+	bytes_written = fwrite(buf, 1, size, cfile->fp);
 
 	//WMC - update filesize and position
 	if (bytes_written > 0) {
-		cb->size += bytes_written;
-		cb->raw_position += bytes_written;
+		cfile->size += bytes_written;
+		cfile->raw_position += bytes_written;
 	}
 
 #if defined(CHECK_SIZE) && !defined(NDEBUG)
-	Assert( cb->size == filelength(fileno(cb->fp)) );
+	Assert( cfile->size == filelength(fileno(cfile->fp)) );
 #endif
 
 	return (int)(bytes_written / elsize);
@@ -1528,34 +1392,32 @@ int cfputc(int c, CFILE *cfile)
 	if(!cf_is_valid(cfile))
 		return EOF;
 
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-
-	if(cb->lib_offset != 0)
+	if(cfile->lib_offset != 0)
 	{
 		Error(LOCATION, "Attempt to write character to a VP file (unsupported)");
 		return EOF;
 	}
 
-	if(cb->data != NULL)
+	if(cfile->data != nullptr)
 	{
 		Warning(LOCATION, "Writing is not supported for mem-mapped files");
 		return EOF;
 	}
 
 	// writing not supported for memory-mapped files
-	Assert( !cb->data );
+	Assert( !cfile->data );
 
-	int result = fputc(c, cb->fp);
+	int result = fputc(c, cfile->fp);
 
 	//WMC - update filesize and position
 	if(result != EOF)
 	{
-		cb->size += 1;
-		cb->raw_position += 1;
+		cfile->size += 1;
+		cfile->raw_position += 1;
 	}
 
 #if defined(CHECK_SIZE) && !defined(NDEBUG)
-	Assert( cb->size == filelength(fileno(cb->fp)) );
+	Assert( cfile->size == filelength(fileno(cfile->fp)) );
 #endif
 
 	return result;	
@@ -1574,31 +1436,29 @@ int cfputs(const char *str, CFILE *cfile)
 	if(str == NULL)
 		return EOF;
 
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-
-	if(cb->lib_offset != 0)
+	if(cfile->lib_offset != 0)
 	{
 		Error(LOCATION, "Attempt to write character to a VP file (unsupported)");
 		return EOF;
 	}
 
-	if(cb->data != NULL)
+	if(cfile->data != nullptr)
 	{
 		Warning(LOCATION, "Writing is not supported for mem-mapped files");
 		return EOF;
 	}
 
-	int result = fputs(str, cb->fp);
+	int result = fputs(str, cfile->fp);
 
 	//WMC - update filesize and position
 	if(result != EOF)
 	{
-		cb->size += strlen(str);
-		cb->raw_position += strlen(str);
+		cfile->size += strlen(str);
+		cfile->raw_position += strlen(str);
 	}
 
 #if defined(CHECK_SIZE) && !defined(NDEBUG)
-	Assert( cb->size == filelength(fileno(cb->fp)) );
+	Assert( cfile->size == filelength(fileno(cfile->fp)) );
 #endif
 
 	return result;	
@@ -1960,19 +1820,16 @@ int cf_chksum_long(CFILE *file, uint *chksum, int max_size)
 int cflush(CFILE *cfile)
 {
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
 
 	// not supported for memory mapped files
-	Assert( !cb->data );
+	Assert( !cfile->data );
 
-	Assert(cb->fp != NULL);
+	Assert(cfile->fp != nullptr);
 
-	int result = fflush(cb->fp);
+	int result = fflush(cfile->fp);
 
 	//WMC - update filesize
-	cb->size = filelength(fileno(cb->fp));
+	cfile->size = filelength(fileno(cfile->fp));
 
 	return result;
 }

code/cfile/cfile.h

@@ -13,10 +13,11 @@
 #define __CFILE_H__
 
 
-#include <ctime>
 #include "globalincs/pstypes.h"
 
+#include <ctime>
 #include <stdexcept>
+#include <memory>
 
 
 #define CF_EOF (-1)
@@ -25,10 +26,8 @@
 #define CF_SEEK_CUR (1)
 #define CF_SEEK_END (2)
 
-typedef struct CFILE {
-	int		id;			// Index into cfile.cpp specific structure
-	int		version;		// version of this file
-} CFILE;
+// Opaque file handle
+struct CFILE;
 
 // extra info that can be returned when getting a file listing
 typedef struct {
@@ -155,9 +154,6 @@ enum CFileLocationFlags {
 	CF_LOCATION_ALL = CF_LOCATION_ROOT_MASK | CF_LOCATION_TYPE_MASK
 };
 
-#define cfread_fix(file) (fix)cfread_int(file)
-#define cfwrite_fix(i,file) cfwrite_int(i,file)
-
 // callback function used for get_file_list() to filter files to be added to list.  Return 1
 // to add file to list, or 0 to not add it.
 extern int (*Get_file_list_filter)(const char *filename);
@@ -176,11 +172,6 @@ extern char Cfile_user_dir[CFILE_ROOT_DIRECTORY_LEN];
 int cfile_init(const char *exe_dir, const char *cdrom_dir=NULL);
 void cfile_close();
 
-// Call this if pack files got added or removed or the
-// cdrom changed.  This will refresh the list of filenames 
-// stored in packfiles and on the cdrom.
-void cfile_refresh();
-
 // add an extension to a filename if it doesn't already have it
 char *cf_add_ext(const char *filename, const char *ext);
 
@@ -202,10 +193,6 @@ CFILE *_cfopen_special(const char* source_file, int line, const char *file_path,
 // Flush the open file buffer
 int cflush(CFILE *cfile);
 
-// version number of opened file.  Will be 0 unless you put something else here after you
-// open a file.  Once set, you can use minimum version numbers with the read functions.
-void cf_set_version( CFILE * cfile, int version );
-
 // will throw an error if cfread*() functions read past this mark
 // converted to raw offsets when used, but gets passed actual length from current position
 // setting 'len' to zero will disable the check
@@ -246,10 +233,6 @@ int cfread(void *buf, int elsize, int nelem, CFILE *fp);
 // cfwrite() writes to the file
 int cfwrite(const void *buf, int elsize, int nelem, CFILE *cfile);
 
-// Reads/writes RLE compressed data.
-int cfread_compressed(void *buf, int elsize, int nelem, CFILE *cfile);
-int cfwrite_compressed(void *param_buf, int param_elsize, int param_nelem, CFILE *cfile);
-
 // Moves the file pointer
 int cfseek(CFILE *fp, int offset, int where);
 
@@ -301,7 +284,6 @@ uint cf_add_chksum_long(uint seed, ubyte *buffer, size_t size);
 // convenient for misc checksumming purposes ------------------------------------------
 
 //================= HIGH LEVEL FUNCTIONS ==================
-int cfexist(const char *filename);	// Returns true if file exists on disk (1) or in hog (2).
 
 // rename a file, utilizing the extension to determine where file is.
 #define CF_RENAME_SUCCESS				0					// successfully renamed the file
@@ -309,6 +291,10 @@ int cfexist(const char *filename);	// Returns true if file exists on disk (1) or
 #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);
 
@@ -319,17 +305,15 @@ int cfile_flush_dir(int type);
 // functions for reading from cfile
 // These are all high level, built up from
 // cfread.
-int cfgetc(CFILE *fp);
 char *cfgets(char *buf, size_t n, CFILE *fp);
-char cfread_char(CFILE *file, int ver = 0, char deflt = 0);
-ubyte cfread_ubyte(CFILE *file, int ver = 0, ubyte deflt = 0);
-short cfread_short(CFILE *file, int ver = 0, short deflt = 0);
-ushort cfread_ushort(CFILE *file, int ver = 0, ushort deflt = 0);
-int cfread_int(CFILE *file, int ver = 0, int deflt = 0);
-uint cfread_uint(CFILE *file, int ver = 0, uint deflt = 0);
-float cfread_float(CFILE *file, int ver = 0, float deflt = 0.0f);
-void cfread_vector(vec3d *vec, CFILE *file, int ver = 0, vec3d *deflt = NULL);
-void cfread_angles(angles *ang, CFILE *file, int ver = 0, angles *deflt = NULL);
+char cfread_char(CFILE* file, char deflt = 0);
+ubyte cfread_ubyte(CFILE* file, ubyte deflt = 0);
+short cfread_short(CFILE* file, short deflt = 0);
+ushort cfread_ushort(CFILE* file, ushort deflt = 0);
+int cfread_int(CFILE* file, int deflt = 0);
+uint cfread_uint(CFILE* file, uint deflt = 0);
+float cfread_float(CFILE* file, float deflt = 0.0f);
+void cfread_vector(vec3d* vec, CFILE* file, vec3d* deflt = nullptr);
 
 // Reads variable length, null-termined string.   Will only read up
 // to n characters.
@@ -360,8 +344,6 @@ int cfwrite_uint(uint i, CFILE *file);
 int cfwrite_short(short s, CFILE *file);
 int cfwrite_ushort(ushort s, CFILE *file);
 int cfwrite_ubyte(ubyte u, CFILE *file);
-int cfwrite_vector(vec3d *vec, CFILE *file);
-int cfwrite_angles(angles *ang, CFILE *file);
 
 // writes variable length, null-termined string.
 int cfwrite_string(const char *buf, CFILE *file);
@@ -483,4 +465,17 @@ namespace cfile
 
 }
 
+// This allows to use std::unique_ptr with CFILE
+namespace std {
+template <>
+struct default_delete<CFILE> {
+	void operator()(CFILE* ptr)
+	{
+		if (cf_is_valid(ptr)) {
+			cfclose(ptr);
+		}
+	}
+};
+} // namespace std
+
 #endif	/* __CFILE_H__ */

code/cfile/cfilearchive.cpp

@@ -36,24 +36,20 @@
 
 void cf_init_lowlevel_read_code( CFILE * cfile, size_t lib_offset, size_t size, size_t pos )
 {
-	Assert(cfile != NULL);
+	Assert(cfile != nullptr);
 
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
+	cfile->lib_offset = lib_offset;
+	cfile->raw_position = pos;
+	cfile->size = size;
 
-	cb->lib_offset = lib_offset;
-	cb->raw_position = pos;
-	cb->size = size;
-
-	if ( cb->fp )	{
-		if ( cb->lib_offset )	{
-			fseek( cb->fp, (long)cb->lib_offset, SEEK_SET );
+	if ( cfile->fp )	{
+		if ( cfile->lib_offset )	{
+			fseek( cfile->fp, (long)cfile->lib_offset, SEEK_SET );
 		}
 
 		#if defined(CHECK_POSITION) && !defined(NDEBUG)
-		auto raw_position = ftell(cb->fp) - cb->lib_offset;
-		Assert(raw_position == cb->raw_position);
+		auto raw_position = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(raw_position == cfile->raw_position);
 		#endif
 	}
 }
@@ -70,20 +66,16 @@ int cfeof(CFILE *cfile)
 {
 	Assert(cfile != NULL);
 
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
-
 	int result = 0;
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-    if (cb->fp) {
-		auto raw_position = ftell(cb->fp) - cb->lib_offset;
-		Assert(raw_position == cb->raw_position);
+    if (cfile->fp) {
+		auto raw_position = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(raw_position == cfile->raw_position);
 	}
 	#endif
 		
-	if (cb->raw_position >= cb->size ) {
+	if (cfile->raw_position >= cfile->size ) {
 		result = 1;
 	} else {
 		result = 0;
@@ -100,21 +92,18 @@ int cfeof(CFILE *cfile)
 int cftell( CFILE * cfile )
 {
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-    if (cb->fp) {
-		auto raw_position = ftell(cb->fp) - cb->lib_offset;
-		Assert(raw_position == cb->raw_position);
+    if (cfile->fp) {
+		auto raw_position = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(raw_position == cfile->raw_position);
 	}
 	#endif
 
 	// The rest of the code still uses ints, do an overflow check to detect cases where this fails
-	Assertion(cb->raw_position <= static_cast<size_t>(std::numeric_limits<int>::max()),
+	Assertion(cfile->raw_position <= static_cast<size_t>(std::numeric_limits<int>::max()),
 		"Integer overflow in cftell, a file is probably too large (but I don't know which one).");
-	return (int) cb->raw_position;
+	return (int) cfile->raw_position;
 }
 
 
@@ -127,27 +116,23 @@ int cfseek( CFILE *cfile, int offset, int where )
 {
 
 	Assert(cfile != NULL);
-	Cfile_block *cb;
-	Assert(cfile->id >= 0 && cfile->id < MAX_CFILE_BLOCKS);
-	cb = &Cfile_block_list[cfile->id];	
-
 
 	// TODO: seek to offset in memory mapped file
-	Assert( !cb->mem_mapped );
+	Assert( !cfile->mem_mapped );
 	
 	size_t goal_position;
 
 	switch( where )	{
 	case CF_SEEK_SET:
-		goal_position = offset+cb->lib_offset;
+		goal_position = offset+cfile->lib_offset;
 		break;
 	case CF_SEEK_CUR:	
 		{
-			goal_position = cb->raw_position+offset+cb->lib_offset;
+			goal_position = cfile->raw_position+offset+cfile->lib_offset;
 		}
 		break;
 	case CF_SEEK_END:
-		goal_position = cb->size+offset+cb->lib_offset;
+		goal_position = cfile->size+offset+cfile->lib_offset;
 		break;
 	default:
 		Int3();
@@ -155,23 +140,23 @@ int cfseek( CFILE *cfile, int offset, int where )
 	}
 
 	// Make sure we don't seek beyond the end of the file
-	CAP(goal_position, cb->lib_offset, cb->lib_offset + cb->size);
+	CAP(goal_position, cfile->lib_offset, cfile->lib_offset + cfile->size);
 
 	int result = 0;
 
-	if (cb->fp) {
+	if (cfile->fp) {
 		// If we have a file pointer we can also seek in that file
-		result = fseek(cb->fp, (long)goal_position, SEEK_SET );
-		Assertion(goal_position >= cb->lib_offset, "Invalid offset values detected while seeking! Goal was " SIZE_T_ARG ", lib_offset is " SIZE_T_ARG ".", goal_position, cb->lib_offset);
+		result = fseek(cfile->fp, (long)goal_position, SEEK_SET );
+		Assertion(goal_position >= cfile->lib_offset, "Invalid offset values detected while seeking! Goal was " SIZE_T_ARG ", lib_offset is " SIZE_T_ARG ".", goal_position, cfile->lib_offset);
 	}
 	// If we only have a data pointer this will do all the work
-	cb->raw_position = goal_position - cb->lib_offset;
-	Assertion(cb->raw_position <= cb->size, "Invalid raw_position value detected!");
+	cfile->raw_position = goal_position - cfile->lib_offset;
+	Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-	if (cb->fp) {
-		auto tmp_offset = ftell(cb->fp) - cb->lib_offset;
-		Assert(tmp_offset == cb->raw_position);
+	if (cfile->fp) {
+		auto tmp_offset = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(tmp_offset == cfile->raw_position);
 	}
 	#endif
 
@@ -194,19 +179,17 @@ int cfread(void *buf, int elsize, int nelem, CFILE *cfile)
 	if(buf == NULL || size <= 0)
 		return 0;
 
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-
-	if ( (cb->raw_position+size) > cb->size ) {
-		Assertion(cb->raw_position <= cb->size, "Invalid raw_position value detected!");
-		size = cb->size - cb->raw_position;
+	if ( (cfile->raw_position+size) > cfile->size ) {
+		Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
+		size = cfile->size - cfile->raw_position;
 		if ( size < 1 ) {
 			return 0;
 		}
 		//mprintf(( "CFILE: EOF encountered in file\n" ));
 	}
 
-	if (cb->max_read_len) {
-		if ( cb->raw_position+size > cb->max_read_len ) {
+	if (cfile->max_read_len) {
+		if ( cfile->raw_position+size > cfile->max_read_len ) {
 			std::ostringstream s_buf;
 			s_buf << "Attempted to read " << size << "-byte(s) beyond length limit";
 
@@ -215,22 +198,22 @@ int cfread(void *buf, int elsize, int nelem, CFILE *cfile)
 	}
 
 	size_t bytes_read;
-	if (cb->data != nullptr) {
+	if (cfile->data != nullptr) {
 		// This is a file from memory
 		bytes_read = size;
-		memcpy(buf, reinterpret_cast<const char*>(cb->data) + cb->raw_position, size);
+		memcpy(buf, reinterpret_cast<const char*>(cfile->data) + cfile->raw_position, size);
 	} else {
-		bytes_read = fread( buf, 1, size, cb->fp );
+		bytes_read = fread( buf, 1, size, cfile->fp );
 	}
 	if ( bytes_read > 0 )	{
-		cb->raw_position += bytes_read;
-		Assertion(cb->raw_position <= cb->size, "Invalid raw_position value detected!");
+		cfile->raw_position += bytes_read;
+		Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
 	}		
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-    if (cb->fp) {
-		auto tmp_offset = ftell(cb->fp) - cb->lib_offset;
-		Assert(tmp_offset==cb->raw_position);
+    if (cfile->fp) {
+		auto tmp_offset = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(tmp_offset==cfile->raw_position);
 	}
 	#endif
 
@@ -246,10 +229,8 @@ int cfread_lua_number(double *buf, CFILE *cfile)
 	if(buf == NULL)
 		return 0;
 
-	Cfile_block *cb = &Cfile_block_list[cfile->id];	
-
 	// cfread() not supported for memory-mapped files
-	if(cb->data != NULL)
+	if(cfile->data != nullptr)
 	{
 		Warning(LOCATION, "Writing is not supported for mem-mapped files");
 		return 0;
@@ -257,28 +238,28 @@ int cfread_lua_number(double *buf, CFILE *cfile)
 
 	size_t advance = 0;
 	int items_read;
-	if (cb->fp) {
-		long orig_pos = ftell(cb->fp);
-		items_read = fscanf(cb->fp, LUA_NUMBER_SCAN, buf);
-		advance = (size_t) (ftell(cb->fp)-orig_pos);
+	if (cfile->fp) {
+		long orig_pos = ftell(cfile->fp);
+		items_read = fscanf(cfile->fp, LUA_NUMBER_SCAN, buf);
+		advance = (size_t) (ftell(cfile->fp)-orig_pos);
 	} else {
 		int read;
 		// %n returns the number of bytes currently read so we append that to the scan format at the end so it will return
 		// how many bytes we have consumed
-		items_read = sscanf(reinterpret_cast<const char*>(cb->data), LUA_NUMBER_SCAN "%n", buf, &read);
+		items_read = sscanf(reinterpret_cast<const char*>(cfile->data), LUA_NUMBER_SCAN "%n", buf, &read);
 		if (items_read == 2) {
 			// We need to correct the items read counter since we read one additional item
 			items_read = 1;
 		}
 		advance = (size_t) read;
 	}
-	cb->raw_position += advance;
-	Assertion(cb->raw_position <= cb->size, "Invalid raw_position value detected!");
+	cfile->raw_position += advance;
+	Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-    if (cb->fp) {
-		auto tmp_offset = ftell(cb->fp) - cb->lib_offset;
-		Assert(tmp_offset==cb->raw_position);
+    if (cfile->fp) {
+		auto tmp_offset = ftell(cfile->fp) - cfile->lib_offset;
+		Assert(tmp_offset==cfile->raw_position);
 	}
 	#endif
 

code/cfile/cfilearchive.h

@@ -22,31 +22,30 @@
 #define CFILE_BLOCK_UNUSED		0
 #define CFILE_BLOCK_USED		1
 
-typedef struct Cfile_block {
-	int		type;				// CFILE_BLOCK_UNUSED, CFILE_BLOCK_USED
-	int		dir_type;		// directory location
-	FILE		*fp;				// File pointer if opening an individual file
-	const void	*data;			// Pointer for memory-mapped file access.  NULL if not mem-mapped.
-	bool 	mem_mapped;		// Flag for memory mapped files (if data is not null and this is false it means that it's an embedded file)
+struct CFILE {
+	int type = CFILE_BLOCK_UNUSED;                // CFILE_BLOCK_UNUSED, CFILE_BLOCK_USED
+	int dir_type;        // directory location
+	FILE* fp;                // File pointer if opening an individual file
+	const void* data;            // Pointer for memory-mapped file access.  NULL if not mem-mapped.
+	bool mem_mapped; // Flag for memory mapped files (if data is not null and this is false it means that it's an embedded file)
 #ifdef _WIN32
 	HANDLE	hInFile;			// Handle from CreateFile()
 	HANDLE	hMapFile;		// Handle from CreateFileMapping()
 #else
-//	int		fd;				// file descriptor
-	size_t	data_length;	// length of data for mmap
+	size_t data_length;    // length of data for mmap
 #endif
-	size_t	lib_offset;
-	size_t	raw_position;
-	size_t	size;				// for packed files
+	size_t lib_offset;
+	size_t raw_position;
+	size_t size;                // for packed files
+
+	size_t max_read_len;    // max read offset, for special error handling
 
-	size_t	max_read_len;	// max read offset, for special error handling
-	
 	const char* source_file;
 	int line_num;
-} Cfile_block;
+};
 
 #define MAX_CFILE_BLOCKS	64
-extern Cfile_block Cfile_block_list[MAX_CFILE_BLOCKS];
+extern std::array<CFILE, MAX_CFILE_BLOCKS> Cfile_block_list;
 
 // Called once to setup the low-level reading code.
 void cf_init_lowlevel_read_code( CFILE * cfile, size_t lib_offset, size_t size, size_t pos );

code/cfile/cfilelist.cpp

@@ -200,353 +200,4 @@ void cf_sort_filenames( int n, char **list, int sort, file_list_info *info )
 	}
 
 	nprintf(("Error", "Unknown sorting method %d passed to cf_sort_filenames()\n", sort));
-}
-
-
-#if (0) // these aren't used anywhere now
-
-//	cf_compress - Do Run Length Compression on a block of data. Targa format.
-//
-//	Usage:
-//				out			Buffer to write it out to
-//				in				Buffer to compress
-//				bytecount	Number of bytes input
-int cf_compress(char *out, char *in, int bytecount )
-{
-	int pixcount;		// number of pixels in the current packet
-	char *inputpixel=NULL;	// current input pixel position
-	char *matchpixel=NULL;	// pixel value to match for a run
-	char *flagbyte=NULL;		// location of last flag byte to set
-	int rlcount;		// current count in r.l. string 
-	int rlthresh;		// minimum valid run length
-	char *copyloc;		// location to begin copying at
-
-	// set the threshold -- the minimum valid run length
-	rlthresh = 2;					// Require a 2 pixel span before rle'ing
-	
-	// set the first pixel up
-
-	flagbyte = out;	// place to put next flag if run
-	inputpixel = in;
-	pixcount = 1;
-	rlcount = 0;
-	copyloc = (char *)0;
-
-	// loop till data processing complete
-	do	{
-
-		// if we have accumulated a 128-byte packet, process it
-		if ( pixcount == 129 )	{
-			*flagbyte = 127;
-
-			// set the run flag if this is a run
-
-			if ( rlcount >= rlthresh )	{
-					*flagbyte |= 0x80;
-					pixcount = 2;
-			}
-
-			// copy the data into place
-			++flagbyte;
-			memmove( flagbyte, copyloc, pixcount-1 );
-			flagbyte += pixcount-1;
-			pixcount = 1;
-
-			// set up for next packet
-			continue;
-		}
-
-		// if zeroth byte, handle as special case
-		if ( pixcount == 1 )	{
-			rlcount = 0;
-			copyloc = inputpixel;		/* point to 1st guy in packet */
-			matchpixel = inputpixel;	/* set pointer to pix to match */
-			pixcount = 2;
-			inputpixel += 1;
-			continue;
-		}
-
-		// assembling a packet -- look at next pixel
-
-		// current pixel == match pixel?
-		if ( *inputpixel == *matchpixel )	{
-
-			//	establishing a run of enough length to
-			//	save space by doing it
-			//		-- write the non-run length packet
-			//		-- start run-length packet
-
-			if ( ++rlcount == rlthresh )	{
-				
-				//	close a non-run packet
-				
-				if ( pixcount > (rlcount+1) )	{
-					// write out length and do not set run flag
-
-					*flagbyte++ = (char)(pixcount - 2 - rlthresh);
-
-					memmove(flagbyte, copyloc, (pixcount-1-rlcount) );
-					flagbyte += (pixcount-1-rlcount);
-
-					copyloc = inputpixel;
-					pixcount = rlcount + 1;
-				}
-			}
-		} else {
-
-			// no match -- either break a run or continue without one
-			//	if a run exists break it:
-			//		write the bytes in the string (1+1)
-			//		start the next string
-
-			if ( rlcount >= rlthresh )	{
-
-				*flagbyte++ = (char)(0x80 | rlcount);
-				memmove(flagbyte, copyloc, 1 );
-				flagbyte += 1;
-				pixcount = 1;
-				continue;
-			} else {
-
-				//	not a match and currently not a run
-				//		- save the current pixel
-				//		- reset the run-length flag
-				rlcount = 0;
-				matchpixel = inputpixel;
-			}
-		}
-		pixcount++;
-		inputpixel += 1;
-	} while ( inputpixel < (in + bytecount));
-
-	// quit this buffer without loosing any data
-	if ( --pixcount >= 1 )	{
-		*flagbyte = (char)(pixcount - 1);
-		if ( rlcount >= rlthresh )	{
-			*flagbyte |= 0x80;
-			pixcount = 1;
-		}
-
-		// copy the data into place
-		++flagbyte;
-		memmove(flagbyte, copyloc, pixcount );
-		flagbyte += pixcount;
-	}
-	return(flagbyte-out);
-}
-
-
-//	cf_decompress - Do Decompression on a run-length encoded block of data. Targa format.
-//
-//	Usage:
-//				out			Buffer to write it out to
-//				in				Buffer to compress
-//				bytecount	Number of bytes input
-int cf_decompress(char *out, char *in )
-{
-	int count;
-
-	char *param_out = out;
-
-	while(1)	{
-	
-		count = int(*in++);
-		int run_span = count & 0x80;
-
-		count &= (~0x80);
-
-		if ( count > 0 )	{
-			if ( run_span )	{
-				// RLE'd data
-				ubyte c = *in++;
-
-				memset( out, c, count );
-				out += count;
-			} else {
-				memmove( out, in, count );
-				in += count;
-				out += count;
-			}
-		}
-	}
-
-	return out - param_out;
-			
-}
-
-#endif // 0
-
-
-// cfread() reads from a file and decompresses it
-//
-// returns:   returns the number of full elements read
-//            
-//
-int cfread_compressed(void *buf, int elsize, int nelem, CFILE *cfile)
-{
-	char *out = (char *)buf;
-	
-	while(1)	{
-
-		ubyte count;
-
-		if ( cfread( &count, 1, 1, cfile ) != 1 )	{
-			break;
-		}
-
-		int run_span = count & 0x80;
-		count &= (~0x80);
-		count++;
-
-		if ( count > 0 )	{
-			if ( run_span )	{
-				// RLE'd data
-				ubyte c;
-				if ( cfread( &c, 1, 1, cfile ) != 1 )	{
-					break;
-				}
-				memset( out, c, count );
-			} else {
-				if ( cfread( out, 1, count, cfile ) != count )	{
-					break;
-				}
-			}
-			out += count;
-			if ( out >= (char *)buf + (elsize*nelem))	{
-				break;
-			}
-		} else {
-			break;
-		}
-	}
-
-	return (int)((out - (char *)buf)/elsize);
-}
-
-int cfwrite_compressed(void *param_buf, int param_elsize, int param_nelem, CFILE *cfile)
-{
-	char *in = (char *)param_buf;
-	int bytecount = (param_elsize * param_nelem );
-
-	int pixcount;		// number of pixels in the current packet
-	char *inputpixel=NULL;	// current input pixel position
-	char *matchpixel=NULL;	// pixel value to match for a run
-	int rlcount;		// current count in r.l. string 
-	int rlthresh;		// minimum valid run length
-	char *copyloc;		// location to begin copying at
-
-	// set the threshold -- the minimum valid run length
-	rlthresh = 2;					// Require a 2 pixel span before rle'ing
-	
-	// set the first pixel up
-
-	inputpixel = in;
-	pixcount = 1;
-	rlcount = 0;
-	copyloc = (char *)0;
-
-	// loop till data processing complete
-	do	{
-
-		// if we have accumulated a 128-byte packet, process it
-		if ( pixcount == 129 )	{
-			ubyte code = 127;
-
-			// set the run flag if this is a run
-
-			if ( rlcount >= rlthresh )	{
-					code |= 0x80;
-					pixcount = 2;
-			}
-
-			cfwrite( &code, 1, 1, cfile );
-
-			// copy the data into place
-			cfwrite( copyloc, 1, pixcount-1, cfile );
-			pixcount = 1;
-
-			// set up for next packet
-			continue;
-		}
-
-		// if zeroth byte, handle as special case
-		if ( pixcount == 1 )	{
-			rlcount = 0;
-			copyloc = inputpixel;		/* point to 1st guy in packet */
-			matchpixel = inputpixel;	/* set pointer to pix to match */
-			pixcount = 2;
-			inputpixel += 1;
-			continue;
-		}
-
-		// assembling a packet -- look at next pixel
-
-		// current pixel == match pixel?
-		if ( *inputpixel == *matchpixel )	{
-
-			//	establishing a run of enough length to
-			//	save space by doing it
-			//		-- write the non-run length packet
-			//		-- start run-length packet
-
-			if ( ++rlcount == rlthresh )	{
-				
-				//	close a non-run packet
-				
-				if ( pixcount > (rlcount+1) )	{
-					// write out length and do not set run flag
-
-					ubyte code = (ubyte)(pixcount - 2 - rlthresh);
-					cfwrite( &code, 1, 1, cfile );
-
-					cfwrite( copyloc, 1, (pixcount-1-rlcount), cfile );
-					copyloc = inputpixel;
-					pixcount = rlcount + 1;
-				}
-			}
-		} else {
-
-			// no match -- either break a run or continue without one
-			//	if a run exists break it:
-			//		write the bytes in the string (1+1)
-			//		start the next string
-
-			if ( rlcount >= rlthresh )	{
-
-				ubyte code = (ubyte)(0x80 | rlcount);
-				cfwrite( &code, 1, 1, cfile );
-				cfwrite( copyloc, 1, 1, cfile );
-				pixcount = 1;
-				continue;
-			} else {
-
-				//	not a match and currently not a run
-				//		- save the current pixel
-				//		- reset the run-length flag
-				rlcount = 0;
-				matchpixel = inputpixel;
-			}
-		}
-		pixcount++;
-		inputpixel += 1;
-	} while ( inputpixel < (in + bytecount));
-
-	// quit this buffer without loosing any data
-	if ( --pixcount >= 1 )	{
-		ubyte code = ubyte(pixcount - 1);
-
-		// set the run flag if this is a run
-
-		if ( rlcount >= rlthresh )	{
-				code |= 0x80;
-				pixcount = 1;
-		}
-
-		cfwrite( &code, 1, 1, cfile );
-
-		// copy the data into place
-		cfwrite( copyloc, 1, pixcount, cfile );
-	}
-
-	return param_nelem;
-}
+}

code/cfile/cfilesystem.cpp

@@ -556,17 +556,40 @@ 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 ));
+	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
 
 	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) ) {
@@ -1556,6 +1579,9 @@ 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)
 {
@@ -1678,6 +1704,10 @@ 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;
@@ -1743,7 +1773,6 @@ 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 );
 	}

code/cmdline/cmdline.cpp

@@ -5,27 +5,27 @@
  * or otherwise commercially exploit the source or things you created based on the 
  * source.
  *
-*/ 
+*/
 
-
-
-#include "camera/camera.h" //VIEWER_ZOOM_DEFAULT
 #include "cmdline/cmdline.h"
+#include "camera/camera.h" //VIEWER_ZOOM_DEFAULT
+#include "cfile/cfilesystem.h"
+#include "fireball/fireballs.h"
 #include "globalincs/linklist.h"
 #include "globalincs/pstypes.h"
 #include "globalincs/systemvars.h"
 #include "globalincs/version.h"
+#include "graphics/shadows.h"
 #include "hud/hudconfig.h"
-#include "network/multi.h"
-#include "scripting/scripting.h"
-#include "parse/sexp.h"
-#include "globalincs/version.h"
-#include "globalincs/pstypes.h"
-#include "osapi/osapi.h"
-#include "cfile/cfilesystem.h"
-#include "sound/speech.h"
-#include "sound/openal.h"
 #include "io/joy.h"
+#include "network/multi.h"
+#include "options/OptionsManager.h"
+#include "osapi/osapi.h"
+#include "parse/sexp.h"
+#include "scripting/scripting.h"
+#include "sound/openal.h"
+#include "sound/speech.h"
+#include "starfield/starfield.h"
 
 #ifdef _WIN32
 #include <io.h>
@@ -82,8 +82,8 @@ public:
 	int name_found;				// true if parameter on command line, otherwise false
 	const int arg_type;					// from enum cmdline_arg_type; used for help
 
-	cmdline_parm(const char *name, const char *help, const int arg_type, const bool stacks = false);
-	~cmdline_parm();
+	cmdline_parm(const char *name, const char *help, const int arg_type, const bool stacks = false) noexcept;
+	~cmdline_parm() noexcept;
 	int found();
 	int get_int();
 	float get_float();
@@ -100,17 +100,13 @@ extern int Show_framerate;	// from freespace.cpp
 enum
 {
 	// DO NOT CHANGE ANYTHING ABOUT THESE FIRST TWO OR WILL MESS UP THE LAUNCHER
-	EASY_DEFAULT  =  1 << 1,
-	EASY_ALL_ON   =  1 << 2,
+	EASY_DEFAULT  =  1 << 1,		// Default FS2 (All features off)
+	EASY_ALL_ON   =  1 << 2,		// All features on
 
-	EASY_MEM_ON   =  1 << 3,
-	EASY_MEM_OFF  =  1 << 4,
+	EASY_HI_MEM_ON   =  1 << 3,		// High memory usage features on
+	EASY_HI_MEM_OFF  =  1 << 4,		// High memory usage features off
 
 	// Add new flags here
-
-	// Combos
-	EASY_MEM_ALL_ON  = EASY_ALL_ON  | EASY_MEM_ON,
-	EASY_DEFAULT_MEM = EASY_DEFAULT | EASY_MEM_OFF
 };
 
 enum BuildCaps
@@ -122,6 +118,7 @@ enum BuildCaps
 };
 
 #define PARSE_COMMAND_LINE_STRING	"-parse_cmdline_only"
+#define GET_FLAGS_STRING			"-get_flags"
 
 typedef struct
 {
@@ -145,111 +142,116 @@ typedef struct
 	char  name[20];		// The actual flag
 	char  desc[40];		// The text that will appear in the launcher (unless its blank, other name is shown)
 	bool  fso_only;		// true if this is a fs2_open only feature
-	int   on_flags;		// Easy flag which will turn this feature on
-	int   off_flags;	// Easy flag which will turn this feature off
+	int   on_flags;		// "Easy setting" which will turn this option on
+	int   off_flags;	// "Easy setting" which will turn this option off
 	char  type[16];		// Launcher uses this to put flags under different headings
 	char  web_url[256];	// Link to documentation of feature (please use wiki or somewhere constant)
 
 } Flag;
 
+// clang-format off
 // Please group them by type, ie graphics, gameplay etc, maximum 20 different types
 Flag exe_params[] = 
 {
-	{ "-nospec",			"Disable specular",							true,	EASY_DEFAULT_MEM,	EASY_MEM_ALL_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-spec", },
-	{ "-noglow",			"Disable glow maps",						true,	EASY_DEFAULT_MEM,	EASY_MEM_ALL_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-glow", },
-	{ "-noenv",				"Disable environment maps",					true,	EASY_DEFAULT_MEM,	EASY_MEM_ALL_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-env", },
-	{ "-nomotiondebris",	"Disable motion debris",					true,	EASY_ALL_ON,		EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomotiondebris",},
-	{ "-noscalevid",		"Disable scale-to-window for movies",		true,	0,					EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noscalevid", },
-	{ "-nonormal",			"Disable normal maps",						true,	EASY_DEFAULT_MEM,	EASY_MEM_ALL_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-normal" },
-	{ "-no_emissive_light",	"Disable emissive light from ships",		true,	0,					EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_emissive_light" },
-	{ "-noheight",			"Disable height/parallax maps",				true,	EASY_DEFAULT_MEM,	EASY_MEM_ALL_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-height" },
-	{ "-3dshockwave",		"Enable 3D shockwaves",						true,	EASY_MEM_ALL_ON,	EASY_DEFAULT_MEM,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-3dshockwave" },
-	{ "-post_process",		"Enable post processing",					true,	EASY_ALL_ON,		EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-post_process" },
-	{ "-soft_particles",	"Enable soft particles",					true,	EASY_ALL_ON,		EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-soft_particles" },
-	{ "-fxaa",				"Enable FXAA anti-aliasing",				true,	EASY_MEM_ALL_ON,	EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fxaa" },
-	{ "-nolightshafts",		"Disable lightshafts",						true,	EASY_DEFAULT,		EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-flightshaftsoff"},
-	{ "-fb_explosions",		"Enable Framebuffer Shockwaves",			true,	EASY_ALL_ON,		EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fb_explosions", },
-    { "-fb_thrusters",      "Enable Framebuffer Thrusters",             true,   EASY_ALL_ON,        EASY_DEFAULT,       "Graphics",     "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fb_thrusters", },
-	{ "-no_deferred",		"Disable Deferred Lighting",				true,	EASY_DEFAULT_MEM,	EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_deferred"},
-	{ "-enable_shadows",	"Enable Shadows",							true,	EASY_MEM_ALL_ON,	EASY_DEFAULT,		"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_shadows"},
-	{ "-no_vsync",			"Disable vertical sync",					true,	0,					EASY_DEFAULT,		"Game Speed",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_vsync", },
+	{ "-nospec",			"Disable specular",							true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON  | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nospec", },
+	{ "-noglow",			"Disable glow maps",						true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON  | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noglow", },
+	{ "-noenv",				"Disable environment maps",					true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON  | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noenv", },
+	{ "-nonormal",			"Disable normal maps",						true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON  | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nonormal" },
+	{ "-emissive_light",	"Enable emissive light from ships",			true,	0,									EASY_DEFAULT,					"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-emissive_light" },
+	{ "-noheight",			"Disable height/parallax maps",				true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON  | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noheight" },
+	{ "-3dshockwave",		"Enable 3D shockwaves",						true,	EASY_ALL_ON  | EASY_HI_MEM_ON,		EASY_DEFAULT | EASY_HI_MEM_OFF,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-3dshockwave" },
+	{ "-no_post_process",	"Disable post-processing",					true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_post_process" },
+	{ "-soft_particles",	"Enable soft particles",					true,	EASY_ALL_ON,						EASY_DEFAULT,					"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-soft_particles" },
+	{ "-aa",				"Enable Post-process anti-aliasing",		true,	EASY_ALL_ON  | EASY_HI_MEM_ON,		EASY_DEFAULT | EASY_HI_MEM_OFF,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-aa" },
+	{ "-nolightshafts",		"Disable lightshafts",						true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nolightshafts"},
+	{ "-fb_explosions",		"Enable Framebuffer Shockwaves",			true,	EASY_ALL_ON,						EASY_DEFAULT,					"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fb_explosions", },
+    { "-fb_thrusters",      "Enable Framebuffer Thrusters",             true,   EASY_ALL_ON,						EASY_DEFAULT,					"Graphics",     "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fb_thrusters", },
+	{ "-no_deferred",		"Disable Deferred Lighting",				true,	EASY_DEFAULT | EASY_HI_MEM_OFF,		EASY_ALL_ON | EASY_HI_MEM_ON,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_deferred"},
+	{ "-enable_shadows",	"Enable Shadows",							true,	EASY_ALL_ON  | EASY_HI_MEM_ON,		EASY_DEFAULT | EASY_HI_MEM_OFF,	"Graphics",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-enable_shadows"},
 
-	{ "-dualscanlines",		"Add another pair of scanning lines",		true,	0,					EASY_DEFAULT,		"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dualscanlines", },
-	{ "-targetinfo",		"Enable info next to target",				true,	0,					EASY_DEFAULT,		"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-targetinfo", },
-	{ "-orbradar",			"Enable 3D radar",							true,	0,					EASY_DEFAULT,		"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-orbradar", },
-	{ "-rearm_timer",		"Enable rearm/repair completion timer",		true,	0,					EASY_DEFAULT,		"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-rearm_timer", },
-	{ "-ballistic_gauge",	"Enable analog ballistic ammo gauge",		true,	0,					EASY_DEFAULT,		"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ballistic_gauge", },
+	{ "-no_vsync",			"Disable vertical sync",					true,	0,									EASY_DEFAULT,					"Game Speed",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_vsync", },
 
-	{ "-ship_choice_3d",	"Use 3D models for ship selection",			true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ship_choice_3d", },
-	{ "-weapon_choice_3d",	"Use 3D models for weapon selection",		true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-weapon_choice_3d", },
-	{ "-3dwarp",			"Enable 3D warp",							true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-3dwarp", },
-	{ "-warp_flash",		"Enable flash upon warp",					true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-warp_flash", },
-	{ "-no_ap_interrupt",	"Disable interrupting autopilot",			true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_ap_interrupt", },
-	{ "-stretch_menu",		"Stretch interface to fill screen",			true,	0,					EASY_DEFAULT,		"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-stretch_menu", },
+	{ "-fps",				"Show frames per second on HUD",			false,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fps", },
+	{ "-dualscanlines",		"Add another pair of scanning lines",		true,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dualscanlines", },
+	{ "-targetinfo",		"Enable info next to target",				true,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-targetinfo", },
+	{ "-orbradar",			"Enable 3D radar",							true,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-orbradar", },
+	{ "-rearm_timer",		"Enable rearm/repair completion timer",		true,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-rearm_timer", },
+	{ "-ballistic_gauge",	"Enable analog ballistic ammo gauge",		true,	0,									EASY_DEFAULT,					"HUD",			"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ballistic_gauge", },
 
-	{ "-nosound",			"Disable all sound",						false,	0,					EASY_DEFAULT,		"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nosound", },
-	{ "-nomusic",			"Disable music",							false,	0,					EASY_DEFAULT,		"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomusic", },
-	{ "-no_enhanced_sound",	"Disable enhanced sound",					false,	0,					EASY_DEFAULT,		"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_enhanced_sound", },
+	{ "-window",			"Run in window",							true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-window", },
+	{ "-fullscreen_window",	"Run in fullscreen window",					false,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fullscreen_window", },
+	{ "-stretch_menu",		"Stretch interface to fill screen",			true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-stretch_menu", },
+	{ "-noscalevid",		"Disable scale-to-window for movies",		true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noscalevid", },
+	{ "-nomotiondebris",	"Disable motion debris",					true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomotiondebris",},
+	{ "-ship_choice_3d",	"Use 3D models for ship selection",			true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ship_choice_3d", },
+	{ "-weapon_choice_3d",	"Use 3D models for weapon selection",		true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-weapon_choice_3d", },
+	{ "-3dwarp",			"Enable 3D warp",							true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-3dwarp", },
+	{ "-warp_flash",		"Enable flash upon warp",					true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-warp_flash", },
+	{ "-no_ap_interrupt",	"Disable interrupting autopilot",			true,	0,									EASY_DEFAULT,					"Gameplay",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_ap_interrupt", },
 
-	{ "-portable_mode",		"Store config in portable location",		false,	0,					EASY_DEFAULT,		"Launcher",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-portable_mode", },
+	{ "-nosound",			"Disable all sound",						false,	0,									EASY_DEFAULT,					"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nosound", },
+	{ "-nomusic",			"Disable music",							false,	0,									EASY_DEFAULT,					"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomusic", },
+	{ "-no_enhanced_sound",	"Disable enhanced sound",					false,	0,									EASY_DEFAULT,					"Audio",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_enhanced_sound", },
 
-	{ "-standalone",		"Run as standalone server",					false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-standalone", },
-	{ "-startgame",			"Skip mainhall and start hosting",			false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-startgame", },
-	{ "-closed",			"Start hosted server as closed",			false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-closed", },
-	{ "-restricted",		"Host confirms join requests",				false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-restricted", },
-	{ "-multilog",			"",											false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-multilog", },
-	{ "-clientdamage",		"",											false,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-clientdamage", },
-	{ "-mpnoreturn",		"Disable flight deck option",				true,	0,					EASY_DEFAULT,		"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-mpnoreturn", },
+	{ "-portable_mode",		"Store config in portable location",		false,	0,									EASY_DEFAULT,					"Launcher",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-portable_mode", },
 
-	{ "-no_set_gamma",		"Disable setting of gamma",					true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_set_gamma", },
-	{ "-nomovies",			"Disable video playback",					true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomovies", },
-	{ "-noparseerrors",		"Disable parsing errors",					true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noparseerrors", },
-	{ "-query_speech",		"Check if this build has speech",			true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-query_speech", },
-	{ "-loadallweps",		"Load all weapons, even those not used",	true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-loadallweps", },
-	{ "-disable_fbo",		"Disable OpenGL RenderTargets",				true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-disable_fbo", },
-	{ "-disable_pbo",		"Disable OpenGL Pixel Buffer Objects",		true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-disable_pbo", },
-	{ "-ati_swap",			"Fix colour issues on some ATI cards",		true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ati_swap", },
-	{ "-no_3d_sound",		"Use only 2D/stereo for sound effects",		true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_3d_sound", },
-	{ "-mipmap",			"Enable mipmapping",						true,	0,					EASY_DEFAULT_MEM,	"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-mipmap", },
-	{ "-use_gldrawelements","Don't use glDrawRangeElements",			true,	0,					EASY_DEFAULT,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-use_gldrawelements", },
-	{ "-old_collision",		"Use old collision detection system",		true,	EASY_DEFAULT,		EASY_ALL_ON,		"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-old_collision", },
-	{ "-gl_finish",			"Fix input lag on some ATI+Linux systems",	true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-gl_finish", },
-	{ "-no_geo_effects",	"Disable geometry shader for effects",		true,	0,					EASY_DEFAULT,		"Troubleshoot", "", },
-	{ "-set_cpu_affinity",	"Sets processor affinity to config value",	true,	0,					EASY_DEFAULT,		"Troubleshoot", "", },
-	{ "-nograb",			"Disables mouse grabbing",					true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nograb", },
-	{ "-noshadercache",		"Disables the shader cache",				true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noshadercache", },
+	{ "-standalone",		"Run as standalone server",					false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-standalone", },
+	{ "-startgame",			"Skip mainhall and start hosting",			false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-startgame", },
+	{ "-closed",			"Start hosted server as closed",			false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-closed", },
+	{ "-restricted",		"Host confirms join requests",				false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-restricted", },
+	{ "-multilog",			"",											false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-multilog", },
+	{ "-clientdamage",		"",											false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-clientdamage", },
+	{ "-mpnoreturn",		"Disable flight deck option",				true,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-mpnoreturn", },
+	{ "-gateway_ip",		"Set gateway IP address",					false,	0,									EASY_DEFAULT,					"Multiplayer",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-gateway_ip", },
+
+	{ "-no_set_gamma",		"Disable setting of gamma",					true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_set_gamma", },
+	{ "-nomovies",			"Disable video playback",					true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nomovies", },
+	{ "-noparseerrors",		"Disable parsing errors",					true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noparseerrors", },
+	{ "-loadallweps",		"Load all weapons, even those not used",	true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-loadallweps", },
+	{ "-disable_fbo",		"Disable OpenGL RenderTargets",				true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-disable_fbo", },
+	{ "-disable_pbo",		"Disable OpenGL Pixel Buffer Objects",		true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-disable_pbo", },
+	{ "-ati_swap",			"Fix colour issues on some ATI cards",		true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ati_swap", },
+	{ "-no_3d_sound",		"Use only 2D/stereo for sound effects",		true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_3d_sound", },
+	{ "-mipmap",			"Enable mipmapping",						true,	0,									EASY_DEFAULT | EASY_HI_MEM_OFF,	"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-mipmap", },
+	{ "-use_gldrawelements","Don't use glDrawRangeElements",			true,	0,									EASY_DEFAULT,					"Troubleshoot",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-use_gldrawelements", },
+	{ "-gl_finish",			"Fix input lag on some ATI+Linux systems",	true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-gl_finish", },
+	{ "-no_geo_effects",	"Disable geometry shader for effects",		true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_geo_effects", },
+	{ "-set_cpu_affinity",	"Sets processor affinity to config value",	true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-set_cpu_affinity", },
+	{ "-nograb",			"Disables mouse grabbing",					true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nograb", },
+	{ "-noshadercache",		"Disables the shader cache",				true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noshadercache", },
 #ifdef WIN32
-	{ "-fix_registry",	"Use a different registry path",			true,		0,					EASY_DEFAULT,		"Troubleshoot", "", },
+	{ "-fix_registry",	"Use a different registry path",				true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fix_registry", },
 #endif
 
-	{ "-ingame_join",		"Allow in-game joining",					true,	0,					EASY_DEFAULT,		"Experimental",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ingame_join", },
-	{ "-voicer",			"Enable voice recognition",					true,	0,					EASY_DEFAULT,		"Experimental",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-voicer", },
+	{ "-ingame_join",		"Allow in-game joining",					true,	0,									EASY_DEFAULT,					"Experimental",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-ingame_join", },
+	{ "-voicer",			"Enable voice recognition",					true,	0,									EASY_DEFAULT,					"Experimental",	"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-voicer", },
 
-	{ "-fps",				"Show frames per second on HUD",			false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fps", },
-	{ "-bmpmanusage",		"Show how many BMPMAN slots are in use",	false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-bmpmanusage", },
-	{ "-pos",				"Show position of camera",					false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-pos", },
-	{ "-window",			"Run in window",							true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-window", },
-	{ "-fullscreen_window",	"Run in fullscreen window",					false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-fullscreen_window", },
-	{ "-stats",				"Show statistics",							true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-stats", },
-	{ "-coords",			"Show coordinates",							false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-coords", },
-	{ "-pofspew",			"Generate all ibx files immediately",		false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-pofspew", },
-	{ "-tablecrcs",			"Dump table CRCs for multi validation",		true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-tablecrcs", },
-	{ "-missioncrcs",		"Dump mission CRCs for multi validation",	true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-missioncrcs", },
-	{ "-dis_collisions",	"Disable collisions",						true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dis_collisions", },
-	{ "-dis_weapons",		"Disable weapon rendering",					true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dis_weapons", },
-	{ "-output_sexps",		"Output SEXPs to sexps.html",				true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-output_sexps", },
-	{ "-output_scripting",	"Output scripting to scripting.html",		true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-output_scripting", },
-	{ "-save_render_target",	"Save render targets to file",			true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-save_render_target", },
-	{ "-verify_vps",		"Spew VP CRCs to vp_crcs.txt",				true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-verify_vps", },
-	{ "-reparse_mainhall",	"Reparse mainhall.tbl when loading halls",	false,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-reparse_mainhall", },
-	{ "-profile_write_file", "Write profiling information to file",		true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-profile_write_file", },
-	{ "-no_unfocused_pause","Don't pause if the window isn't focused",	true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_unfocused_pause", },
-	{ "-benchmark_mode",	"Puts the game into benchmark mode",		true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-benchmark_mode", },
-	{ "-noninteractive",	"Disables interactive dialogs",				true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noninteractive", },
-	{ "-json_profiling",	"Generate JSON profiling output",			true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-json_profiling", },
-	{ "-profile_frame_time","Profile engine subsystems",				true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-profile_frame_timings", },
-	{ "-debug_window",		"Enable the debug window",					true,	0,					EASY_DEFAULT,		"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-debug_window", },
+	{ "-bmpmanusage",		"Show how many BMPMAN slots are in use",	false,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-bmpmanusage", },
+	{ "-pos",				"Show position of camera",					false,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-pos", },
+	{ "-stats",				"Show statistics",							true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-stats", },
+	{ "-coords",			"Show coordinates",							false,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-coords", },
+	{ "-pofspew",			"Dump model information to pofspew.txt",	false,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-pofspew", },
+	{ "-weaponspew",		"Dump weapon stats and spreadsheets",		true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-weaponspew", },
+	{ "-tablecrcs",			"Dump table CRCs for multi validation",		true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-tablecrcs", },
+	{ "-missioncrcs",		"Dump mission CRCs for multi validation",	true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-missioncrcs", },
+	{ "-dis_collisions",	"Disable collisions",						true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dis_collisions", },
+	{ "-dis_weapons",		"Disable weapon rendering",					true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-dis_weapons", },
+	{ "-output_sexps",		"Output SEXPs to sexps.html",				true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-output_sexps", },
+	{ "-output_scripting",	"Output scripting to scripting.html",		true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-output_scripting", },
+	{ "-output_script_json",	"Output scripting doc to scripting.json",	true,	0,								EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-output_script_json", },
+	{ "-save_render_target",	"Save render targets to file",			true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-save_render_target", },
+	{ "-verify_vps",		"Spew VP CRCs to vp_crcs.txt",				true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-verify_vps", },
+	{ "-reparse_mainhall",	"Reparse mainhall.tbl when loading halls",	false,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-reparse_mainhall", },
+	{ "-noninteractive",	"Disables interactive dialogs",				true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noninteractive", },
+	{ "-no_unfocused_pause","Don't pause if the window isn't focused",	true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_unfocused_pause", },
+	{ "-benchmark_mode",	"Puts the game into benchmark mode",		true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-benchmark_mode", },
+	{ "-profile_frame_time","Profile frame time",				true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-profile_frame_time", },
+	{ "-profile_write_file", "Write profiling information to file",		true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-profile_write_file", },
+	{ "-json_profiling",	"Generate JSON profiling output",			true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-json_profiling", },
+	{ "-debug_window",		"Enable the debug window",					true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-debug_window", },
+	{ "-gr_debug",		"Output graphics debug information",			true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-gr_debug", },
 };
+// clang-format on
 
 // forward declaration
 const char * get_param_desc(const char *flag_name);
@@ -273,6 +275,7 @@ cmdline_parm port_arg("-port", "Multiplayer network port", AT_INT);
 cmdline_parm multilog_arg("-multilog", NULL, AT_NONE);		// Cmdline_multi_log
 cmdline_parm client_dodamage("-clientdamage", NULL, AT_NONE);	// Cmdline_client_dodamage
 cmdline_parm pof_spew("-pofspew", NULL, AT_NONE);			// Cmdline_spew_pof_info
+cmdline_parm weapon_spew("-weaponspew", nullptr, AT_NONE);			// Cmdline_spew_weapon_stats
 cmdline_parm mouse_coords("-coords", NULL, AT_NONE);			// Cmdline_mouse_coords
 cmdline_parm timeout("-timeout", "Multiplayer network timeout (secs)", AT_INT);				// Cmdline_timeout
 cmdline_parm bit32_arg("-32bit", "Deprecated", AT_NONE);				// (only here for retail compatibility reasons, doesn't actually do anything)
@@ -294,6 +297,7 @@ int Cmdline_multi_stream_chat_to_file = 0;
 int Cmdline_network_port = -1;
 int Cmdline_restricted_game = 0;
 int Cmdline_spew_pof_info = 0;
+bool Cmdline_spew_weapon_stats = false;
 int Cmdline_start_netgame = 0;
 int Cmdline_timeout = -1;
 int Cmdline_use_last_pilot = 0;
@@ -304,8 +308,6 @@ int Cmdline_use_last_pilot = 0;
 // Graphics related
 cmdline_parm fov_arg("-fov", "Vertical field-of-view factor", AT_FLOAT);					// Cmdline_fov  -- comand line FOV -Bobboau
 cmdline_parm clip_dist_arg("-clipdist", "Changes the distance from the viewpoint for the near-clipping plane", AT_FLOAT);		// Cmdline_clip_dist
-cmdline_parm spec_exp_arg("-spec_exp", "Adjusts the size of shiny spots on ships", AT_FLOAT);
-cmdline_parm ogl_spec_arg("-ogl_spec", "Shininess of specular light", AT_FLOAT);		// Cmdline_ogl_spec
 cmdline_parm spec_static_arg("-spec_static", "Adjusts suns contribution to specular highlights", AT_FLOAT);
 cmdline_parm spec_point_arg("-spec_point", "Adjusts laser weapons contribution to specular highlights", AT_FLOAT);
 cmdline_parm spec_tube_arg("-spec_tube", "Adjusts beam weapons contribution to specular highlights", AT_FLOAT);
@@ -315,15 +317,19 @@ cmdline_parm glow_arg("-noglow", NULL, AT_NONE); 						// Cmdline_glow  -- use B
 cmdline_parm nomotiondebris_arg("-nomotiondebris", NULL, AT_NONE);		// Cmdline_nomotiondebris  -- Removes those ugly floating rocks -C
 cmdline_parm noscalevid_arg("-noscalevid", NULL, AT_NONE);				// Cmdline_noscalevid  -- disable video scaling that fits to window
 cmdline_parm spec_arg("-nospec", NULL, AT_NONE);			// Cmdline_spec  --
-cmdline_parm noemissive_arg("-no_emissive_light", "Disable emissive light from ships", AT_NONE);		// Cmdline_no_emissive  -- don't use emissive light in OGL
+cmdline_parm emissive_arg("-emissive_light", "Enable emissive light from ships", AT_NONE);		// Cmdline_no_emissive  -- don't use emissive light in OGL
 cmdline_parm normal_arg("-nonormal", NULL, AT_NONE);						// Cmdline_normal  -- disable normal mapping
 cmdline_parm height_arg("-noheight", NULL, AT_NONE);						// Cmdline_height  -- enable support for parallax mapping
 cmdline_parm enable_3d_shockwave_arg("-3dshockwave", NULL, AT_NONE);
 cmdline_parm softparticles_arg("-soft_particles", NULL, AT_NONE);
-cmdline_parm postprocess_arg("-post_process", NULL, AT_NONE);
-cmdline_parm bloom_intensity_arg("-bloom_intensity", "Set bloom intensity, requires -post_process", AT_INT);
-cmdline_parm fxaa_arg("-fxaa", NULL, AT_NONE);
-cmdline_parm fxaa_preset_arg("-fxaa_preset", "FXAA quality (0-9), requires -post_process and -fxaa", AT_INT);
+cmdline_parm no_postprocess_arg("-no_post_process", "Disables post-processing", AT_NONE);
+cmdline_parm bloom_intensity_arg("-bloom_intensity", "Set bloom intensity, requires post-processing", AT_INT);
+cmdline_parm post_process_aa_arg("-aa", "Enables post-process antialiasing", AT_NONE);
+cmdline_parm post_process_aa_preset_arg("-aa_preset", "Sets the AA effect to use. See the wiki for details", AT_INT);
+cmdline_parm deprecated_fxaa_arg("-fxaa", nullptr, AT_NONE);
+cmdline_parm deprecated_fxaa_preset_arg("-fxaa_preset", "FXAA quality (0-2), requires post-processing and -fxaa", AT_INT);
+cmdline_parm deprecated_smaa_arg("-smaa", nullptr, AT_NONE);
+cmdline_parm deprecated_smaa_preset_arg("-smaa_preset", "SMAA quality (0-3), requires post-processing and -smaa", AT_INT);
 cmdline_parm fb_explosions_arg("-fb_explosions", NULL, AT_NONE);
 cmdline_parm fb_thrusters_arg("-fb_thrusters", NULL, AT_NONE);
 cmdline_parm flightshaftsoff_arg("-nolightshafts", NULL, AT_NONE);
@@ -333,29 +339,19 @@ cmdline_parm no_deferred_lighting_arg("-no_deferred", NULL, AT_NONE);	// Cmdline
 cmdline_parm anisotropy_level_arg("-anisotropic_filter", NULL, AT_INT);
 
 float Cmdline_clip_dist = Default_min_draw_distance;
-float Cmdline_fov = 0.75f;
-float Cmdline_ogl_spec = 80.0f;
 int Cmdline_ambient_factor = 128;
 int Cmdline_env = 1;
 int Cmdline_mipmap = 0;
 int Cmdline_glow = 1;
-int Cmdline_nomotiondebris = 0;
 int Cmdline_noscalevid = 0;
 int Cmdline_spec = 1;
-int Cmdline_no_emissive = 0;
+int Cmdline_emissive = 0;
 int Cmdline_normal = 1;
 int Cmdline_height = 1;
 int Cmdline_enable_3d_shockwave = 0;
 int Cmdline_softparticles = 0;
-int Cmdline_postprocess = 0;
-int Cmdline_bloom_intensity = 75;
-bool Cmdline_fxaa = false;
-int Cmdline_fxaa_preset = 6;
-extern int Fxaa_preset_last_frame;
-bool Cmdline_fb_explosions = 0;
-bool Cmdline_fb_thrusters = false;
+int Cmdline_bloom_intensity = 25;
 extern bool ls_force_off;
-int Cmdline_shadow_quality = 0;
 int Cmdline_no_deferred_lighting = 0;
 int Cmdline_aniso_level = 0;
 
@@ -395,10 +391,8 @@ int Cmdline_autopilot_interruptable = 1;
 int Cmdline_stretch_menu = 0;
 
 // Audio related
-cmdline_parm query_speech_arg("-query_speech", NULL, AT_NONE);	// Cmdline_query_speech
 cmdline_parm voice_recognition_arg("-voicer", NULL, AT_NONE);	// Cmdline_voice_recognition
 
-int Cmdline_query_speech = 0;
 int Cmdline_voice_recognition = 0;
 int Cmdline_no_enhanced_sound = 0;
 
@@ -411,16 +405,14 @@ char *Cmdline_mod = NULL; //DTP for mod argument
 cmdline_parm almission_arg("-almission", "Autoload multiplayer mission", AT_STRING);		// Cmdline_almission  -- DTP for autoload Multi mission
 cmdline_parm ingamejoin_arg("-ingame_join", NULL, AT_NONE);	// Cmdline_ingamejoin
 cmdline_parm mpnoreturn_arg("-mpnoreturn", NULL, AT_NONE);	// Cmdline_mpnoreturn  -- Removes 'Return to Flight Deck' in respawn dialog -C
-cmdline_parm missioncrcspew_arg("-missioncrcs", NULL, AT_STRING);		// Cmdline_spew_mission_crcs
-cmdline_parm tablecrcspew_arg("-tablecrcs", NULL, AT_STRING);			// Cmdline_spew_table_crcs
 cmdline_parm objupd_arg("-cap_object_update", "Multiplayer object update cap (0-3)", AT_INT);
+cmdline_parm gateway_ip_arg("-gateway_ip", "Set gateway IP address", AT_STRING);
 
 char *Cmdline_almission = NULL;	//DTP for autoload multi mission.
 int Cmdline_ingamejoin = 0;
 int Cmdline_mpnoreturn = 0;
-char *Cmdline_spew_mission_crcs = NULL;
-char *Cmdline_spew_table_crcs = NULL;
 int Cmdline_objupd = 3;		// client object updates on LAN by default
+char *Cmdline_gateway_ip = nullptr;
 
 // Launcher related options
 cmdline_parm portable_mode("-portable_mode", NULL, AT_NONE);
@@ -438,7 +430,6 @@ cmdline_parm atiswap_arg("-ati_swap", NULL, AT_NONE);        // Cmdline_atiswap
 cmdline_parm no3dsound_arg("-no_3d_sound", NULL, AT_NONE);		// Cmdline_no_3d_sound - Disable use of full 3D sounds
 cmdline_parm no_drawrangeelements("-use_gldrawelements", NULL, AT_NONE); // Cmdline_drawelements -- Uses glDrawElements instead of glDrawRangeElements
 cmdline_parm keyboard_layout("-keyboard_layout", "Specify keyboard layout (qwertz or azerty)", AT_STRING);
-cmdline_parm old_collision_system("-old_collision", NULL, AT_NONE); // Cmdline_old_collision_sys
 cmdline_parm gl_finish ("-gl_finish", NULL, AT_NONE);
 cmdline_parm no_geo_sdr_effects("-no_geo_effects", NULL, AT_NONE);
 cmdline_parm set_cpu_affinity("-set_cpu_affinity", NULL, AT_NONE);
@@ -492,10 +483,11 @@ cmdline_parm json_profiling("-json_profiling", NULL, AT_NONE); //Cmdline_json_pr
 cmdline_parm show_video_info("-show_video_info", NULL, AT_NONE); //Cmdline_show_video_info
 cmdline_parm frame_profile_arg("-profile_frame_time", NULL, AT_NONE); //Cmdline_frame_profile
 cmdline_parm debug_window_arg("-debug_window", NULL, AT_NONE);	// Cmdline_debug_window
+cmdline_parm graphics_debug_output_arg("-gr_debug", nullptr, AT_NONE); // Cmdline_graphics_debug_output
+cmdline_parm log_to_stdout_arg("-stdout_log", nullptr, AT_NONE); // Cmdline_log_to_stdout
 
 
 char *Cmdline_start_mission = NULL;
-int Cmdline_old_collision_sys = 0;
 int Cmdline_dis_collisions = 0;
 int Cmdline_dis_weapons = 0;
 bool Cmdline_output_sexp_info = false;
@@ -522,11 +514,14 @@ bool Cmdline_json_profiling = false;
 bool Cmdline_frame_profile = false;
 bool Cmdline_show_video_info = false;
 bool Cmdline_debug_window = false;
+bool Cmdline_graphics_debug_output = false;
+bool Cmdline_log_to_stdout = false;
 
 // Other
-cmdline_parm get_flags_arg("-get_flags", "Output the launcher flags file", AT_STRING);
+cmdline_parm get_flags_arg(GET_FLAGS_STRING, "Output the launcher flags file", AT_STRING);
 cmdline_parm output_sexp_arg("-output_sexps", NULL, AT_NONE); //WMC - outputs all SEXPs to sexps.html
 cmdline_parm output_scripting_arg("-output_scripting", NULL, AT_NONE);	//WMC
+cmdline_parm output_script_json_arg("-output_script_json", nullptr, AT_NONE);	// m!m
 
 // Deprecated flags - CommanderDJ
 cmdline_parm deprecated_spec_arg("-spec", "Deprecated", AT_NONE);
@@ -540,6 +535,8 @@ cmdline_parm deprecated_brieflighting_arg("-brief_lighting", "Deprecated", AT_NO
 cmdline_parm deprecated_sndpreload_arg("-snd_preload", "Deprecated", AT_NONE);
 cmdline_parm deprecated_missile_lighting_arg("-missile_lighting", "Deprecated", AT_NONE);
 cmdline_parm deprecated_cache_bitmaps_arg("-cache_bitmaps", "Deprecated", AT_NONE);
+cmdline_parm deprecated_no_emissive_arg("-no_emissive_light", "Deprecated", AT_NONE);
+cmdline_parm deprecated_postprocess_arg("-post_process", "Deprecated", AT_NONE);
 
 int Cmdline_deprecated_spec = 0;
 int Cmdline_deprecated_glow = 0;
@@ -551,6 +548,7 @@ int Cmdline_deprecated_nohtl = 0;
 bool Cmdline_deprecated_brief_lighting = 0;
 bool Cmdline_deprecated_missile_lighting = false;
 bool Cmdline_deprecated_cache_bitmaps = false;
+bool Cmdline_deprecated_postprocess = false;
 
 #ifndef NDEBUG
 // NOTE: this assumes that os_init() has already been called but isn't a fatal error if it hasn't
@@ -625,6 +623,10 @@ void cmdline_debug_print_cmdline()
 	if (Cmdline_deprecated_cache_bitmaps) {
 		mprintf(("Deprecated flag '-cache_bitmaps' found. Please remove from your cmdline.\n"));
 	}
+
+	if (Cmdline_deprecated_postprocess) {
+		mprintf(("Deprecated flag '-post_process' found. Please remove from your cmdline.\n"));
+	}
 }
 #endif
 
@@ -929,11 +931,11 @@ void os_process_cmdline(char* cmdline)
 	delete[] argv;
 }
 
-bool has_cmdline_only_flag(int argc, char *argv[])
+bool has_cmdline_only_or_get_flags(int argc, char *argv[])
 {
 	for (int i = 0; i < argc; ++i)
 	{
-		if (!strcmp(argv[i], PARSE_COMMAND_LINE_STRING))
+		if (!strcmp(argv[i], PARSE_COMMAND_LINE_STRING) || !strcmp(argv[i], GET_FLAGS_STRING))
 		{
 			return true;
 		}
@@ -965,7 +967,9 @@ void os_init_cmdline(int argc, char *argv[])
 
 	FILE *fp;
 
-	if (!has_cmdline_only_flag(argc, argv)) {
+	// Don't parse any command-line config files if we specified PARSE_COMMAND_LINE_STRING (to explicitly prevent it),
+	// or GET_FLAGS_STRING (because the engine is going to do a quick exit and for GitHub issue #1221)
+	if (!has_cmdline_only_or_get_flags(argc, argv)) {
 		// Only parse the config file in the current directory if we are in legacy config mode
 		if (os_is_legacy_mode()) {
 			// read the cmdline_fso.cfg file from the data folder, and pass the command line arguments to
@@ -1030,7 +1034,7 @@ void os_init_cmdline(int argc, char *argv[])
 				fclose(fp);
 			}
 		}
-	} // If cmdline included PARSE_COMMAND_LINE_STRING
+	} // If cmdline included PARSE_COMMAND_LINE_STRING or GET_FLAGS_STRING
 
 	// By parsing cmdline last, anything actually on the command line will take precedence.
 	os_parse_parms(argc, argv);
@@ -1046,7 +1050,7 @@ void os_init_cmdline(int argc, char *argv[])
  * @param arg_type_    parameters arguement type (if any)
  * @param stacks_    can the parameter be stacked
  */
-cmdline_parm::cmdline_parm(const char *name_, const char *help_, const int arg_type_, const bool stacks_):
+cmdline_parm::cmdline_parm(const char *name_, const char *help_, const int arg_type_, const bool stacks_) noexcept:
 	name(name_), help(help_), stacks(stacks_), arg_type(arg_type_)
 {
 	args = NULL;
@@ -1069,7 +1073,7 @@ cmdline_parm::cmdline_parm(const char *name_, const char *help_, const int arg_t
 
 
 // destructor - frees any allocated memory
-cmdline_parm::~cmdline_parm()
+cmdline_parm::~cmdline_parm() noexcept
 {
 #ifndef FRED
 	if (args) {
@@ -1475,7 +1479,7 @@ static void write_flags_file() {
 }
 
 static flag_output_type get_flags_output_type() {
-	Assertion(get_flags_arg.found(), "This function is only valid if -get_flags is present!");
+	Assertion(get_flags_arg.found(), "This function is only valid if " GET_FLAGS_STRING " is present!");
 
 	if (!get_flags_arg.has_param()) {
 		// Default to binary mode
@@ -1550,24 +1554,6 @@ bool SetCmdlineParams()
 		Cmdline_extra_warn = 1;
 	}
 
-	if ( missioncrcspew_arg.found() ) {
-		Cmdline_spew_mission_crcs = missioncrcspew_arg.str();
-
-		// strip off blank space at end if it's there
-		if ( Cmdline_spew_mission_crcs[strlen(Cmdline_spew_mission_crcs)-1] == ' ' ) {
-			Cmdline_spew_mission_crcs[strlen(Cmdline_spew_mission_crcs)-1] = '\0';
-		}
- 	}
- 
-	if ( tablecrcspew_arg.found() ) {
-		Cmdline_spew_table_crcs = tablecrcspew_arg.str();
-
-		// strip off blank space at end if it's there
-		if ( Cmdline_spew_table_crcs[strlen(Cmdline_spew_table_crcs)-1] == ' ' ) {
-			Cmdline_spew_table_crcs[strlen(Cmdline_spew_table_crcs)-1] = '\0';
-		}
- 	}
-
 	if (!Fred_running) { //There is no standalone FRED
 		// is this a standalone server??
 		if (standalone_arg.found()) {
@@ -1658,6 +1644,11 @@ bool SetCmdlineParams()
 		Cmdline_network_port = port_arg.get_int();
 	}
 
+	// get IP address of gateway, for auto port forwarding
+	if ( gateway_ip_arg.found() ) {
+		Cmdline_gateway_ip = gateway_ip_arg.str();
+	}
+
 	// the connect argument specifies to join a game at this particular address
 	if ( connect_arg.found() ) {
 		Cmdline_use_last_pilot = 1;
@@ -1680,6 +1671,11 @@ bool SetCmdlineParams()
 		Cmdline_spew_pof_info = 1;
 	}
 
+	// spew weapon stats
+	if (weapon_spew.found()) {
+		Cmdline_spew_weapon_stats = true;
+	}
+
 	// mouse coords
 	if(mouse_coords.found()){
 		Cmdline_mouse_coords = 1;
@@ -1691,18 +1687,32 @@ bool SetCmdlineParams()
 	}
 
 	// d3d windowed
-	if(window_arg.found()){
+	if(window_arg.found()) {
+		// We need to set both values since we don't know if we are going to use the new config system
+		options::OptionsManager::instance()->setOverride("Graphics.WindowMode", "0");
 		Cmdline_window = 1;
 	}
 
 	if ( fullscreen_window_arg.found( ) )
 	{
+		options::OptionsManager::instance()->setOverride("Graphics.WindowMode", "1");
 		Cmdline_fullscreen_window = 1;
 		Cmdline_window = 0; /* Make sure no-one sets both */
 	}
 
 	if(res_arg.found()){
 		Cmdline_res = res_arg.str();
+
+		int width = 0;
+		int height = 0;
+
+		if ( sscanf(Cmdline_res, "%dx%d", &width, &height) == 2 ) {
+			SCP_string override;
+			sprintf(override, "{\"width\":%d,\"height\":%d}", width, height);
+			options::OptionsManager::instance()->setOverride("Graphics.Resolution", override);
+		} else {
+			mprintf(("Failed to parse -res parameter \"%s\". Must be in format \"<width>x<height>\".", Cmdline_res));
+		}
 	}
 	if(center_res_arg.found()){
 		Cmdline_center_res = center_res_arg.str();
@@ -1782,7 +1792,7 @@ bool SetCmdlineParams()
 	}
 
 	if ( nomotiondebris_arg.found() ) {
-		Cmdline_nomotiondebris = 1;
+		Motion_debris_enabled = false;
 	}
 
 	if( mipmap_arg.found() ) {
@@ -1794,11 +1804,11 @@ bool SetCmdlineParams()
 	}
 
 	if ( fov_arg.found() ) {
-		Cmdline_fov = fov_arg.get_float();
-		if (Cmdline_fov > 0.1) {
-			VIEWER_ZOOM_DEFAULT = Cmdline_fov;
+		auto val = fov_arg.get_float();
+		if (val > 0.1) {
+			VIEWER_ZOOM_DEFAULT = val;
 		} else {
-			VIEWER_ZOOM_DEFAULT = Cmdline_fov = 0.75f;
+			VIEWER_ZOOM_DEFAULT = 0.75f;
 		}
 	}
 
@@ -1812,7 +1822,7 @@ bool SetCmdlineParams()
 	}
 
 	if ( use_3dwarp.found() ) {
-		Cmdline_3dwarp = 1;
+		Fireball_use_3d_warp = true;
 	}
 
 	if ( use_warp_flash.found() ) {
@@ -1826,11 +1836,8 @@ bool SetCmdlineParams()
 	if ( stretch_menu.found() )	{
 		Cmdline_stretch_menu = 1;
 	}
-	// specular comand lines
-	if ( spec_exp_arg.found() ) {
-		specular_exponent_value = spec_exp_arg.get_float();
-	}
 
+	// specular comand lines
 	if ( spec_point_arg.found() ) {
 		static_point_factor = spec_point_arg.get_float();
 	}
@@ -1855,7 +1862,7 @@ bool SetCmdlineParams()
 
 	if(no_vsync_arg.found() )
 	{
-		Cmdline_no_vsync = 1;
+		Gr_enable_vsync = false;
 	}
 
 	if ( normal_arg.found() ) {
@@ -1865,23 +1872,44 @@ bool SetCmdlineParams()
 	if ( height_arg.found() ) {
 		Cmdline_height = 0;
 	}
-	
-	if (fxaa_arg.found() ) {
-		Cmdline_fxaa = true;
 
-		if (fxaa_preset_arg.found()) {
-			Cmdline_fxaa_preset = fxaa_preset_arg.get_int();
+	if (post_process_aa_arg.found() || post_process_aa_preset_arg.found()) {
+		Gr_aa_mode = AntiAliasMode::SMAA_Low;
+
+		if (post_process_aa_preset_arg.found()) {
+			switch (post_process_aa_preset_arg.get_int()) {
+			case 0: 
+				Gr_aa_mode = AntiAliasMode::FXAA_Low;
+				break;
+			case 1: 
+				Gr_aa_mode = AntiAliasMode::FXAA_Medium;
+				break;
+			case 2: 
+				Gr_aa_mode = AntiAliasMode::FXAA_High;
+				break;
+			case 3: 
+				Gr_aa_mode = AntiAliasMode::SMAA_Low;
+				break;
+			case 4: 
+				Gr_aa_mode = AntiAliasMode::SMAA_Medium;
+				break;
+			case 5: 
+				Gr_aa_mode = AntiAliasMode::SMAA_High;
+				break;
+			case 6: 
+				Gr_aa_mode = AntiAliasMode::SMAA_Ultra;
+				break;
+			}
 		}
-
-		Fxaa_preset_last_frame = Cmdline_fxaa_preset;
 	}
 
+	// If any of the AA presets were chosen, update the _last_frame AA mode to avoid an unnecessary
+	// shader recompile.
+	Gr_aa_mode_last_frame = Gr_aa_mode;
+
 	if ( glow_arg.found() )
 		Cmdline_glow = 0;
 
-	if ( query_speech_arg.found() )
-		Cmdline_query_speech = 1;
-
 	if ( ship_choice_3d_arg.found() )
 		Cmdline_ship_choice_3d = 1;
 
@@ -1901,6 +1929,9 @@ bool SetCmdlineParams()
 	if ( output_scripting_arg.found() )
 		Output_scripting_meta = true;
 
+	if (output_script_json_arg.found() )
+		Output_scripting_json = true;
+
 	if (output_sexp_arg.found() ) {
 		Cmdline_output_sexp_info = true;
 	}
@@ -1964,9 +1995,6 @@ bool SetCmdlineParams()
 		Cmdline_ballistic_gauge = 1;
 	}
 
-	if(old_collision_system.found())
-		Cmdline_old_collision_sys = 1;
-
 	if(dis_collisions.found())
 		Cmdline_dis_collisions = 1;
 
@@ -1977,14 +2005,8 @@ bool SetCmdlineParams()
 		Cmdline_no_fbo = 1;
 	}
 
-	if ( noemissive_arg.found() ) {
-		Cmdline_no_emissive = 1;
-	}
-
-	if ( ogl_spec_arg.found() ) {
-		Cmdline_ogl_spec = ogl_spec_arg.get_float();
-
-		CLAMP(Cmdline_ogl_spec, 0.0f, 128.0f);
+	if ( emissive_arg.found() ) {
+		Cmdline_emissive = 1;
 	}
 
 	if ( rearm_timer_arg.found() )
@@ -2016,17 +2038,17 @@ bool SetCmdlineParams()
 
 	if ( fb_explosions_arg.found() )
 	{
-		Cmdline_fb_explosions = 1;
+		Gr_framebuffer_effects.set(FramebufferEffects::Shockwaves, true);
 	}
 
     if (fb_thrusters_arg.found()) 
     {
-        Cmdline_fb_thrusters = true;
+	    Gr_framebuffer_effects.set(FramebufferEffects::Thrusters, true);
     }
 
-	if ( postprocess_arg.found() )
+	if ( no_postprocess_arg.found() )
 	{
-		Cmdline_postprocess = 1;
+		Gr_post_processing_enabled = false;
 	}
 
 	if ( bloom_intensity_arg.found() )
@@ -2046,12 +2068,32 @@ bool SetCmdlineParams()
 
 	if( enable_shadows_arg.found() )
 	{
-		Cmdline_shadow_quality = 2;
+		Shadow_quality = ShadowQuality::Medium;
 	}
 
 	if( shadow_quality_arg.found() )
 	{
-		Cmdline_shadow_quality = shadow_quality_arg.get_int();
+		switch (shadow_quality_arg.get_int()) {
+		case 0:
+			Shadow_quality = ShadowQuality::Disabled;
+			break;
+		case 1:
+			Shadow_quality = ShadowQuality::Low;
+			break;
+		case 2:
+			Shadow_quality = ShadowQuality::Medium;
+			break;
+		case 3:
+			Shadow_quality = ShadowQuality::High;
+			break;
+		case 4:
+			Shadow_quality = ShadowQuality::Ultra;
+			break;
+		default:
+			mprintf(("Invalid shadow quality %d. Disabling shadows...\n", shadow_quality_arg.get_int()));
+			Shadow_quality = ShadowQuality::Disabled;
+			break;
+		}
 	}
 
 	if( no_deferred_lighting_arg.found() )
@@ -2098,6 +2140,14 @@ bool SetCmdlineParams()
 		Cmdline_debug_window = true;
 	}
 
+	if (graphics_debug_output_arg.found()) {
+		Cmdline_graphics_debug_output = true;
+	}
+
+	if (log_to_stdout_arg.found()) {
+		Cmdline_log_to_stdout = true;
+	}
+
 	if (show_video_info.found())
 	{
 		Cmdline_show_video_info = true;
@@ -2153,6 +2203,53 @@ bool SetCmdlineParams()
 		Cmdline_deprecated_cache_bitmaps = true;
 	}
 
+	if (deprecated_no_emissive_arg.found()) {
+		Cmdline_emissive = 0;
+	}
+
+	if (deprecated_postprocess_arg.found()) {
+		Cmdline_deprecated_postprocess = true;
+	}
+
+	if (deprecated_fxaa_arg.found() ) {
+		Gr_aa_mode = AntiAliasMode::FXAA_Medium;
+
+		if (deprecated_fxaa_preset_arg.found()) {
+			auto val = deprecated_fxaa_preset_arg.get_int();
+			if (val > 6) {
+				Gr_aa_mode = AntiAliasMode::FXAA_High;
+			} else if (val > 3) {
+				Gr_aa_mode = AntiAliasMode::FXAA_Medium;
+			} else {
+				Gr_aa_mode = AntiAliasMode::FXAA_Low;
+			}
+		}
+	}
+
+	if (deprecated_smaa_arg.found()) {
+		Gr_aa_mode = AntiAliasMode::SMAA_Medium;
+
+		if (deprecated_smaa_preset_arg.found()) {
+			switch (deprecated_smaa_preset_arg.get_int()) {
+			case 0:
+				Gr_aa_mode = AntiAliasMode::SMAA_Low;
+				break;
+			case 1:
+				Gr_aa_mode = AntiAliasMode::SMAA_Medium;
+				break;
+			case 2:
+				Gr_aa_mode = AntiAliasMode::SMAA_High;
+				break;
+			case 3:
+				Gr_aa_mode = AntiAliasMode::SMAA_Ultra;
+				break;
+			default:
+				Gr_aa_mode = AntiAliasMode::SMAA_Ultra;
+				break;
+			}
+		}
+	}
+ 
 	return true; 
 }
 

code/cmdline/cmdline.h

@@ -53,32 +53,22 @@ extern char *Cmdline_center_res;
 // FSO OPTIONS -------------------------------------------------
 
 // Graphics related
-extern double specular_exponent_value;
 extern float Cmdline_clip_dist;
-extern float Cmdline_fov;
-extern float Cmdline_ogl_spec;
 extern float static_light_factor;
 extern float static_point_factor;
 extern float static_tube_factor;
 extern int Cmdline_ambient_factor;
 extern int Cmdline_env;
 extern int Cmdline_glow;
-extern int Cmdline_nomotiondebris;
 extern int Cmdline_noscalevid;	// disables fit-to-window for movies - taylor
 extern int Cmdline_spec;
 extern int Cmdline_normal;
 extern int Cmdline_height;
 extern int Cmdline_enable_3d_shockwave;
 extern int Cmdline_softparticles;
-extern int Cmdline_postprocess;
 extern int Cmdline_bloom_intensity;
-extern bool Cmdline_fxaa;
-extern int Cmdline_fxaa_preset;
-extern bool Cmdline_fb_explosions;
-extern bool Cmdline_fb_thrusters;
-extern int Cmdline_shadow_quality;
 extern int Cmdline_no_deferred_lighting;
-extern int Cmdline_no_emissive;
+extern int Cmdline_emissive;
 extern int Cmdline_aniso_level;
 
 // Game Speed related
@@ -101,7 +91,6 @@ extern int Cmdline_autopilot_interruptable;
 extern int Cmdline_stretch_menu;
 
 // Audio related
-extern int Cmdline_query_speech;
 extern int Cmdline_voice_recognition;
 extern int Cmdline_no_enhanced_sound;
 
@@ -111,9 +100,8 @@ extern char *Cmdline_mod;	 // DTP for mod support
 extern char *Cmdline_almission;	// DTP for autoload mission (for multi only)
 extern int Cmdline_ingamejoin;
 extern int Cmdline_mpnoreturn;
-extern char *Cmdline_spew_mission_crcs;
-extern char *Cmdline_spew_table_crcs;
 extern int Cmdline_objupd;
+extern char *Cmdline_gateway_ip;
 
 // Launcher related options
 extern bool Cmdline_portable_mode;
@@ -140,7 +128,6 @@ extern bool Cmdline_alternate_registry_path;
 
 // Developer/Testing related
 extern char *Cmdline_start_mission;
-extern int Cmdline_old_collision_sys;
 extern int Cmdline_dis_collisions;
 extern int Cmdline_dis_weapons;
 extern bool Cmdline_output_sexp_info;
@@ -160,5 +147,9 @@ 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;
+extern bool Cmdline_spew_weapon_stats;
+
 
 #endif

code/cmeasure/cmeasure.cpp

@@ -53,26 +53,6 @@ void cmeasure_set_ship_launch_vel(object *objp, object *parent_objp, int arand)
 	vm_vec_copy_scale(&objp->phys_info.desired_vel, &objp->orient.vec.fvec, objp->phys_info.max_vel.xyz.z );
 }
 
-void cmeasure_select_next(ship *shipp)
-{
-	Assert(shipp != NULL);
-	int i, new_index;
-
-	for (i = 1; i < Num_weapon_types; i++)
-	{
-		new_index = (shipp->current_cmeasure + i) % Num_weapon_types;
-
-		if(Weapon_info[new_index].wi_flags[Weapon::Info_Flags::Cmeasure])
-		{
-			shipp->current_cmeasure = new_index;
-			return;
-		}
-	}
-
-	mprintf(("Countermeasure type set to %i in frame %i\n", shipp->current_cmeasure, Framecount));
-}
-
-
 /** 
  * @brief If this is a player countermeasure, let the player know they evaded a missile.
  * @param objp [description]

code/cmeasure/cmeasure.h

@@ -28,7 +28,6 @@ extern int Cmeasures_homing_check;
 extern int Countermeasures_enabled;
 
 extern void cmeasure_set_ship_launch_vel(object *objp, object *parent_objp, int arand);
-extern void cmeasure_select_next(object *objp);
 extern void cmeasure_maybe_alert_success(object *objp);
 
 #endif // _CMEASURE_H

code/controlconfig/controlsconfig.cpp

@@ -38,7 +38,6 @@
 
 
 
-#define NUM_SYSTEM_KEYS			14
 #define NUM_BUTTONS				19
 #define NUM_TABS				4
 
@@ -157,11 +156,6 @@ char *Mouse_button_text[NUM_MOUSE_TEXT];
 char *Mouse_axis_text[NUM_MOUSE_AXIS_TEXT];
 char *Invert_text[NUM_INVERT_TEXT];
 
-ubyte System_keys[NUM_SYSTEM_KEYS] = {
-	KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10,
-	KEY_F11, KEY_F12, KEY_PRINT_SCRN
-};
-
 int Control_check_count = 0;
 
 static int Tab;  // which tab we are currently in
@@ -522,7 +516,9 @@ 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].hasXSTR) {
+			if (Control_config[z].indexXSTR > 1) {
+				Cc_lines[Num_cc_lines].label = XSTR(Control_config[z].text, Control_config[z].indexXSTR);
+			} else if (Control_config[z].indexXSTR == 1) {
 				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;
@@ -1005,7 +1001,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].hasXSTR = preset[i].hasXSTR;
+		Control_config[i].indexXSTR = preset[i].indexXSTR;
 		Control_config[i].type = preset[i].type;
 		Control_config[i].disabled = preset[i].disabled;
 	}
@@ -1988,7 +1984,9 @@ 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].hasXSTR) {
+		if (Control_config[i].indexXSTR > 1) {
+			strcpy_s(buf, XSTR(Control_config[i].text, Control_config[i].indexXSTR));
+		} else if (Control_config[i].indexXSTR == 1) {
 			strcpy_s(buf, XSTR(Control_config[i].text, CONTROL_CONFIG_XSTR + i));
 		} else {
 			strcpy_s(buf, Control_config[i].text);
@@ -2193,17 +2191,6 @@ void control_config_do_frame(float frametime)
 	gr_flip();
 }
 
-void clear_key_binding(short key)
-{
-	int i;
-
-	for (i=0; i<CCFG_MAX; i++) {
-		if (Control_config[i].key_id == key) {
-			Control_config[i].key_id = -1;
-		}
-	}
-}
-
 float check_control_timef(int id)
 {
 	float t1, t2;
@@ -2317,7 +2304,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", key));
+		//mprintf(("Key used %d\n", key));
 		control_used(id);
 		return 1;
 	}
@@ -2447,9 +2434,4 @@ void control_config_clear()
 	for (i=0; i<CCFG_MAX; i++) {
 		Control_config[i].key_id = Control_config[i].joy_id = -1;
 	}
-}
-
-int control_config_handle_conflict()
-{
-	return 0;
-}
+}

code/controlconfig/controlsconfig.h

@@ -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
-	bool hasXSTR;			//!< whether we should translate this with an XSTR
+	int indexXSTR;			//!< what string index we should use to 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,6 +270,15 @@ 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
 	 */
@@ -277,12 +286,6 @@ enum IoActionId  {
 };
 
 extern int Failed_key_index;
-extern int Invert_heading;
-extern int Invert_pitch;
-extern int Invert_roll;
-extern int Invert_thrust;
-extern int Disable_axis2;
-extern int Disable_axis3;
 
 extern int Axis_map_to[];
 extern int Invert_axis[];
@@ -336,7 +339,6 @@ int check_control(int id, int key = -1);
 void control_get_axes_readings(int *h, int *p, int *b, int *ta, int *tr);
 void control_used(int id);
 void control_config_clear();
-void clear_key_binding(short key);
 void control_check_indicate();
 void control_config_clear_used_status();
 

code/controlconfig/controlsconfigcommon.cpp

@@ -17,6 +17,7 @@
 #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...
@@ -32,15 +33,29 @@ 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;
 
-// assume control keys are used as modifiers until we find out 
-int Shift_is_modifier;
-int Ctrl_is_modifier;
-int Alt_is_modifier;
+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 Axis_enabled[JOY_NUM_AXES] = { 1, 1, 1, 0, 0, 0 };
-int Axis_enabled_defaults[JOY_NUM_AXES] = { 1, 1, 1, 0, 0, 0 };
 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 };
 
@@ -49,154 +64,159 @@ 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,   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 },
+	{                           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 },
 
 	// targeting a ship's subsystem
-	{                           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 },
+	{                           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 },
 
 	// matching speed
-	{                           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 },
+	{                           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 },
 
 	// weapons
-	{                           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 },
+	{                           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 },
 
 	// controls
-	{                           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 },
+	{                           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 },
 
 	// throttle controls
-	{                           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 },
+	{                           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 },
 
 	// squadmate messaging
-	{             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_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_R,               6, TARGET_TAB,   true,  "Target Closest Attacking Ship",          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 },
 
 	// Views
-	{                           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_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_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_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_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_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_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 },
+	{                           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 },
 //	{                           -1,                 -1, -1,           true,  "Show Damage Popup Window" },
 
-	{                           -1,                 -1, SHIP_TAB,     false, "Glide When Pressed",                     CC_TYPE_CONTINUOUS, -1, -1, 0, false, false },
+	{                           -1,                 -1, SHIP_TAB,     0, "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,     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 },
+	{                           -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 },
 
-	{                           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_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_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 },
+	{                           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 },
 
 	// multiplayer messaging keys
-	{                           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 },
+	{                           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 },
 
 	// Misc
-	{             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
+	{             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
 	// Auto Navigation Systen
-	{ 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 }
+	{ 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 }
 };
 
 const char *Scan_code_text_german[] = {
@@ -410,31 +430,6 @@ const char **Joy_button_text = Joy_button_text_english;
 SCP_vector<config_item*> Control_config_presets;
 SCP_vector<SCP_string> Control_config_preset_names;
 
-void set_modifier_status()
-{
-	int i;
-
-	Alt_is_modifier = 0;
-	Shift_is_modifier = 0;
-	Ctrl_is_modifier = 0;
-
-	for (i=0; i<CCFG_MAX; i++) {
-		if (Control_config[i].key_id < 0)
-			continue;
-
-		if (Control_config[i].key_id & KEY_ALTED)
-			Alt_is_modifier = 1;
-
-		if (Control_config[i].key_id & KEY_SHIFTED)
-			Shift_is_modifier = 1;
-
-		if (Control_config[i].key_id & KEY_CTRLED) {
-			Assert(0);  // get Alan
-			Ctrl_is_modifier = 1;
-		}
-	}
-}
-
 // If find_override is set to true, then this returns the index of the action
 // which has been bound to the given key. Otherwise, the index of the action
 // which has the given key as its default key will be returned.
@@ -536,7 +531,9 @@ char *translate_key(char *key)
 	// both key and joystick button are mapped to this control
 	if ((key_code >= 0 ) && (joy_code >= 0) ) {
 		strcpy_s(text, key_text);
-		strcat_s(text, " or ");
+		strcat_s(text, " ");
+		strcat_s(text, XSTR("or", 1638));
+		strcat_s(text, " ");
 		strcat_s(text, joy_text);
 	}
 	// if we only have one
@@ -616,7 +613,6 @@ 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;
 	}
 
@@ -873,7 +869,7 @@ void control_config_common_load_overrides()
                         * short key_default;
                         * short joy_default;
                         * char tab;
-                        * bool hasXSTR;
+                        * int indexXSTR;
                         * char type;
                         */
 
@@ -915,7 +911,7 @@ void control_config_common_load_overrides()
 
 						if (optional_string("$Has XStr:")) {
 							stuff_int(&iTemp);
-							r_ccConfig.hasXSTR = (iTemp == 1);
+							r_ccConfig.indexXSTR = iTemp;
 						}
 
 						if (optional_string("$Type:")) {

code/cutscene/Decoder.cpp

@@ -4,7 +4,7 @@
 
 namespace cutscene {
 FrameSize::FrameSize(size_t in_width, size_t in_height, size_t in_stride)
-    : width(in_width), height(in_height), stride(in_stride)
+		: width(in_width), height(in_height), stride(in_stride)
 {
 }
 FrameSize::FrameSize() = default;
@@ -46,10 +46,6 @@ void Decoder::stopDecoder() {
 	m_subtitleQueue->close();
 }
 
-bool Decoder::canPushAudioData() {
-	return !isAudioQueueFull();
-}
-
 void Decoder::pushAudioData(AudioFramePtr&& data) {
 	Assertion(data, "Invalid audio data passed!");
 
@@ -61,9 +57,6 @@ void Decoder::pushAudioData(AudioFramePtr&& data) {
 	}
 }
 
-bool Decoder::canPushSubtitleData() {
-	return !isSubtitleQueueFull();
-}
 void Decoder::pushSubtitleData(SubtitleFramePtr&& data) {
 	Assertion(data, "Invalid audio data passed!");
 
@@ -75,10 +68,6 @@ void Decoder::pushSubtitleData(SubtitleFramePtr&& data) {
 	}
 }
 
-bool Decoder::canPushVideoData() {
-	return !isVideoQueueFull();
-}
-
 void Decoder::pushFrameData(VideoFramePtr&& frame) {
 	Assertion(frame, "Invalid video data passed!");
 

code/cutscene/Decoder.h

@@ -11,8 +11,8 @@ struct FrameSize {
 	size_t height = 0;
 	size_t stride = 0;
 
-	FrameSize(size_t width, size_t in_height, size_t in_stride);
 	FrameSize();
+	FrameSize(size_t width, size_t in_height, size_t in_stride);
 };
 
 class VideoFrame {
@@ -147,10 +147,6 @@ class Decoder {
 
 	bool isSubtitleQueueFull() { return m_subtitleQueue->size() == m_queueSize; }
 
-	bool isSubtitleFrameAvailable() { return !m_subtitleQueue->empty(); }
-
-	size_t getSubtitleQueueSize() { return m_subtitleQueue->size(); }
-
 	bool tryPopSubtitleData(SubtitleFramePtr&);
 
 	bool isVideoQueueFull() { return m_videoQueue->size() == m_queueSize; }
@@ -168,16 +164,10 @@ class Decoder {
  protected:
 	void initializeQueues(size_t queueSize);
 
-	bool canPushAudioData();
-
 	void pushAudioData(AudioFramePtr&& data);
 
-	bool canPushSubtitleData();
-
 	void pushSubtitleData(SubtitleFramePtr&& data);
 
-	bool canPushVideoData();
-
 	void pushFrameData(VideoFramePtr&& frame);
 };
 }

code/cutscene/cutscenes.cpp

@@ -83,24 +83,33 @@ void cutscene_init()
 
 			if (optional_string("$cd:"))
 			{
-				// Option isn't needed anymore. Consume the token and ignore it
-
+				// CD option isn't needed anymore. Consume the token and ignore it
 				int junk;
 				stuff_int(&junk);
 			}
 
-			cutinfo.viewable = false;
+			cutinfo.flags.reset();
 
 			if (isFirstCutscene)
 			{
 				isFirstCutscene = false;
-				// The original code assumes the first movie is the intro, so always viewable
-				cutinfo.viewable = true;
+				// The original code assumes the first movie is the intro, so make it viewable
+				cutinfo.flags.set(Cutscene::Cutscene_Flags::Viewable);
 			}
 
 			if (optional_string("$Always Viewable:"))
 			{
-				stuff_boolean(&cutinfo.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);
 			}
 
 			Cutscenes.push_back(cutinfo);
@@ -143,7 +152,7 @@ void cutscene_mark_viewable(const char* filename)
 		// see if the stripped filename matches the cutscene filename
 		if (strstr(cut_file, file) != NULL)
 		{
-			cut->viewable = true;
+			cut->flags.set(Cutscene::Cutscene_Flags::Viewable);
 			return;
 		}
 		i++;
@@ -441,9 +450,9 @@ void cutscenes_screen_init()
 	Cutscene_list.clear();
 
 	int u = 0;
-	for (SCP_vector<cutscene_info>::iterator cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut, u++)
+	for (auto cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut, ++u)
 	{
-		if ((*cut).viewable)
+		if (cut->flags[Cutscene::Cutscene_Flags::Viewable, Cutscene::Cutscene_Flags::Always_viewable] && !cut->flags[Cutscene::Cutscene_Flags::Never_viewable])
 		{
 			Cutscene_list.push_back(u);
 		}

code/cutscene/cutscenes.h

@@ -10,26 +10,31 @@
 #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;
-	bool viewable;
+	flagset<Cutscene::Cutscene_Flags> flags;
 } cutscene_info;
 
-#if SCP_COMPILER_IS_GNU
-#pragma GCC diagnostic push
-// This suppresses a GCC bug where it thinks that the Cutscenes from the enum class below shadows a global variable
-#pragma GCC diagnostic ignored "-Wshadow"
-#endif
 extern SCP_vector<cutscene_info> Cutscenes;
-#if SCP_COMPILER_IS_GNU
-#pragma GCC diagnostic pop
-#endif
 
 // initializa table data
 void cutscene_init();

code/cutscene/ffmpeg/AudioDecoder.cpp

@@ -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!!!"));
+			mprintf(("FFMPEG: Failed to allocate samples!!!\n"));
 			return;
 		}
 

code/cutscene/ffmpeg/FFMPEGDecoder.cpp

@@ -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];
+		auto& current_language = Lcl_languages[Lcl_current_lang == LCL_UNTRANSLATED ? LCL_DEFAULT : 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];
+	auto& current_language = Lcl_languages[Lcl_current_lang == LCL_UNTRANSLATED ? LCL_DEFAULT : Lcl_current_lang];
 
 	for (auto ext : CHECKED_SUBT_EXTENSIONS) {
 		SCP_string fileName;

code/cutscene/player.cpp

@@ -27,13 +27,15 @@ using namespace cutscene;
 
 const int MAX_AUDIO_BUFFERS = 15;
 
-std::unique_ptr<Decoder> findDecoder(const SCP_string& name, const PlaybackProperties& properties) {
+std::unique_ptr<Decoder> findDecoder(__UNUSED const SCP_string& name, __UNUSED const PlaybackProperties& properties) {
+#ifdef WITH_FFMPEG
 	{
 		std::unique_ptr<Decoder> ffmpeg(new ::cutscene::ffmpeg::FFMPEGDecoder());
 		if (ffmpeg->initialize(name, properties)) {
 			return ffmpeg;
 		}
 	}
+#endif
 
 	return nullptr;
 }

code/debris/debris.cpp

@@ -31,7 +31,6 @@
 #include "weapon/weapon.h"
 #include "tracing/Monitor.h"
 
-#define MAX_LIFE									10.0f
 #define MIN_RADIUS_FOR_PERSISTANT_DEBRIS	50		// ship radius at which debris from it becomes persistant
 #define DEBRIS_SOUND_DELAY						2000	// time to start debris sound after created
 #define MAX_HULL_PIECES			MAX_DEBRIS_PIECES // limit the number of hull debris chunks that can exist. 
@@ -52,10 +51,6 @@ int Debris_num_submodels = 0;
 #define	DEBRIS_DISTANCE_CHECK_TIME		(10*1000)		//	Check every 10 seconds.
 #define	DEBRIS_INDEX(dp) (int)(dp-Debris)
 
-#define	MAX_SPEED_SMALL_DEBRIS		200					// maximum velocity of small debris piece
-#define	MAX_SPEED_BIG_DEBRIS			150					// maximum velocity of big debris piece
-#define	MAX_SPEED_CAPITAL_DEBRIS	100					// maximum velocity of capital debris piece
-
 /**
  * Start the sequence of a piece of debris writhing in unholy agony!!!
  */
@@ -245,11 +240,12 @@ void debris_process_post(object * obj, float frame_time)
 		MONITOR_INC(NumSmallDebris,1);
 	}
 
-	if ( db->lifeleft >= 0.0f) {
+	if (db->lifeleft >= 0.0f) {
 		db->lifeleft -= frame_time;
-		if ( db->lifeleft < 0.0f )	{
-			debris_start_death_roll(obj, db);
-		}
+	}
+
+	if ( db->lifeleft < 0.0f )	{
+		debris_start_death_roll(obj, db);
 	}
 
 	maybe_delete_debris(db);	//	Make this debris go away if it's very far away.
@@ -270,13 +266,8 @@ void debris_process_post(object * obj, float frame_time)
 
 			vec3d v1, v2, v3, v4;
 
-			if ( Cmdline_old_collision_sys ) {
-				submodel_get_two_random_points( db->model_num, db->submodel_num, &v1, &v2 );
-				submodel_get_two_random_points( db->model_num, db->submodel_num, &v3, &v4 );
-			} else {
-				submodel_get_two_random_points_better( db->model_num, db->submodel_num, &v1, &v2 );
-				submodel_get_two_random_points_better( db->model_num, db->submodel_num, &v3, &v4 );
-			}
+			submodel_get_two_random_points_better(db->model_num, db->submodel_num, &v1, &v2);
+			submodel_get_two_random_points_better(db->model_num, db->submodel_num, &v3, &v4);
 
 			n = 0;
 
@@ -352,12 +343,8 @@ void debris_process_post(object * obj, float frame_time)
 				if ( mr < RAND_MAX/5 )	{
 					vec3d v1, v2;
 
-					if ( Cmdline_old_collision_sys ) {
-						submodel_get_two_random_points( db->model_num, db->submodel_num, &v1, &v2 );
-					} else {
-						submodel_get_two_random_points_better( db->model_num, db->submodel_num, &v1, &v2 );
-					}
-					
+					submodel_get_two_random_points_better(db->model_num, db->submodel_num, &v1, &v2);
+
 					db->arc_pts[i][mr % 2] = v1;
 				}
 			}
@@ -505,7 +492,6 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	db->flags |= DEBRIS_USED;
 	db->is_hull = hull_flag;
 	db->source_objnum = parent_objnum;
-	db->source_sig = source_obj->signature;
 	db->damage_type_idx = shipp->debris_damage_type_idx;
 	db->ship_info_index = shipp->ship_info_index;
 	db->team = shipp->team;
@@ -989,8 +975,6 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 
 		// SET PHYSICS PARAMETERS
 		// already have (hitpos - heavy) and light_cm_pos
-		// get heavy cm pos - already have light_cm_pos
-		debris_hit_info->heavy_collision_cm_pos = zero;
 
 		// get r_heavy and r_light
 		debris_hit_info->r_heavy = debris_hit_info->hit_pos;

code/debris/debris.h

@@ -24,7 +24,6 @@ typedef struct debris {
 	debris	*next, *prev;		// used for a linked list of the hull debris chunks
 	int		flags;					// See DEBRIS_??? defines
 	int		source_objnum;		// What object this came from
-	int		source_sig;			// Signature of the source object
 	int		damage_type_idx;	// Damage type of this debris
 	int		ship_info_index;	// Ship info index of the ship type debris came from
 	int		team;					// Team of the ship where the debris came from

code/debugconsole/console.cpp

@@ -70,7 +70,6 @@ int dc_font = font::FONT1;
 
 SCP_string dc_title;
 
-#define SCROLL_X_MAX (DBCOLS - DCOLS)
 #define SCROLL_Y_MAX (DBROWS - DROWS)
 
 // Commands and History
@@ -117,11 +116,6 @@ void dc_draw_window(bool show_prompt);
  */
 void dc_putc(char c);
 
-/**
- * @brief Predicate function used to sort debug_commands
- */
-bool dcmd_less(debug_command *first, debug_command *second);
-
 // ============================== IMPLEMENTATIONS =============================
 void dc_do_command(SCP_string *cmd_str)
 {
@@ -494,11 +488,6 @@ void dc_putc(char c)
 	line_str->push_back(c);
 }
 
-bool dcmd_less(debug_command *first, debug_command *second)
-{
-	return (strcmp(first->name, second->name) < 0);
-}
-
 void debug_console(void (*_func)(void))
 {
 	int done = 0;

code/debugconsole/consolecmds.cpp

@@ -28,10 +28,6 @@ debug_command *dc_commands[DC_MAX_COMMANDS];
 int dc_commands_size = 0;
 
 // ========================= LOCALS ==========================
-// dcf_shell commands
-void dc_shell_font( void );
-void dc_shell_resize( void );
-void dc_shell_resize_buf( void );
 
 // =================== class debug_command ===================
 debug_command::debug_command()
@@ -155,6 +151,4 @@ DCF(help, "Displays the help list." )
 
 		dc_printf(" %s - %s\n", dc_commands[i]->name, dc_commands[i]->help);
 	}
-}
-
-debug_command dc_man("man", "Also displays the help list", dcf_help);
+}

code/decals/decals.cpp

@@ -226,6 +226,7 @@ void parse_decals_table(const char* filename) {
 struct Decal {
 	int definition_handle = -1;
 	object_h object;
+	int orig_obj_type = OBJ_NONE;
 	int submodel = -1;
 
 	float creation_time = -1.0f; //!< The mission time at which this decal was created
@@ -244,6 +245,12 @@ struct Decal {
 			return false;
 		}
 
+		if (orig_obj_type != object.objp->type) {
+			mprintf(("Decal object type for object %d has changed from %s to %s. Please let m!m know about this\n",
+			         OBJ_INDEX(object.objp), Object_type_names[orig_obj_type], Object_type_names[object.objp->type]));
+			return false;
+		}
+
 		if (lifetime > 0.0f) {
 			if (f2fl(Missiontime) >= creation_time + lifetime) {
 				// Decal has expired
@@ -461,10 +468,9 @@ void renderAll() {
 		return;
 	}
 
-
-	graphics::decal_draw_list draw_list;
 	auto mission_time = f2fl(Missiontime);
 
+	graphics::decal_draw_list draw_list(active_decals.size());
 	for (auto& decal : active_decals) {
 		int diffuse_bm = -1;
 		int glow_bm = -1;
@@ -525,6 +531,7 @@ addDecal(creation_info& info, object* host, int submodel, const vec3d& local_pos
 	Decal newDecal;
 	newDecal.definition_handle = info.definition_handle;
 	newDecal.object = object_h(host);
+	newDecal.orig_obj_type     = host->type;
 	newDecal.submodel = submodel;
 	newDecal.creation_time = f2fl(Missiontime);
 	newDecal.lifetime = info.lifetime.next();

code/def_files/data/effects/batched-f.sdr

@@ -3,9 +3,15 @@
 
 in vec4 fragTexCoord;
 in vec4 fragColor;
+
 out vec4 fragOut0;
+
 uniform sampler2DArray baseMap;
-uniform float intensity;
+
+layout (std140) uniform genericData {
+	vec4 color;
+	float intensity;
+};
 
 void main()
 {

code/def_files/data/effects/batched-v.sdr

@@ -1,11 +1,20 @@
 in vec4 vertPosition;
 in vec4 vertTexCoord;
 in vec4 vertColor;
+
 out vec4 fragTexCoord;
 out vec4 fragColor;
-uniform mat4 modelViewMatrix;
-uniform mat4 projMatrix;
-uniform vec4 color;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
+layout (std140) uniform genericData {
+	vec4 color;
+	float intensity;
+};
+
 void main()
 {
 	fragTexCoord = vec4(vertTexCoord.xyz, 0.0);

code/def_files/data/effects/bloom-comp-f.sdr

@@ -1,8 +1,15 @@
+
 in vec4 fragTexCoord;
+
 out vec4 fragOut0;
+
 uniform sampler2D bloomed;
-uniform float bloom_intensity;
-uniform int levels;
+
+layout (std140) uniform genericData {
+	float bloom_intensity;
+	int levels;
+};
+
 void main() {
 	vec4 color_out = vec4(0.0, 0.0, 0.0, 1.0);
 	float factor = 0.0;
@@ -14,4 +21,4 @@ void main() {
 	color_out.rgb /= factor;
 	color_out.rgb *= bloom_intensity;
 	fragOut0 = color_out;
-}
+}

code/def_files/data/effects/blur-f.sdr

@@ -1,9 +1,16 @@
 out vec4 fragOut0;
-uniform float texSize;
-uniform float tapSize;
-uniform int level;
+
 in vec4 fragTexCoord;
+
 uniform sampler2D tex;
+
+const float TapSize = 1.0;
+
+layout (std140) uniform genericData {
+	float texSize;
+	int level;
+};
+
 // Gaussian Blur
 // 2 passes required
 void main()
@@ -20,15 +27,15 @@ void main()
 	vec4 sum = textureLod(tex, fragTexCoord.xy, float(level)) * BlurWeights[0];
 #ifdef PASS_0
 	for (int i = 1; i < 6; i++) {
-		sum += textureLod(tex, vec2(clamp(fragTexCoord.x - float(i) * (texSize) * tapSize, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
-		sum += textureLod(tex, vec2(clamp(fragTexCoord.x + float(i) * (texSize) * tapSize, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
+		sum += textureLod(tex, vec2(clamp(fragTexCoord.x - float(i) * (texSize) * TapSize, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
+		sum += textureLod(tex, vec2(clamp(fragTexCoord.x + float(i) * (texSize) * TapSize, 0.0, 1.0), fragTexCoord.y), float(level)) * BlurWeights[i];
 	}
 #endif
 #ifdef PASS_1
 	for (int i = 1; i < 6; i++) {
-		sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y - float(i) * (texSize) * tapSize, 0.0, 1.0)), float(level)) * BlurWeights[i];
-		sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y + float(i) * (texSize) * tapSize, 0.0, 1.0)), float(level)) * BlurWeights[i];
+		sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y - float(i) * (texSize) * TapSize, 0.0, 1.0)), float(level)) * BlurWeights[i];
+		sum += textureLod(tex, vec2(fragTexCoord.x, clamp(fragTexCoord.y + float(i) * (texSize) * TapSize, 0.0, 1.0)), float(level)) * BlurWeights[i];
 	}
 #endif
 	fragOut0 = sum;
-}
+}

code/def_files/data/effects/default-material-f.sdr

@@ -6,12 +6,23 @@ in vec4 fragColor;
 out vec4 fragOut0;
 
 uniform sampler2DArray baseMap;
-uniform int baseMapIndex;
-uniform int alphaTexture;
-uniform int noTexturing;
-uniform int srgb;
-uniform float intensity;
-uniform float alphaThreshold;
+
+layout (std140) uniform genericData {
+	mat4 modelMatrix;
+
+	vec4 color;
+
+	vec4 clipEquation;
+
+	int baseMapIndex;
+	int alphaTexture;
+	int noTexturing;
+	int srgb;
+
+	float intensity;
+	float alphaThreshold;
+	bool clipEnabled;
+};
 
 void main()
 {

code/def_files/data/effects/default-material-v.sdr

@@ -0,0 +1,38 @@
+in vec4 vertPosition;
+in vec4 vertTexCoord;
+in vec4 vertColor;
+out vec4 fragTexCoord;
+out vec4 fragColor;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
+layout (std140) uniform genericData {
+	mat4 modelMatrix;
+
+	vec4 color;
+
+	vec4 clipEquation;
+
+	int baseMapIndex;
+	int alphaTexture;
+	int noTexturing;
+	int srgb;
+
+	float intensity;
+	float alphaThreshold;
+	bool clipEnabled;
+};
+
+void main()
+{
+	fragTexCoord = vertTexCoord;
+	fragColor = vertColor * color;
+	gl_Position = projMatrix * modelViewMatrix * vertPosition;
+
+	if (clipEnabled) {
+		gl_ClipDistance[0] = dot(clipEquation, modelMatrix * vertPosition);
+	}
+}

code/def_files/data/effects/deferred-f.sdr

@@ -24,7 +24,6 @@ layout (std140) uniform globalDeferredData {
 	float middist;
 	float fardist;
 
-	float specFactor;
 	float invScreenWidth;
 	float invScreenHeight;
 };

code/def_files/data/effects/deferred-v.sdr

@@ -2,8 +2,11 @@
 #include "lighting.sdr"
 
 in vec4 vertPosition;
-uniform mat4 modelViewMatrix;
-uniform mat4 projMatrix;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
 
 layout (std140) uniform lightData {
 	vec3 diffuseLightColor;

code/def_files/data/effects/effect-distort-f.sdr

@@ -1,13 +1,20 @@
 in vec4 fragTexCoord;
 in vec4 fragColor;
 in float fragOffset;
+
 out vec4 fragOut0;
+
 uniform sampler2DArray baseMap;
 uniform sampler2D depthMap;
-uniform float window_width;
-uniform float window_height;
 uniform sampler2D distMap;
 uniform sampler2D frameBuffer;
+
+layout (std140) uniform genericData {
+	float window_width;
+	float window_height;
+	float use_offset;
+};
+
 void main()
 {
 	vec2 depthCoord = vec2(gl_FragCoord.x / window_width, gl_FragCoord.y / window_height);

code/def_files/data/effects/effect-distort-v.sdr

@@ -5,9 +5,18 @@ in float vertRadius;
 out vec4 fragTexCoord;
 out vec4 fragColor;
 out float fragOffset;
-uniform mat4 modelViewMatrix;
-uniform mat4 projMatrix;
-uniform float use_offset;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
+layout (std140) uniform genericData {
+	float window_width;
+	float window_height;
+	float use_offset;
+};
+
 void main()
 {
 	gl_Position = projMatrix * modelViewMatrix * vertPosition;

code/def_files/data/effects/effect-f.sdr

@@ -1,21 +1,27 @@
 
 #include "gamma.sdr"
 
-uniform sampler2DArray baseMap;
-uniform sampler2D depthMap;
-uniform float window_width;
-uniform float window_height;
-uniform float nearZ;
-uniform float farZ;
-uniform int linear_depth;
-uniform int srgb;
-uniform int blend_alpha;
 in float fragRadius;
 in vec4 fragPosition;
 in vec4 fragTexCoord;
 in vec4 fragColor;
+
 out vec4 fragOut0;
 
+uniform sampler2DArray baseMap;
+uniform sampler2D depthMap;
+
+layout (std140) uniform genericData {
+	float window_width;
+	float window_height;
+	float nearZ;
+	float farZ;
+	int linear_depth;
+	int srgb;
+	int blend_alpha;
+};
+
+
 void main()
 {
 	vec4 fragmentColor = texture(baseMap, fragTexCoord.xyz);
@@ -39,7 +45,7 @@ void main()
 		fragDepthLinear = ( 2.0 * farZ * nearZ ) / ( farZ + nearZ - gl_FragCoord.z * (farZ-nearZ) );
 	}
 	// assume UV of 0.5, 0.5 is the centroid of this sphere volume
-	float depthOffset = sqrt(pow(fragRadius, 2.0) - pow(offset_len, 2.0));
+	float depthOffset = sqrt((fragRadius*fragRadius) - (offset_len*offset_len));
 	float frontDepth = fragDepthLinear - depthOffset;
 	float backDepth = fragDepthLinear + depthOffset;
 	float intensity = smoothstep(max(nearZ, frontDepth), backDepth, sceneDepthLinear);

code/def_files/data/effects/effect-g.sdr

@@ -1,14 +1,21 @@
 layout (points) in;
 layout (triangle_strip, max_vertices = 4) out;
+
 in vec3 geoUvec[];
 in float geoRadius[];
 in vec4 geoColor[];
 in float geoArrayIndex[];
+
 out float fragRadius;
 out vec4 fragPosition;
 out vec4 fragTexCoord;
 out vec4 fragColor;
-uniform mat4 projMatrix;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
 void main(void)
 {
 	vec3 forward_vec = vec3(0.0, 0.0, 1.0);

code/def_files/data/effects/effect-v.sdr

@@ -1,7 +1,9 @@
+
 in vec4 vertPosition;
 in vec4 vertTexCoord;
 in vec4 vertColor;
 in float vertRadius;
+
 #ifdef FLAG_EFFECT_GEOMETRY
  in vec3 vertUvec;
  out vec3 geoUvec;
@@ -14,28 +16,25 @@ in float vertRadius;
  out vec4 fragTexCoord;
  out vec4 fragColor;
 #endif
-#ifdef FLAG_EFFECT_DISTORTION
-out float fragOffset;
-uniform float use_offset;
-#endif
-uniform mat4 modelViewMatrix;
-uniform mat4 projMatrix;
+
+layout (std140) uniform matrixData {
+	mat4 modelViewMatrix;
+	mat4 projMatrix;
+};
+
 void main()
 {
-	#ifdef FLAG_EFFECT_GEOMETRY
-	 geoRadius = vertRadius;
-	 geoUvec = vertUvec;
-	 gl_Position = modelViewMatrix * vertPosition;
-	 geoColor = vertColor;
-	 geoArrayIndex = vertTexCoord.z;
-	#else
-	 fragRadius = vertRadius;
-	 gl_Position = projMatrix * modelViewMatrix * vertPosition;
-	 fragPosition = modelViewMatrix * vertPosition;
-	 fragTexCoord = vec4(vertTexCoord.xyz, 0.0);
-	 fragColor = vertColor;
-	#endif
-	#ifdef FLAG_EFFECT_DISTORTION
-	fragOffset = vertRadius * use_offset;
-	#endif
+#ifdef FLAG_EFFECT_GEOMETRY
+	geoRadius = vertRadius;
+	geoUvec = vertUvec;
+	gl_Position = modelViewMatrix * vertPosition;
+	geoColor = vertColor;
+	geoArrayIndex = vertTexCoord.z;
+#else
+	fragRadius = vertRadius;
+	gl_Position = projMatrix * modelViewMatrix * vertPosition;
+	fragPosition = modelViewMatrix * vertPosition;
+	fragTexCoord = vec4(vertTexCoord.xyz, 0.0);
+	fragColor = vertColor;
+#endif
 }