Automated build commit

prevent the ship select dialog from crashing if there are too many IFFs

.github/CODEOWNERS

@@ -8,3 +8,5 @@ code/scpui/ @asarium
 code/scripting/ @asarium
 
 code/controlconfig/ @z64555
+
+code/model/modelanimation*.* @bmagnu

.github/workflows/build-nightly.yaml

@@ -15,7 +15,7 @@ jobs:
         configuration: [FastDebug, Release]
     name: Linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-e29f882
+    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
     steps:
       - name: Cache Qt
         id: cache-qt-lin

.github/workflows/build-release.yaml

@@ -16,6 +16,17 @@ jobs:
       - name: Create Release
         id: create_release
         uses: actions/create-release@v1
+        # Creates a release package page on github
+        # create_release.inputs:      (notable inputs)
+        #   allowUpdates=false        if true, update an existing release if it exists
+        #   artifactErrorsFailBuild=false   if true, fails the build should artifact read/write errors occur
+        #   artifacts                 optional set of paths to artifacts to upload to the release. comma delimited.
+        #   removeArtifacts=false     if true, remove existing artifacts
+        #   replaceArtifacts=false    if true, replace/overwrite existing artifacts
+        # create_release.outputs:
+        #   id          id of the created release
+        #   html_url    HTML URL of the release
+        #   upload_url  FTP URL of the release where assets are uploaded
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
         with:
@@ -28,27 +39,65 @@ jobs:
           echo -n "${{ steps.create_release.outputs.upload_url }}" > upload_url
       - name: Persist upload URL
         uses: actions/upload-artifact@v2
+        # Upload the url file for use with other runners
+        # upload-artifact.inputs:
+        #   if-no-files-found=warn  What to do if path fails to find any files.
+        #       warn      Display a warning but do not fail the action
+        #       error     Display an error and fail the action
+        #       ignore    No display, No fail
+        #   retention-days=0    Days to keep the artifact.
+        #       0     Use default retention policy of the repo
+        #       1~90  Min 1, Max 90 days to keep the artifact unless changed by repo settings page
         with:
-          name: upload_url
-          path: ${{ github.workspace }}/upload_url
+          name: upload_url  # name of artifact
+          path: ${{ github.workspace }}/upload_url  # source location of artifact to upload
 
   build_linux:
     strategy:
       matrix:
+        # Run this job for each configuration
+        # The current config running is accesible with `matrix.configuration`
         configuration: [FastDebug, Release]
     name: Linux
-    needs: create_release
+    needs: create_release   # Don't run this job until create_release is done and successful
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-e29f882
+    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
     steps:
       - name: Cache Qt
         id: cache-qt-lin
         uses: actions/cache@v1
+        # cache the Qt directory so we don't have to reinstall it every time
+        # cache.inputs:
+        #   path - A list of files, directories, and wildcard patterns to cache and restore. See @actions/glob for supported patterns.
+        #   key - An explicit key for restoring and saving the cache
+        #   restore-keys - An ordered list of keys to use for restoring the cache if no cache hit occurred for key
+        # cache.outputs:
+        #   cache-hit   true when an exact match was found for the key, false otherwise.
         with:
           path: ${{ github.workspace }}/../Qt
           key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
       - name: Install Qt
         uses: jurplel/install-qt-action@v2
+        # installs Qt in the action workflow
+        # install-qt-action.inputs:
+        #   version     desired qt version to install
+        #   host        Host platform of Qt, default to platform used by runs-on
+        #   target      target platform of Qt, default to desktop
+        #   arch        target architecture of Qt, only used for windows or android builds
+        #   dir         root dir Qt will be installed to
+        #   install-deps    if true, auto-install dependencies on linux. Default true
+        #   modules     whitespace delimited list string of additional addon modules to install
+        #   archives    whitespace delimited list string of Qt archives to install
+        #   cached      if true, Don't download Qt but set ENVARs; use with cache.outputs.cache-hit
+        #   setup-python    Set to false to skip using setup-python to find/download a valid python version
+        #   set-env     if true, set ENVARs; default = false
+        #   aqtversion  version of aqtinstall to use; default = 2.0.0
+        #   py7zrversion    version of py7zr to use; default = 0.16.1
+        #   extra       additional arguments to pass to aqinstall
+        # ENVARS set:
+        #   Qt5_DIR / Qt6_DIR
+        #   Qt bin dir appended to PATH
+        #   QT_PLUGIN_PATH, QML2_IMPORT_PATH, PKG_CONFIG_PATH, LD_LIBRARY_PATH
         with:
           version: ${{ env.QT_VERSION }}
           dir: ${{ github.workspace }}/..
@@ -57,9 +106,10 @@ jobs:
           aqtversion: ==1.1.3
 
       - uses: actions/checkout@v1
+        # checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.
         name: Checkout
         with:
-          submodules: true
+          submodules: true  # `true` to checkout submodules, `recursive` to recursively checkout submodules
       - name: Configure CMake
         env:
           CONFIGURATION: ${{ matrix.configuration }}
@@ -97,38 +147,52 @@ jobs:
         name: Checkout
         with:
           submodules: true
-          fetch-depth: '0'
+          fetch-depth: '0'  # value 0 to fetch all history and tags for all branches
       - name: Download upload URL
         uses: actions/download-artifact@v1
+        # Downloads and extracts uploaded artifact by name
+        # github_token  default ${{secrets.GITHUB_TOKEN}}
+        # name      name of artifact to download
+        # latest    Download latest artifact (default true)
+        # path      Where to save the artifact, (default extract_here)
+        # repo      Source repo of artifact (default ${{github.repository}})
         with:
           name: upload_url
           path: .
       - name: Extract upload URL
+        # Extract the URL from file and stuff it into a shell variable
         id: extractUploadUrl
         run: echo "::set-output name=upload_url::$(cat upload_url)"
       - name: Download Release builds
-        uses: actions/download-artifact@v1
+        # Grab the release builds
+        uses: actions/download-artifact@v2
         with:
           name: linux-Release
           path: builds
       - name: Download FastDebug builds
+        # Grab the debug builds
         uses: actions/download-artifact@v2
         with:
           name: linux-FastDebug
           path: builds
       - name: Create Distribution package
+        # Zip both builds together
         id: generate_package
         working-directory: ./builds
         run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
       - name: Upload result package
-        uses: actions/upload-release-asset@v1
+        # Stash the result to artifact filespace
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ steps.generate_package.outputs.package_name }}
+          path: ${{ steps.generate_package.outputs.package_path }}
+      - name: Publish result package
+        # publish the zipped result
+        uses: softprops/action-gh-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
+          files: ${{ steps.generate_package.outputs.package_path }}
 
   build_windows:
     strategy:
@@ -141,16 +205,19 @@ jobs:
     runs-on: windows-2019
     steps:
       - uses: actions/checkout@v1
+        # Checkout repo
         name: Checkout
         with:
           submodules: true
       - name: Cache Qt
+        # Cache Qt
         id: cache-qt-win
         uses: actions/cache@v1
         with:
           path: ${{ github.workspace }}/../Qt
           key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
       - name: Install Qt (32 bit)
+        # Install Qt 32bit if matrix.arch == Win32
         uses: jurplel/install-qt-action@v2
         if: ${{ matrix.arch == 'Win32' }}
         with:
@@ -160,6 +227,7 @@ jobs:
           cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
           aqtversion: ==0.8
       - name: Install Qt (64 bit)
+        # Install Qt 64bit if matrix.arch == x64
         uses: jurplel/install-qt-action@v2
         if: ${{ matrix.arch == 'x64' }}
         with:
@@ -204,39 +272,47 @@ jobs:
         with:
           name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
           path: ${{ github.workspace }}/build/install/*
+
   windows_zip:
     name: Build Windows distribution zip
     needs: build_windows
     runs-on: ubuntu-latest
     container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     strategy:
+      fail-fast: false  # Run the other jobs in the matrix instead of failing them
       matrix:
         arch: [Win32, x64]
         simd: [SSE2, AVX]
+
     steps:
       - uses: actions/checkout@v1
         name: Checkout
         with:
           submodules: true
           fetch-depth: '0'
+
       - name: Download upload URL
         uses: actions/download-artifact@v1
         with:
           name: upload_url
           path: .
+
       - name: Extract upload URL
         id: extractUploadUrl
         run: echo "::set-output name=upload_url::$(cat upload_url)"
+
       - name: Download Release builds
-        uses: actions/download-artifact@v1
+        uses: actions/download-artifact@v2
         with:
           name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
           path: builds
+
       - name: Download FastDebug builds
         uses: actions/download-artifact@v2
         with:
           name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
           path: builds
+
       - name: Create Distribution package
         id: generate_package
         working-directory: ./builds
@@ -245,21 +321,33 @@ jobs:
           ARCH: ${{ matrix.arch }}
           SIMD: ${{ matrix.simd }}
         run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
+
       - name: Upload result package
-        uses: actions/upload-release-asset@v1
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ steps.generate_package.outputs.package_name }}
+          path: ${{ steps.generate_package.outputs.package_path }}
+
+      - name: Upload debug package
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ steps.generate_package.outputs.debug_name }}
+          path: ${{ steps.generate_package.outputs.debug_path }}
+
+      - name: Publish packages
+        uses: softprops/action-gh-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.package_path }}
-          asset_name: ${{ steps.generate_package.outputs.package_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
-      - name: Upload debug symbols
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
-          asset_path: ${{ steps.generate_package.outputs.debug_path }}
-          asset_name: ${{ steps.generate_package.outputs.debug_name }}
-          asset_content_type: ${{ steps.generate_package.outputs.debug_mime }}
+          files: |
+            ${{ steps.generate_package.outputs.package_path }}
+            ${{ steps.generate_package.outputs.debug_path }}
+
+  post_build:
+    name: Post builds to Nebula and Forum
+    needs: [linux_zip, windows_zip]
+    uses: ./.github/workflows/post-build-release.yaml
+    with:
+      linux_result: ${{ needs.build_linux.result }}
+      windows_result: ${{ needs.build_windows.result }}
+      releaseTag: ${{ github.ref_name }}

.github/workflows/build-standalone.yaml

@@ -8,6 +8,7 @@ on:
 
 jobs:
   build_images:
+    if: github.repository == 'scp-fs2open/fs2open.github.com'
     strategy:
       matrix:
         configuration: [FastDebug, Release]

.github/workflows/build-test.yaml

@@ -15,7 +15,7 @@ jobs:
         configuration: [FastDebug, Release]
     name: Linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-e29f882
+    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
     steps:
       - name: Cache Qt
         id: cache-qt-lin

.github/workflows/cache-master.yaml

@@ -0,0 +1,62 @@
+name: Build caches for master
+
+on:
+  push:
+    branches:
+      - master
+
+env:
+  QT_VERSION: 5.12.9
+
+jobs:
+  build_linux:
+    strategy:
+      matrix:
+        configuration: [Debug, Release]
+        compiler: [gcc-5, gcc-10]
+        cmake_options: [""]
+        include:
+          # Also include configurations that check if the code compiles without the graphics backends
+          - configuration: Debug
+            compiler: gcc-10
+            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
+          - configuration: Release
+            compiler: gcc-10
+            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
+    name: Linux
+    runs-on: ubuntu-latest
+    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
+    steps:
+      - name: Cache Qt
+        id: cache-qt-lin
+        uses: actions/cache@v1
+        with:
+          path: ${{ github.workspace }}/../Qt
+          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v2
+        with:
+          version: ${{ env.QT_VERSION }}
+          dir: ${{ github.workspace }}/..
+          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
+          setup-python: 'false'
+          aqtversion: ==1.1.3
+
+      - uses: actions/checkout@v1
+        name: Checkout
+        with:
+          submodules: true
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
+
+      - name: Configure CMake
+        env:
+          CONFIGURATION: ${{ matrix.configuration }}
+          COMPILER: ${{ matrix.compiler }}
+          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
+        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
+      - name: Compile
+        working-directory: ./build
+        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all

.github/workflows/post-build-release.yaml

@@ -0,0 +1,64 @@
+name: Post Release builds
+
+on:
+  workflow_call:
+    # Trigger when called by other workflows
+    inputs:
+      linux_result:   # job.result; either success, failure, canceled or skipped
+        required: true
+        type: boolean
+      windows_result: # job.result
+        required: true
+        type: boolean
+      releaseTag:
+        required: true
+        type: string
+
+  workflow_dispatch:
+    # Trigger manually from Github
+    inputs:
+      releaseTag:
+        description: Release Tag
+        required: true
+        type: string
+
+env:
+  GITHUB_REPO: ${{ github.repository }} # repo this workflow was called from
+  INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
+  INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
+  NEBULA_USER: ${{ secrets.NEBULA_USER }}
+  NEBULA_PASSWORD: ${{ secrets.NEBULA_PASSWORD }}
+  HLP_API: ${{ secrets.HLP_API }}
+  HLP_KEY: ${{ secrets.HLP_KEY }}
+  RELEASE_TAG: ${{ github.event.inputs.releaseTag }}
+
+jobs:
+  post_builds:
+    name: Post builds on Nebula and the forums
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: '0'
+
+      - name: Install Python dependencies
+        run: pip install -r ci/post/requirements.txt
+
+      - name: Post Builds (Auto trigger)
+        if: ${{ github.event_name == 'workflow_call' }}
+        env:
+          LINUX_RESULT: ${{ github.event.inputs.linux_result }}
+          WINDOWS_RESULT: ${{ github.event.inputs.windows_result }}
+        run: python ci/post/main.py release
+
+      - name: Post Builds (Manual trigger)
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        # assume user knows what they're doing...
+        env:
+          LINUX_RESULT: success
+          WINDOWS_RESULT: success
+        run: |
+          echo "releaseTag= ${{ github.event.inputs.releaseTag }}"
+          echo "repository= ${{ github.repository }}"
+          python ci/post/main.py release

.github/workflows/test-pull_request.yaml

@@ -22,7 +22,7 @@ jobs:
             cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
     name: Linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-e29f882
+    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
     steps:
       - name: Cache Qt
         id: cache-qt-lin
@@ -44,6 +44,11 @@ jobs:
         with:
           submodules: true
           fetch-depth: 0
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
+
       - name: Configure CMake
         env:
           CONFIGURATION: ${{ matrix.configuration }}

ci/post/file_list.py

@@ -0,0 +1,228 @@
+import re # regex module
+from ftplib import FTP, error_perm
+from itertools import groupby
+from typing import List, Tuple, Dict
+
+import requests  # HTTP requests module
+
+from util import retry_multi, GLOBAL_TIMEOUT	# from util.py
+
+
+class ReleaseFile:
+    """! Class representing a Released file on Nebula
+
+    `name`: str
+        Mod (or build) name,
+    `url`: str
+        Primary host URL,
+    `group`: str
+        Mod group string,
+    `subgroup`: str
+        Mod subgroup string,
+    `mirrors`: List[str]
+        List of URL's of FTP mirrors
+    """
+    def __init__(self, name, url, group, subgroup=None, mirrors=None):
+        if mirrors is None:
+            mirrors = []
+        self.mirrors = mirrors
+        self.subgroup = subgroup
+        self.group = group
+        self.url = url
+        self.name = name
+
+        self.base_url = "/".join(url.split('/')[0:-1]) + "/"
+        self.filename = url.split('/')[-1]
+
+        # A list of tuples of (filename, hash)
+        self.content_hashes = None
+
+        self.hash = None
+        self.size = 0
+    
+    def __repr__(self):
+        return repr((self.name))
+
+
+class SourceFile:
+    """! Class represeting a source file
+
+    `name`: str
+        File name,
+    `url`: str
+        FTP URL,
+    `group`
+        <unknown>
+ 
+    @details More details
+    """
+    def __init__(self, name, url, group):
+        self.group = group
+        self.url = url
+        self.name = name
+
+
+class FileGroup:
+    """! Represents a file group
+
+    `name`: str
+        Name of this group
+    `files`: List[ReleaseFile]
+        List of files within this group
+    `mainFile`: str
+        If this FileGroup has a subgroup, `mainFile` is the head of that group
+    `subFiles`: List[ReleaseFile]
+        Files within a subgroup
+    """
+
+    def __init__(self, name, files: List[ReleaseFile]):
+        self.files = files
+        self.name = name
+
+        if len(files) == 1:
+            self.mainFile = files[0]
+            self.subFiles = {}
+        else:
+            self.mainFile = None
+            subFiles = []
+            for file in files:
+                # We only have subcategories for Windows where SSE2 is the main group
+                if file.subgroup == "SSE2":
+                    self.mainFile = file
+                else:
+                    subFiles.append(file)
+
+            self.subFiles = dict(((x[0], next(x[1])) for x in groupby(subFiles, lambda f: f.subgroup)))
+
+
+def get_release_files(tag_name, config) -> Tuple[List[ReleaseFile], Dict[str, SourceFile]]:
+    """! Brief Gets the binary and source files from the Github Release server
+
+    @param[in] `tag_name` Git tag of the current release
+    @param[in] `config`   confi metadata set in main.py
+
+    @returns `List[ReleaseFile]`        List of release files
+    @returns `Dict[str, SourceFile]`    Dictionary of source files
+
+    @details Sends an `HTTP GET` request to github using their REST API to retrieve metadata.  The files are not
+        actually downloaded here, just their metadata is gathered and organized in their respective container for later
+        use.
+    """
+
+    @retry_multi(5)	# retry at most 5 times
+    def execute_request(path):
+        """!
+        @brief Performs a GET request with the given path. To be used with Github's REST API.
+        @returns If successful, returns a .JSON object
+        """
+        headers = {
+            "Accept": "application/vnd.github.v3+json"
+        }
+        url = "https://api.github.com" + path
+
+        # GET https://api.github.com/<path> Accept: "application/vnd.github.v3+json"
+
+        response = requests.get(url, headers=headers, timeout=GLOBAL_TIMEOUT)
+
+        response.raise_for_status() # Raise a RequestException if we failed, and trigger retry
+
+        return response.json()
+
+    build_group_regex = re.compile("fs2_open_.*-builds-([^.-]*)(-([^.]*))?.*")  # regex for matching binary .zip's and .7z's
+    source_file_regex = re.compile("fs2_open_.*-source-([^.]*)?.*") # regex for matching source .zip's and .7z's
+
+    # Get the github release metadata of the given tag name
+    response = execute_request(
+        "/repos/{}/releases/tags/{}".format(config["github"]["repo"], tag_name))
+
+    # Extract the binary and source files from the response["asset"] metadata
+    binary_files = []
+    source_files = {}
+    for asset in response["assets"]:
+        url = asset["browser_download_url"]
+        name = asset["name"]
+
+        group_match = build_group_regex.match(name)
+
+        if group_match is not None:
+            platform = group_match.group(1)
+            # x64 is the Visual Studio name but for consistency we need Win64
+            if platform == "x64":
+                platform = "Win64"
+
+            binary_files.append(ReleaseFile(name, url, platform, group_match.group(3)))
+        else:
+            group_match = source_file_regex.match(name)
+
+            if group_match is None:
+                continue
+
+            group = group_match.group(1)
+
+            source_files[group] = SourceFile(name, url, group)
+
+    binary_files.sort(key=lambda ReleaseFile: ReleaseFile.name)
+
+    return binary_files, source_files
+
+
+def get_ftp_files(build_type, tag_name, config) -> List[ReleaseFile] :
+    """!
+    @brief Gets file metadata for nightlies hosted on FTP, as determined by config["ftp"] attributes
+    
+    @param [in] `build_type` Unknown str
+    @param [in] `tag_name`   Github tag name of the release
+    @param [in] `config`     config metadata set in main.py
+    """
+
+    tag_regex = re.compile("nightly_(.*)")
+    build_group_regex = re.compile("nightly_.*-builds-([^.]+).*")
+
+    files = []
+    try:
+        with FTP(config["ftp"]["host"], config["ftp"]["user"], config["ftp"]["pass"]) as ftp:
+            # extract version
+            version_str = tag_regex.match(tag_name).group(1)
+
+            # extract filepath w/ version
+            # then list all ftp hits with that path
+            path_template = config["ftp"]["path"]
+            path = path_template.format(type=build_type, version=version_str)
+            file_entries = list(ftp.mlsd(path, ["type"]))
+
+            # get all ftp hits of type file
+            for entry in file_entries:
+                if entry[1]["type"] == "file":
+                    files.append(entry[0])
+    except error_perm:
+        print("Received permanent FTP error!")
+        return []
+
+    out_data = []
+    for file in files:
+        # from the file list, extract only nightly files
+        file_match = build_group_regex.match(file)
+        if file_match is None:
+            print("Ignoring non nightly file '{}'".format(file))
+            continue
+
+        group_match = file_match.group(1)
+        primary_url = None
+        mirrors = []
+
+        # x64 is the name Visual Studio uses but Win64 works better for us since that gets displayed in the nightly post
+        if "x64" in group_match:
+            group_match = group_match.replace("x64", "Win64")
+
+        # construct the download URL list for all mirrors.  The first listed ftp location is taken as the Primary
+        for mirror in config["ftp"]["mirrors"]:
+            download_url = mirror.format(type=build_type, version=version_str, file=file)
+            if primary_url is None:
+                primary_url = download_url
+            else:
+                mirrors.append(download_url)
+
+        # Form the List[ReleaseFile] list with the download URL links
+        out_data.append(ReleaseFile(file, primary_url, group_match, None, mirrors))
+
+    return out_data

ci/post/forum.py

@@ -0,0 +1,65 @@
+from typing import List
+
+import requests
+import semantic_version
+from mako.template import Template
+
+from file_list import ReleaseFile
+
+
+class ForumAPI:
+    def __init__(self, config):
+        self.config = config
+
+    def create_post(self, title, content, board):
+        print(self.config["hlp"]["api"])
+        print(self.config["hlp"]["key"])
+        if (self.config["hlp"]["api"] == "") or (self.config["hlp"]["key"] == ""):
+            print("Post failed! No API or API_KEY given!")
+            return
+
+        resp = requests.post(self.config["hlp"]["api"], data={
+            "api_key": self.config["hlp"]["key"],
+            "board": str(board),
+            "subject": title,
+            "body": content
+        })
+
+        if resp.text != "OK":
+            print("Post failed! Response: %s" %resp.text)
+
+    def post_nightly(self, date, revision, files, log, success):
+        print("Posting nightly thread...")
+
+        title = "Nightly: {} - Revision {}".format(date, revision)
+
+        template = Template(filename=self.config["templates"]["nightly"])
+        rendered = template.render_unicode(**{
+            "date": date,
+            "revision": revision,
+            "files": files,
+            "log": log,
+            "success": success
+        })
+
+        print("Creating post...")
+        self.create_post(title, rendered, self.config["nightly"]["hlp_board"])
+
+    def post_release(self, date, version: semantic_version.Version, groups, sources):
+        print("Posting release thread...")
+
+        title = "Release: {}".format(version)
+
+        template = Template(
+            filename=self.config["templates"]["release"].format(major=version.major, minor=version.minor),
+            module_directory='/tmp/mako_modules')
+        rendered = template.render_unicode(**{
+            "date": date,
+            "version": version,
+            "groups": groups,
+            "sources": sources
+        }).strip("\n")
+
+        print("Creating post...")
+
+        self.create_post(title, rendered, self.config["release"]["hlp_board"])

ci/post/installer.py

@@ -0,0 +1,88 @@
+import os
+import hashlib
+import tarfile
+import traceback
+import zipfile
+from tempfile import NamedTemporaryFile
+from zipfile import ZipFile
+
+import requests
+import sys
+from mako.template import Template
+
+from file_list import ReleaseFile
+from util import GLOBAL_TIMEOUT
+
+
+def _download_file(url, dest_file, session):
+    print("Downloading " + url)
+    # NOTE the stream=True parameter
+    r = session.get(url, stream=True, timeout=GLOBAL_TIMEOUT)
+    for chunk in r.iter_content(chunk_size=1024):
+        if chunk:  # filter out keep-alive new chunks
+            dest_file.write(chunk)
+    dest_file.flush()
+
+
+def _gen_hash(fileobj, hash_alg):
+    h = hashlib.new(hash_alg)
+    while True:
+        data = fileobj.read(4096)
+
+        if not data:
+            break
+
+        h.update(data)
+
+    return h.hexdigest()
+
+
+def get_hashed_file_list(file: ReleaseFile, session: requests.Session = None, hash_alg: str = "sha256"):
+    if session is None:
+        session = requests.Session()
+
+    with NamedTemporaryFile('w+b', suffix=file.filename) as local_file:
+        _download_file(file.url, local_file, session)
+
+        filename = local_file.name
+        hash_list = []
+
+        local_file.seek(0)
+        file.hash = _gen_hash(local_file, hash_alg)
+        file.size = os.stat(filename).st_size
+
+        try:
+            if tarfile.is_tarfile(filename):
+                with tarfile.open(filename) as archive:
+                    for entry in archive:
+                        if not entry.isfile():
+                            continue
+
+                        print("Computing hash for " + entry.name)
+                        fileobj = archive.extractfile(entry)
+                        hash_list.append((entry.path, _gen_hash(fileobj, hash_alg)))
+            elif zipfile.is_zipfile(filename):
+                with ZipFile(filename) as archive:
+                    for entry in archive.infolist():
+                        # Python 3.6 has is_dir but that version is relatively new so we'll use the "safe" version here
+                        if entry.filename.endswith('/'):
+                            continue
+
+                        print("Computing hash for " + entry.filename)
+                        with archive.open(entry) as fileobj:
+                            hash_list.append((entry.filename, _gen_hash(fileobj, hash_alg)))
+            else:
+                raise NotImplementedError("Unsupported archive type!")
+        except:
+            traceback.print_exception(*sys.exc_info())
+            return
+
+        file.content_hashes = hash_list
+
+
+def render_installer_config(version, groups, config):
+    template = Template(filename=config["templates"]["installer"], module_directory='/tmp/mako_modules')
+    return template.render(**{
+        "version": version,
+        "groups": groups,
+    }).strip("\n")

ci/post/main.py

@@ -0,0 +1,260 @@
+# Post-build python script
+# Uploads build packages to Nebula and creates a forum post on https://www.hard-light.net
+# Uses the following environment variables (Set by the github action workflow before execution)
+
+# FSO versioning
+# FSO_VERSION_MAJOR
+# FSO_VERSION_MINOR
+# FSO_VERSION_BUILD
+
+# Credentials into IndieGames file host
+# INDIEGAMES_USER:
+# INDIEGAMES_SSHPASS:
+
+# Credentials into Nebula Mod Database
+# NEBULA_USER:
+# NEBULA_PASSWORD:
+
+# Credentials into hard-light.net for forum post
+# HLP_API:
+# HLP_KEY:
+
+# LINUX_RESULT: bool, if the linux builds were sucessfully uploaded
+# WINDOWS_RESULT: bool, if the windows builds were successfully uploaded
+
+import sys
+import os
+import re
+from subprocess import check_output
+from datetime import datetime
+from itertools import groupby
+
+import semantic_version
+
+# local .py files
+import file_list
+import installer
+import nebula
+import forum
+
+# Compile regexes for extracting version components
+MAJOR_VERSION_PATTERN = re.compile("set_if_not_defined\(FSO_VERSION_MAJOR (\d+)\)")
+MINOR_VERSION_PATTERN = re.compile("set_if_not_defined\(FSO_VERSION_MINOR (\d+)\)")
+BUILD_VERSION_PATTERN = re.compile("set_if_not_defined\(FSO_VERSION_BUILD (\d+)\)")
+
+LOG_FORMAT = """
+------------------------------------------------------------------------%n
+commit %h%nAuthor: %an <%ad>%n
+Commit: %cn <%cd>%n%n    %s
+"""
+DATEFORMAT_VERSION = "%Y%m%d"
+DATEFORMAT_FORUM = "%d %B %Y"
+
+def _match_version_number(text, regex):
+	"""! Extracts the version component represented by `regex` from `text`
+	
+	@param [in] `text`  Filename with version string 'MAJOR.MINOR.BUILD'
+	@param [in] `regex` Regex pattern of component to look for
+
+	@return The version component as integer
+	"""
+	match = regex.search(text)
+	return int(match.group(1))
+	
+
+def get_source_version(date_version: datetime, tag_name: str) -> semantic_version.Version:
+	"""! Retrieves the build's version from `version.cmake`, forms it as a string, and appends the date
+
+	@param[in] `date_version` Date this build is published for release
+	@param[in] `tag_name`     Tag of this release, used to determine if release, rc, or nightly
+
+	@return If release: `MAJOR_VERSION.MINOR_VERSION.BUILD_VERSION` from version.cmake, or
+	@return If rc:      `MAJOR_VERSION.MINOR_VERSION.BUILD_VERSION` from tag_name, or
+	@return If nightly: `MAJOR_VERSION.MINOR_VERSION.BUILD_VERSION-date` from version.cmake
+	"""
+	major = minor = build = version = 0
+	with open(os.path.join("..", "..", "cmake", "version.cmake"), "r") as f:
+		filetext = f.read()
+		major = _match_version_number(filetext, MAJOR_VERSION_PATTERN)
+		minor = _match_version_number(filetext, MINOR_VERSION_PATTERN)
+		build = _match_version_number(filetext, BUILD_VERSION_PATTERN)
+
+	if "rc" in tag_name.lower():
+		# Release candidates idenfity with their unstable version (ex: 21.5.0-03052022) within the game and the logs, but
+		# the builds are named with the target release version (ex: 22.0.0).  Since this script works on the builds we
+		# need to grab the target release version from tag_name
+		x = tag_name.upper().split("_")
+		# "release" = x[0], year = x[1], major = x[2], minor = x[3], build = x[4], 
+		version = semantic_version.Version("{}.{}.{}-{}".format(x[1], x[2], x[3], x[4]))
+
+	elif "release" in tag_name.lower():
+		version = semantic_version.Version("{}.{}.{}".format(major, minor, build))
+
+	elif "nightly" in tag_name.lower():
+		version = semantic_version.Version("{}.{}.{}-{}".format(major, minor, build, date_version))
+	
+	else:	
+		print("ERROR: malformed tag_name %s" % tag_name)
+		sys.exit(1)
+
+	print("version: {}".format(version))
+	print("version.prerelease: {}".format(version.prerelease))
+	return version
+
+
+def main():
+	os.chdir(os.path.dirname(__file__))	# Change working directory to this file's directory
+
+	# Aggregate configuration data in a dictionary
+	config = {
+		"github": {
+			"repo": os.environ["GITHUB_REPO"],
+		},
+		"ftp": {
+			"host": "scp.indiegames.us",
+			"user": os.environ["INDIEGAMES_USER"],
+			"pass": os.environ["INDIEGAMES_SSHPASS"],
+			"path": "public_html/builds/{type}/{version}/",
+			"mirrors": (
+				"https://porphyrion.feralhosting.com/datacorder/builds/{type}/{version}/{file}",
+				"http://scp.indiegames.us/builds/{type}/{version}/{file}",
+			),
+		},
+		"nebula": {
+			"user": os.environ["NEBULA_USER"],
+			"password": os.environ["NEBULA_PASSWORD"],
+		},
+		"hlp": {
+			"api": os.environ["HLP_API"],
+			"key": os.environ["HLP_KEY"],
+		},
+		"templates": {
+			"nightly": "nightly.mako",
+			"release": "release.mako",
+		},
+		"nightly": {
+			"hlp_board": 173,
+		},
+		"release": {
+			"hlp_board": 50,
+		},
+	}
+
+	# bail if this script is run from a workflow that doesn't identify as a release or nightly
+	if sys.argv[1] not in ("release", "nightly"):
+		print("ERROR: Invalid release mode %s passed. Expected release or nightly!" % sys.argv[1])
+		sys.exit(1)
+
+	tag_name = os.environ["RELEASE_TAG"]	##!< commit tag string
+	date = datetime.now()	##!< current date
+	version = get_source_version(date.strftime(DATEFORMAT_VERSION), tag_name)	##!< form full version string
+	success = os.environ["LINUX_RESULT"] == "success" and os.environ["WINDOWS_RESULT"] == "success"	##!< true if both linux and windows builds successful
+
+	# check that tag_name is actually in the git repo and find the previous tag release
+	tags = check_output(("git", "for-each-ref", "--sort=-taggerdate", "--format='%(tag)'", "refs/tags"), text=True).splitlines()	# retrieve all tags in the repo by using git on the shell
+	# NOTE: check_output returns canonical string representation. use repr() on strings its being compared to
+	previous_tag = None
+	found = False
+
+	for tag in tags:
+		if found:
+			# Look for the "previous" tag with the same configuration ('release_' or 'nightly_')
+			# Assumes older tags have a higher index than newer
+			if tag.startswith("\'" + sys.argv[1] + "_"):
+				previous_tag = tag
+				break
+		elif tag == repr(tag_name):
+			# Ok, found the tag
+			found = True
+
+	if not found:
+		# couldn't find tag, bail
+		print("ERROR: Couldn't find tag %s in repo!" % tag_name)
+		sys.exit(1)
+
+	if not previous_tag:
+		# couldn't find previous tag, bail
+		print("ERROR: Could not find a previous tag for %s!" % tag_name)
+		sys.exit(1)
+
+	if sys.argv[1] == "release":
+		# Release specific action
+		if not tag_name.startswith("release_"):
+			# Safety check tag is from a release
+			print("ERROR: Invalid tag name detected. Expected release_ prefix for release builds but found %s (full ref = %s)" % tag_name, os.environ["GITHUB_REF"])
+			sys.exit(1)
+
+		files, sources = file_list.get_release_files(tag_name, config)
+
+		print("Hashing files")
+		for file in files:
+			installer.get_hashed_file_list(file)
+
+		# Construct the file groups
+		# split the file list into a dictionary of {group: files} pairs using `groupby()`
+		# Since `groupby()` returns a iterator reference to the original files list, we have to do a weird hand toss
+		# to save it as a dictionary
+		## NOTE z64: files need to be sorted or else key duplication will occur!
+		groups = {key: file_list.FileGroup(key, list(group)) for key, group in groupby(files, lambda g: g.group)}
+		
+		# Error check for all group keys and subkeys to be used in the mako.  Do this here for better debugging QoL
+		if "Win32" in groups.keys():
+			if "AVX" not in groups["Win32"].subFiles.keys():
+				print("ERROR: No Win32-AVX builds were detected!")
+				sys.exit(1)
+		else:
+			print("ERROR: No Win32 builds were detected!")
+			sys.exit(1)
+
+		if "Win64" in groups.keys():
+			if "AVX" not in groups["Win64"].subFiles.keys():
+				print("ERROR: No x64-AVX builds were detected!")
+				sys.exit(1)
+		else:
+			print("ERROR: No x64 builds were detected!")
+			sys.exit(1)
+		
+		if "Linux" not in groups.keys():
+			print("ERROR: No Linux builds were detected!")
+			sys.exit(1)
+		
+		# z64: What dose this do???
+		# print(installer.render_installer_config(version, groups, config))
+
+		# Publish release builds to Nebula
+		nebula.submit_release(
+			nebula.render_nebula_release(version, "rc" if version.prerelease else "stable", files, config),
+			config)
+
+		# Publish forum post, using the release.mako template
+		fapi = forum.ForumAPI(config)
+		fapi.post_release(date.strftime(DATEFORMAT_FORUM), version, groups, sources)
+
+	else:
+		# Dead for now, nightly publish is done elsewhere
+		# Nightly specific action
+		if not tag_name.startswith("nightly_"):
+			# safety check tag is from a nightly
+			print("ERROR: Invalid tag name detected. Expected nightly_ prefix for nightly builds but found %s (full ref = %s)" % tag_name, os.environ["GITHUB_REF"])
+			sys.exit(1)
+
+		print("Retrieving file list")
+		files = file_list.get_ftp_files("nightly", tag_name, config)
+
+		print("Hashing files")
+		for file in files:
+			installer.get_hashed_file_list(file)
+
+		# Publish nightly builds to Nebula
+		nebula.submit_release(
+			nebula.render_nebula_release(version, "nightly", files, config),
+			config)
+
+		# Compile commit messages into a log with all commits between this nightly and the previous nightly
+		log = check_output(("git", "log", "%s^..%s^" % (previous_tag, tag_name), "--no-merges", "--stat", "--pretty=format:\"%s\"" % LOG_FORMAT.strip()))
+
+		# Publish forum post, using the nighty.mako template
+		fapi = forum.ForumAPI(config)
+		fapi.post_nightly(date.strftime(DATEFORMAT_FORUM), os.environ["GITHUB_SHA"], files, log, success)
+
+main()

ci/post/nebula.py

@@ -0,0 +1,241 @@
+import os.path
+import sys
+import traceback
+
+import requests
+
+from file_list import ReleaseFile
+from util import retry_multi, GLOBAL_TIMEOUT
+
+metadata = {
+    'type': 'engine',
+    'title': 'FSO',
+    'notes': '',
+    'banner': 'https://fsnebula.org/storage/0d/e7/bf64bcdea9a9c115969cfb784e1ca457d24a7c2da4fc6f213521c3bb6abb.png',
+    'screenshots': [],
+    'videos': [],
+    'first_release': '2017-09-24',
+    'cmdline': '',
+    'mod_flag': ['FSO'],
+    'tile': 'https://fsnebula.org/storage/ec/cc/0bf23e028c26d5175ff52d003bff85b0a17b0ddfc1130d65bdf6d36f6324.png',
+    'logo': None,
+    'release_thread': None,
+    'description': '',
+    'id': 'FSO',
+    'packages': [],
+}
+
+platforms = {
+    'Linux': 'linux',
+    'MacOSX': 'macosx',
+    'Win32-SSE2': 'windows',
+    'Win64-SSE2': 'windows',
+    'Win32-AVX': 'windows',
+    'Win64-AVX': 'windows'
+}
+
+envs = {
+    'Linux': 'linux && x86_64',  # Linux only has 64bit builds
+    'MacOSX': 'macosx',
+    'Win32-SSE2': 'windows',
+    'Win64-SSE2': 'windows && x86_64',
+    'Win32-AVX': 'windows && avx',
+    'Win64-AVX': 'windows && avx && x86_64'
+}
+
+subdirs = {
+    'Win32-SSE2': 'x86',
+    'Win64-SSE2': 'x64',
+    'Win32-AVX': 'x86_avx',
+    'Win64-AVX': 'x64_avx'
+}
+
+
+def render_nebula_release(version, stability, files, config):
+    meta = metadata.copy()
+    meta['version'] = str(version)
+    meta['stability'] = stability  # This can be one of ('stable', 'rc', 'nightly')
+
+    for file in files:
+        if file.content_hashes is None:
+            # The extraction probably failed which is why we don't have any hashes
+            continue
+
+        group = file.group
+
+        # release.py sets subgroup but nightly.py doesn't which means we have to normalize group here.
+        if file.subgroup:
+            group += '-' + file.subgroup
+
+        pkg = {
+            'name': group,
+            'notes': '',
+            'is_vp': False,
+            'files': [{
+                'dest': platforms[group] + '/' + subdirs.get(group, ''),
+                'filesize': file.size,
+                'checksum': ['sha256', file.hash],
+                'urls': [file.url] + file.mirrors,
+                'filename': file.name
+            }],
+            'environment': envs.get(group),
+            'filelist': [],
+            'status': 'required',
+            'folder': None,
+            'dependencies': [],
+            'executables': []
+        }
+
+        for fn, checksum in file.content_hashes:
+            if group in subdirs:
+                dest_fn = subdirs[group] + '/' + fn
+            else:
+                dest_fn = fn
+
+            # If the group is a known platform then we put the binaries into a separate subfolder for each platform
+            if group in platforms:
+                dest_fn = platforms[group] + '/' + dest_fn
+
+            pkg['filelist'].append({
+                'orig_name': fn,
+                'checksum': ('sha256', checksum),
+                'archive': file.name,
+                'filename': dest_fn
+            })
+
+            if group == 'Linux' and fn.endswith('.AppImage'):
+                if 'qtfred' in fn:
+                    if '-FASTDBG' in fn:
+                        label = 'QtFRED Debug'
+                    else:
+                        label = 'QtFRED'
+
+                else:
+                    if '-FASTDBG' in fn:
+                        label = 'Fast Debug'
+                    else:
+                        label = None
+
+                props = {
+                    "x64": True,  # All Linux builds are 64-bit
+                    "sse2": True,  # Linux builds are forced to compile with SSE2 but not AVX
+                    "avx": False,
+                    "avx2": False,
+                }
+
+                pkg['executables'].append({
+                    'file': dest_fn,
+                    'label': label,
+                    'properties': props,
+                })
+            elif group == 'MacOSX' and fn.startswith(os.path.basename(fn) + '.app/'):
+                if 'qtfred' in fn:
+                    if '-FASTDBG' in fn:
+                        label = 'QtFRED Debug'
+                    else:
+                        label = 'QtFRED'
+                else:
+                    if '-FASTDBG' in fn:
+                        label = 'Fast Debug'
+                    else:
+                        label = None
+
+                props = {
+                    "x64": True,  # All Mac builds are 64-bit
+                    "sse2": True,  # There are no forced options on mac but 64-bit always implies SSE2 so we set that here
+                    "avx": False,
+                    "avx2": False,
+                }
+
+                pkg['executables'].append({
+                    'file': dest_fn,
+                    'label': label,
+                    'properties': props,
+                })
+            elif group.startswith('Win') and fn.endswith('.exe'):
+                if 'fred2' in fn:
+                    if '-FASTDBG' in fn:
+                        label = 'FRED2 Debug'
+                    else:
+                        label = 'FRED2'
+
+                elif 'qtfred' in fn:
+                    if '-FASTDBG' in fn:
+                        label = 'QtFRED Debug'
+                    else:
+                        label = 'QtFRED'
+
+                else:
+                    if '-FASTDBG' in fn:
+                        label = 'Fast Debug'
+                    else:
+                        label = None
+
+                props = {
+                    "x64": "x64" in fn,
+                    "sse2": "SSE2" in fn or "AVX" in fn,  # AVX implies SSE2
+                    "avx": "AVX" in fn,  # This conveniently also covers the AVX2 case since AVX2 implies AVX
+                    "avx2": "AVX2" in fn,
+                }
+
+                pkg['executables'].append({
+                    'file': dest_fn,
+                    'label': label,
+                    'properties': props,
+                })
+
+        meta["packages"].append(pkg)
+
+    return meta
+
+
+@retry_multi(5)
+def nebula_request(session, kind, path, **kwargs):
+    uri = "https://fsnebula.org/api/1/{}".format(path)
+
+    request_args = {
+        "timeout": GLOBAL_TIMEOUT
+    }
+    request_args.update(kwargs)
+
+    return session.request(kind, uri, **request_args)
+
+
+def submit_release(meta, config):
+    try:
+        with requests.Session() as session:
+            print('Logging into Nebula...')
+            result = nebula_request(session, 'post', 'login', data={
+                'user': config['nebula']['user'],
+                'password': config['nebula']['password']
+            })
+
+            if result.status_code != 200:
+                print('Login failed!')
+                return False
+
+            data = result.json()
+            if not data['result']:
+                print('Login failed!')
+                return False
+
+            print('Submitting release...')
+            result = nebula_request(session, 'post', 'mod/release', headers={
+                'X-KN-TOKEN': data['token']
+            }, json=meta)
+
+            if result.status_code != 200:
+                print('Request failed!')
+                return False
+
+            data = result.json()
+            if not data['result']:
+                print('ERROR: ' + data['reason'])
+                return False
+
+            print('Success!')
+            return True
+    except Exception:
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(exc_type, exc_value, exc_traceback)
+        return False

ci/post/nightly.mako

@@ -0,0 +1,27 @@
+Here is the nightly for ${date} - Revision ${revision}
+
+% if not success:
+[b][color=red]At least one of the nightly builds failed![/color][/b]
+% endif
+% for file in files:
+
+
+Group: ${file.group}
+[url=${file.url}]${file.name}[/url] \
+    %for mirror in file.mirrors:
+        %if loop.first:
+(\
+        %endif
+[url=${mirror}]Mirror[/url]\
+        %if loop.last:
+)\
+        %else:
+, \
+        %endif
+    %endfor
+
+% endfor
+
+[code]
+${log}
+[/code]

ci/post/release.mako

@@ -0,0 +1,68 @@
+
+<%def name="build(file)">[url=${file.url}]${file.filename}[/url]</%def>
+
+[b]Change log:[/b] (chronologically ordered)
+PLACEHOLDER
+
+[b]Deprecations:[/b]
+PLACEHOLDER
+
+Deprecations are a mechanism in FSO where a certain feature or aspect of the engine has changed or is no longer supported. Since this would normally break existing mods we have the mod table feature "[tt]$Target Version:[/tt]" with which a mod can specify what version of FSO it was developed with. The features listed above will be removed or changed when the target version of a mod is at least the version released in this post.
+
+[size=5pt]Previous [url=https://www.hard-light.net/forums/index.php?topic=97293.0]21.0 Release Thread[/url][/size]
+
+Launchers, if you don't have one already:
+[b]All platforms: [/b] For every day use, we recommend [url=https://www.hard-light.net/forums/index.php?topic=94068.0]Knossos[/url], an integrated solution for downloading and launching mods.
+
+[hidden=Alternative Launchers]
+Cross-platform: [url=http://www.hard-light.net/forums/index.php?topic=89162]wxLauncher 0.12.x Test Build[/url] (ongoing project for a unified launcher, you should upgrade to the latest RC/test build if you have not yet)
+[b]Important:[/b] For best compatibility with FSO 3.8 and later you should use at least wxLauncher 0.12.
+
+Windows:  [url=http://scp.fsmods.net/files/Launcher55g.zip]Launcher 5.5g[/url] ([url=http://scp.indiegames.us/builds/Launcher55g.zip]Mirror[/url]) ([url=http://www.mediafire.com/?wdvzn7hhhzh418m]Mirror[/url]) Not compatible with Windows 8+, use wxLauncher above
+OS X:  Soulstorm's [url=http://www.hard-light.net/forums/index.php/topic,51391.0.html]OS X Launcher 3.0[/url]
+Linux:  [url=http://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[/url] or [url=http://www.hard-light.net/wiki/index.php/Fs2_open_on_Linux/Graphics_Settings]by hand[/url] or whatever you can figure out.[/hidden]
+
+[img]http://scp.indiegames.us/img/windows-icon.png[/img] [color=green][size=12pt]Windows (32/64-bit)[/size][/color]
+[size=8pt]Compiled using GitHub Actions on Windows Server 2019 (10.0.17763), Visual Studio Enterprise 2019[/size]
+
+[b]64-bit:[/b] ${build(groups["Win64"].mainFile)}
+
+[b]32-bit:[/b] ${build(groups["Win32"].mainFile)}
+[size=8pt]This one is based on the SSE2 Optimizations from the MSVC Compiler.[/size]
+
+[hidden=Alternative builds]
+
+[b]64-bit AVX:[/b] ${build(groups["Win64"].subFiles["AVX"])}
+[size=8pt]This one is based on the AVX Optimizations from the MSVC Compiler (fastest build if your CPU supports AVX instructions).[/size]
+
+
+[b]32-bit AVX:[/b] ${build(groups["Win32"].subFiles["AVX"])}
+[size=8pt]This one is based on the AVX Optimizations from the MSVC Compiler.[/size]
+
+[b]What are those SSE, SSE2 and AVX builds I keep seeing everywhere?[/b]
+[url=http://www.hard-light.net/forums/index.php?topic=65628.0]Your answer is in this topic.[/url]
+Don't want to deal with that? Use [url=https://www.hard-light.net/forums/index.php?topic=94068.0]Knossos[/url] and it will download the best build specifically for your PC!
+[/hidden]
+
+[img]http://scp.indiegames.us/img/linux-icon.png[/img] [color=green][size=12pt]Linux 64-bit[/size][/color]
+[size=8pt]Compiled with Ubuntu 16.04 LTS 64-bit, GCC 5[/size]
+${build(groups["Linux"].mainFile)}
+
+These builds use a mechanism called [url=http://appimage.org/]AppImage[/url] which should allow these builds to run on most Linux distributions. However, we recommend that you compile your own builds which will result in less issues.
+Alternatively, if there is a package in your software repository then you should use that. If you are the maintainer of such a package for a distribution then let us know and we will include that here.
+
+
+[img]http://scp.indiegames.us/img/mac-icon.png[/img] [color=green][size=12pt]OS X[/size][/color]
+[b][color=red]Not available[/color][/b] We recently lost access to our Mac CI environment which we usually used for compiling these builds so for the time being, there will be no builds for this OS.
+
+[hidden=TrackIR Users]
+[size=12pt]Important!![/size]
+An external DLL is required for FSO to use TrackIR functions.  The following DLL is simply unpacked in to your main FreeSpace2 root dir.
+TrackIR is only supported on Windows.
+[url=http://www.mediafire.com/download.php?4zw024zrh44etse]TrackIR SCP DLL[/url] ([url=http://scp.fsmods.net/builds/scptrackir.zip]Mirror[/url]) ([url=http://scp.indiegames.us/builds/scptrackir.zip]Mirror[/url])[/hidden]
+
+Known issues:
+[list]
+[li][url=https://github.com/scp-fs2open/fs2open.github.com/issues]Github issues[/url] and [url=https://github.com/scp-fs2open/fs2open.github.com/pulls]pending pull requests[/url][/li]
+[li]See the list of [url=http://scp.indiegames.us/mantis/search.php?project_id=1&status_id%5B%5D=10&status_id%5B%5D=20&status_id%5B%5D=30&status_id%5B%5D=40&status_id%5B%5D=50&priority_id%5B%5D=40&priority_id%5B%5D=50&priority_id%5B%5D=60&sticky_issues=on&sortby=last_updated&dir=DESC&per_page=200&hide_status_id=-2]Fix for next release[/url] bugs - mark a bug as an elevated priority (high, urgent, immediate) to get it included in that filter.[/li]
+[/list]

ci/post/requirements.txt

@@ -0,0 +1,3 @@
+Mako==1.1.5
+requests==2.26.0
+semantic-version==2.8.5

ci/post/util.py

@@ -0,0 +1,46 @@
+# miscellaneous utilities
+
+import os
+import time
+from functools import wraps
+
+from requests import RequestException
+
+GLOBAL_TIMEOUT = 30
+
+def retry_multi(max_retries):
+    """!
+    @brief Decorator - Retry a function `max_retries` times.
+    
+    @param [in] `max_retries` Maximum number of times to retry the decorated function before giving up
+
+    @details  Intended for use with functions from the `request` module, only catches `RequestException`'s
+    @note This has been copied from https://stackoverflow.com/a/23892489
+    """
+
+    def retry(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            num_retries = 0
+            while num_retries <= max_retries:
+                try:
+                    ret = func(*args, **kwargs)
+                    break
+                except RequestException:
+                    if num_retries == max_retries:
+                        raise
+                    num_retries += 1
+                    time.sleep(5)
+            return ret
+
+        return wrapper
+
+    return retry
+
+
+def expand_config_vars(config):
+    """
+    @brief Expands the shell variable for the repo string from `config`
+    """
+
+    config["git"]["repo"] = os.path.expandvars(config["git"]["repo"])

cmake/Cxx11.cmake

@@ -1,15 +1,3 @@
 
-include(WriteCompilerDetectionHeader)
-
 set(CMAKE_CXX_STANDARD_REQUIRED 11)
 set(CMAKE_CXX_STANDARD 11)
-
-get_property(CMAKE_CXX_KNOWN_FEATURES GLOBAL PROPERTY CMAKE_CXX_KNOWN_FEATURES)
-
-write_compiler_detection_header(
-  FILE "${GENERATED_SOURCE_DIR}/scp_compiler_detection.h"
-  PREFIX SCP
-  COMPILERS AppleClang Clang GNU MSVC
-  FEATURES ${CMAKE_CXX_KNOWN_FEATURES}
-  VERSION 3.2
-)

cmake/platformChecks.cmake

@@ -21,8 +21,6 @@ endif()
 
 set(CMAKE_EXTRA_INCLUDE_FILES "cstddef")
 CHECK_TYPE_SIZE("std::max_align_t" STD_MAX_ALIGN_T LANGUAGE CXX)
-set(CMAKE_EXTRA_INCLUDE_FILES "type_traits")
-CHECK_TYPE_SIZE("std::is_trivially_copyable<int>" STD_IS_TRIVIALLY_COPYABLE LANGUAGE CXX)
 set(CMAKE_EXTRA_INCLUDE_FILES)
 
 CHECK_TYPE_SIZE("char32_t" CHAR32_T LANGUAGE CXX)

cmake/platformChecks.h.in

@@ -8,8 +8,6 @@
 #cmakedefine SCP_HAVE_MAX_ALIGN_T
 #cmakedefine SCP_HAVE_STD_MAX_ALIGN_T
 
-#cmakedefine01 HAVE_STD_IS_TRIVIALLY_COPYABLE
-
 #cmakedefine01 IS_64BIT
 
 #cmakedefine01 SCP_HAVE_STRCASECMP

cmake/toolchain-clang.cmake

@@ -100,6 +100,10 @@ set(CMAKE_C_FLAGS_DEBUG ${COMPILER_FLAGS_DEBUG})
 
 set(CMAKE_EXE_LINKER_FLAGS "")
 
+if(DEFINED ENV{LDFLAGS})
+    set(CMAKE_EXE_LINKER_FLAGS $ENV{LDFLAGS})
+endif()
+
 if (CLANG_USE_LIBCXX)
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
 endif()

cmake/toolchain-gcc.cmake

@@ -27,6 +27,11 @@ endif()
 set(COMPILER_FLAGS "")
 set(LINKER_FLAGS "")
 
+# Don't ignore user-set LDFLAGS
+if(DEFINED ENV{LDFLAGS})
+	set(LINKER_FLAGS $ENV{LDFLAGS})
+endif()
+
 if (GCC_USE_GOLD)
 	OPTION(GCC_INCREMENTAL_LINKING "Use incremental linking" OFF)
 	set(LINKER_FLAGS "${LINKER_FLAGS} -fuse-ld=gold")

cmake/version.cmake

@@ -6,8 +6,8 @@ if (EXISTS "${PROJECT_SOURCE_DIR}/version_override.cmake")
     include("${PROJECT_SOURCE_DIR}/version_override.cmake")
 endif()
 
-set_if_not_defined(FSO_VERSION_MAJOR 21)
-set_if_not_defined(FSO_VERSION_MINOR 1)
+set_if_not_defined(FSO_VERSION_MAJOR 22)
+set_if_not_defined(FSO_VERSION_MINOR 0)
 set_if_not_defined(FSO_VERSION_BUILD 0)
 
 # A numeric revision e.g. the CI build number

code/CMakeLists.txt

@@ -26,6 +26,7 @@ TARGET_LINK_LIBRARIES(code PUBLIC openal)
 TARGET_LINK_LIBRARIES(code PUBLIC ${LUA_LIBS})
 TARGET_LINK_LIBRARIES(code PUBLIC ${PNG_LIBS})
 TARGET_LINK_LIBRARIES(code PUBLIC ${JPEG_LIBS})
+TARGET_LINK_LIBRARIES(code PUBLIC lz4)
 
 TARGET_LINK_LIBRARIES(code PUBLIC sdl2)
 
@@ -65,6 +66,8 @@ TARGET_LINK_LIBRARIES(code PUBLIC jansson)
 
 target_link_libraries(code PUBLIC variant)
 
+target_link_libraries(code PUBLIC any)
+
 # Headers for standalone "gui" on UNIX
 IF(UNIX)
 	TARGET_LINK_LIBRARIES(code PUBLIC ${MONGOOSE_LIBS})

code/actions/types/ParticleEffectAction.cpp

@@ -43,13 +43,13 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
 		auto pmi = model_get_instance(instance);
 		auto pm = model_get(pmi->model_num);
 
-		find_submodel_instance_point_orient(&local_pos,
+		model_instance_local_to_global_point_orient(&local_pos,
 			&local_orient,
+			&locals.localPosition,
+			&locals.localOrient,
 			pm,
 			pmi,
-			locals.hostSubobject,
-			&locals.localPosition,
-			&locals.localOrient);
+			locals.hostSubobject);
 	} else {
 		local_pos = locals.localPosition;
 		local_orient = locals.localOrient;

code/actions/types/PlaySoundAction.cpp

@@ -32,13 +32,13 @@ ActionResult PlaySoundAction::execute(ProgramLocals& locals) const
 		auto pmi = model_get_instance(instance);
 		auto pm = model_get(pmi->model_num);
 
-		find_submodel_instance_point_orient(&local_pos,
+		model_instance_local_to_global_point_orient(&local_pos,
 			&local_orient,
+			&locals.localPosition,
+			&locals.localOrient,
 			pm,
 			pmi,
-			locals.hostSubobject,
-			&locals.localPosition,
-			&locals.localOrient);
+			locals.hostSubobject);
 	} else {
 		local_pos = locals.localPosition;
 		local_orient = locals.localOrient;

code/ai/ai.h

@@ -330,7 +330,7 @@ typedef struct ai_info {
 	fix		path_next_check_time;	//	Last time checked to see if would collide with model.
 	int		path_goal_dist;		// minimum distance to first path point to consider path reached
 	int		path_subsystem_next_check;	// timestamp to next check if subsystem is still visible
-	vec3d	path_depart_orient;		//Rotational orientation associated with the path
+	vec3d	path_depart_rvec;		//Rotational orientation associated with the path
 
 	int		submode;
 	int		previous_submode;		// previous submode, get it?
@@ -405,7 +405,6 @@ typedef struct ai_info {
 
 
 	union {
-	float		lead_scale;							//	Amount to lead current opponent by.
 	float		stay_near_distance;				//	Distance to stay within for AIM_STAY_NEAR mode.
 	};
 
@@ -491,6 +490,9 @@ typedef struct ai_info {
 	int		ai_override_rot_timestamp;		// mark for when to end the current rotational maneuver override
 
 	int form_obj_slotnum;               // for flying in formation object mode, the position in the formation
+
+	int multilock_check_timestamp;		// when to check for multilock next
+	SCP_vector<std::pair<int, ship_subsys*>> ai_missile_locks_firing;  // a list of missile locks (locked objnum, locked subsys) the ai is currently firing
 } ai_info;
 
 // Goober5000
@@ -605,7 +607,7 @@ extern int ai_find_goal_index( ai_goal* aigp, int mode, int submode = -1, int pr
 extern void ai_do_safety(object *objp);
 
 // used to get path info for fighter bay emerging and departing
-int ai_acquire_emerge_path(object *pl_objp, int parent_objnum, int path_mask, vec3d *pos, vec3d *fvec);
+int ai_acquire_emerge_path(object *pl_objp, int parent_objnum, int path_mask);
 int ai_acquire_depart_path(object *pl_objp, int parent_objnum, int path_mask);
 
 // used by AiBig.cpp
@@ -657,7 +659,7 @@ void ai_start_fly_to_ship(object *objp, int shipnum);
 void ai_fly_to_ship();
 
 //Moved declaration here for player ship -WMC
-void process_subobjects(int objnum);
+void ai_process_subobjects(int objnum);
 
 //SUSHI: Setting ai_info stuff from both ai class and ai profile
 void init_aip_from_class_and_profile(ai_info *aip, ai_class *aicp, ai_profile_t *profile);

code/ai/ai_flags.h

@@ -5,7 +5,7 @@
 
 namespace AI {
 	FLAG_LIST(AI_Flags) {
-		Formation_wing,				//	Fly in formation as part of wing.
+		Formation_wing,				//	Fly in formation as part of wing. Also used when flying waypoints.
 		Awaiting_repair,			//	Awaiting a repair ship.
 		Being_repaired,				//	Currently docked with repair ship.
 		Repairing,					//	Repairing a ship (or going to repair a ship)
@@ -137,6 +137,13 @@ namespace AI {
 		Improved_missile_avoidance,
 		Friendlies_use_countermeasure_firechance,
 		Improved_subsystem_attack_pathing,
+		Fixed_ship_weapon_collision,
+		No_shield_damage_from_ship_collisions,
+		Reset_last_hit_target_time_for_player_hits,
+		Fighterbay_arrivals_use_carrier_orient, 
+		Fighterbay_departures_use_carrier_orient,
+		Prevent_negative_turret_ammo,
+		Fix_keep_safe_distance,
 
 		NUM_VALUES
 	};

code/ai/ai_profiles.cpp

@@ -58,6 +58,26 @@ int ai_path_type_match(char *p)
 	return -1;
 }
 
+
+const char* AI_secondary_range_aware_select_modes[] = {
+	"retail",
+	"aware",
+};
+
+int Num_ai_secondary_range_aware_select_modes = sizeof(AI_secondary_range_aware_select_modes) / sizeof(char*);
+
+int ai_secondary_range_select_mode_match(char* p)
+{
+	int i;
+	for (i = 0; i < Num_ai_secondary_range_aware_select_modes; i++)
+	{
+		if (!stricmp(AI_secondary_range_aware_select_modes[i], p))
+			return i;
+	}
+
+	return -1;
+}
+
 void parse_ai_profiles_tbl(const char *filename)
 {
 	int i;
@@ -448,7 +468,10 @@ void parse_ai_profiles_tbl(const char *filename)
 
 				set_flag(profile, "$firing requires exact los:", AI::Profile_Flags::Require_exact_los);
 
-				profile->ai_path_mode = AI_PATH_MODE_NORMAL;
+				set_flag(profile, "$fighterbay arrivals use carrier orientation:", AI::Profile_Flags::Fighterbay_arrivals_use_carrier_orient);
+
+				set_flag(profile, "$fighterbay departures use carrier orientation:", AI::Profile_Flags::Fighterbay_departures_use_carrier_orient);
+
 				if (optional_string("$ai path mode:"))
 				{
 					stuff_string(buf, F_NAME, NAME_LENGTH);
@@ -481,14 +504,12 @@ void parse_ai_profiles_tbl(const char *filename)
 					if (path_radii >= Minimum_subsystem_path_pt_dist) {
 						profile->subsystem_path_radii = path_radii;
 					} else {
-						mprintf(("Warning: \"$override radius for subsystem path points:\" should be >= %i (read %i). Value will not be used. ", Minimum_subsystem_path_pt_dist, path_radii));
+						mprintf(("Warning: \"$override radius for subsystem path points:\" should be >= %i (read %i). Value will not be used.\n", Minimum_subsystem_path_pt_dist, path_radii));
 					}
 				}
 
 				set_flag(profile, "$use POF radius for subsystem path points:", AI::Profile_Flags::Use_subsystem_path_point_radii);
 
-				profile->bay_arrive_speed_mult = 1.0f;
-				profile->bay_depart_speed_mult = 1.0f;
 				if (optional_string("$bay arrive speed multiplier:")) {
 					stuff_float(&profile->bay_arrive_speed_mult);
 				}
@@ -544,6 +565,40 @@ void parse_ai_profiles_tbl(const char *filename)
 
 				set_flag(profile, "$improved subsystem attack pathing:", AI::Profile_Flags::Improved_subsystem_attack_pathing);
 
+				set_flag(profile, "$fixed ship-weapon collisions:", AI::Profile_Flags::Fixed_ship_weapon_collision);
+
+				//Intention is to expand this feature to include a preference for close or long range weapons
+				//hence using something besides a simple flag.
+				if (optional_string("$AI secondary range awareness:"))
+				{
+					stuff_string(buf, F_NAME, NAME_LENGTH);
+					int j = ai_secondary_range_select_mode_match(buf);
+					if (j >= 0) {
+						profile->ai_range_aware_secondary_select_mode = j;
+					}
+					else {
+						Warning(LOCATION, "Invalid ai secondary range awareness mode '%s' specified", buf);
+					}
+				}
+
+				set_flag(profile, "$no shield damage from ship collisions:", AI::Profile_Flags::No_shield_damage_from_ship_collisions);
+
+				set_flag(profile, "$reset last_hit_target_time for player hits:", AI::Profile_Flags::Reset_last_hit_target_time_for_player_hits);
+
+				if (optional_string("$turret target recheck time:"))
+				{
+					stuff_float(&profile->turret_target_recheck_time);
+					if (profile->turret_target_recheck_time < 0) {
+						Warning(LOCATION, "Turret target recheck time must be positive.");
+						profile->turret_target_recheck_time = 2000.0f;
+					}
+				}
+
+				set_flag(profile, "$prevent negative turret ammo:", AI::Profile_Flags::Prevent_negative_turret_ammo);
+
+				set_flag(profile, "$fix keep-safe-distance:", AI::Profile_Flags::Fix_keep_safe_distance);
+
+
 				// if we've been through once already and are at the same place, force a move
 				if (saved_Mp && (saved_Mp == Mp))
 				{
@@ -615,11 +670,13 @@ void ai_profile_t::reset()
 
     flags.reset();
 
-    ai_path_mode = 0;
+    ai_path_mode = AI_PATH_MODE_NORMAL;
 	subsystem_path_radii = 0;
-    bay_arrive_speed_mult = 0;
-    bay_depart_speed_mult = 0;
+    bay_arrive_speed_mult = 1.0f;
+    bay_depart_speed_mult = 1.0f;
 	second_order_lead_predict_factor = 0;
+	ai_range_aware_secondary_select_mode = AI_RANGE_AWARE_SEC_SEL_MODE_RETAIL;
+	turret_target_recheck_time = 2000.0f;
 
     for (int i = 0; i < NUM_SKILL_LEVELS; ++i) {
         max_incoming_asteroids[i] = 0;
@@ -697,4 +754,16 @@ void ai_profile_t::reset()
 	if (mod_supports_version(3, 7, 2)) {
 		flags.set(AI::Profile_Flags::Fix_ramming_stationary_targets_bug);
 	}
+	// and this flag has been enabled ever since 3.6.10
+	if (mod_supports_version(3, 6, 10)) {
+		flags.set(AI::Profile_Flags::Reset_last_hit_target_time_for_player_hits);
+	}
+	if (mod_supports_version(21, 4, 0)) {
+		flags.set(AI::Profile_Flags::Fixed_ship_weapon_collision);
+	}
+	if (mod_supports_version(22, 0, 0)) {
+		flags.set(AI::Profile_Flags::Fighterbay_arrivals_use_carrier_orient);
+		flags.set(AI::Profile_Flags::Prevent_negative_turret_ammo);
+		flags.set(AI::Profile_Flags::Fix_keep_safe_distance);
+	}
 }

code/ai/ai_profiles.h

@@ -17,6 +17,9 @@
 // AI Path types
 #define	AI_PATH_MODE_NORMAL 0
 #define	AI_PATH_MODE_ALT1	1
+
+#define	AI_RANGE_AWARE_SEC_SEL_MODE_RETAIL 0
+#define	AI_RANGE_AWARE_SEC_SEL_MODE_AWARE 1
 	
 #define MAX_AI_PROFILES	5
 
@@ -107,6 +110,12 @@ public:
 
 	// How much 0-1 of a second-order lead prediction factor to add to lead indicators. Affects only the HUD indicator, and autoaim.
 	float second_order_lead_predict_factor;
+	
+	//Controls if the AI is dumb enough to keep trying to use out-of-range secondaries. 
+	int ai_range_aware_secondary_select_mode;
+
+	// how often turrets shoulds check for new targets, milliseconds
+	float turret_target_recheck_time;
 
     void reset();
 };

code/ai/aibig.cpp

@@ -17,12 +17,12 @@
 #include "io/timer.h"
 #include "math/staticrand.h"
 #include "mission/missionparse.h"
+#include "object/objcollide.h"
 #include "object/object.h"
 #include "ship/afterburner.h"
 #include "ship/ship.h"
+#include "utils/Random.h"
 #include "weapon/weapon.h"
-#include "object/objcollide.h"
-
 
 #ifdef _MSC_VER
 #pragma optimize("", off)
@@ -407,7 +407,7 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 
 			// get world pos of eye (stored in geye)
 			ep = &(pm->view_positions[shipp->current_viewpoint]);
-			model_instance_find_world_point( &geye, &ep->pnt, pm, pmi, 0, &Pl_objp->orient, &Pl_objp->pos );
+			model_instance_local_to_global_point( &geye, &ep->pnt, pm, pmi, 0, &Pl_objp->orient, &Pl_objp->pos );
 			
 			// get world pos of subsystem
 			vm_vec_unrotate(&gsubpos, &aip->targeted_subsys->system_info->pnt, &En_objp->orient);
@@ -549,7 +549,7 @@ bool ai_new_maybe_reposition_attack_subsys() {
 
 	// get world pos of eye (stored in geye)
 	ep = &(pm->view_positions[Ships[Pl_objp->instance].current_viewpoint]);
-	model_find_world_point(&geye, &ep->pnt, pm->id, 0, &Pl_objp->orient, &Pl_objp->pos);
+	model_local_to_global_point(&geye, &ep->pnt, pm->id, 0, &Pl_objp->orient, &Pl_objp->pos);
 
 	// get world pos of subsystem
 	vm_vec_unrotate(&gsubpos, &aip->targeted_subsys->system_info->pnt, &En_objp->orient);
@@ -777,14 +777,28 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 		
 		ai_turn_towards_vector(enemy_pos, Pl_objp, nullptr, rel_pos, 0.0f, 0, rvec);
 
+		// set an optimal range if applicable
+		float optimal_range = 0.0f;
+		ship_weapon* weapons = &Ships[Pl_objp->instance].weapons;
+		weapon_info* wip = nullptr;
+		ship* shipp = &Ships[Pl_objp->instance];
+
+		if (weapons->num_primary_banks >= 1 && weapons->current_primary_bank >= 0 && !shipp->flags[Ship::Ship_Flags::Primaries_locked]) {
+			wip = &Weapon_info[weapons->primary_bank_weapons[weapons->current_primary_bank]];
+		} else if (weapons->num_secondary_banks >= 1 && weapons->current_secondary_bank >= 0 && !shipp->flags[Ship::Ship_Flags::Secondaries_locked]) {
+			wip = &Weapon_info[weapons->secondary_bank_weapons[weapons->current_secondary_bank]];
+		}
+
+		if (wip != nullptr && wip->optimum_range > 0)
+			optimal_range = wip->optimum_range;
+
 		// calc range of primary weapon
 		weapon_travel_dist = ai_get_weapon_dist(&Ships[Pl_objp->instance].weapons);
 
 		if ( aip->targeted_subsys != NULL ) {
-			if (dist_to_enemy > (weapon_travel_dist-20)) {
+			if (dist_to_enemy > (optimal_range > 0.0f ? optimal_range : (weapon_travel_dist-20))) {
 				accelerate_ship(aip, 1.0f);
 				
-				ship	*shipp = &Ships[Pl_objp->instance];
 				if ((aip->ai_flags[AI::AI_Flags::Free_afterburner_use] || aip->ai_profile_flags[AI::Profile_Flags::Free_afterburner_use]) && !(shipp->flags[Ship::Ship_Flags::Afterburner_locked]) && (dot_to_enemy > 0.75f)) {
 					if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
 						afterburners_start(Pl_objp);
@@ -809,7 +823,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 			} else if (dot_to_enemy < 0.75f) {
 				accel = 0.75f;
 			} else {
-				if (dist_to_enemy > weapon_travel_dist/2.0f) {
+				if (dist_to_enemy > (optimal_range > 0.0f ? optimal_range : (weapon_travel_dist/2.0f))) {
 					accel = 1.0f;
 				} else {
 					accel = 1.0f - dot_to_enemy;
@@ -826,7 +840,6 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 			} else {
 				accelerate_ship(aip, accel);
 
-				ship	*shipp = &Ships[Pl_objp->instance];
 				if ((aip->ai_flags[AI::AI_Flags::Free_afterburner_use] || aip->ai_profile_flags[AI::Profile_Flags::Free_afterburner_use]) && !(shipp->flags[Ship::Ship_Flags::Afterburner_locked]) && (accel > 0.95f)) {
 					if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
 						afterburners_start(Pl_objp);
@@ -914,7 +927,7 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 									}
 								}
 
-								if (timestamp_elapsed(swp->next_secondary_fire_stamp[current_bank])) {
+								if (timestamp_elapsed(swp->next_secondary_fire_stamp[current_bank]) && weapon_target_satisfies_lock_restrictions(swip, En_objp)) {
 									float firing_range;
 									if (swip->wi_flags[Weapon::Info_Flags::Local_ssm])
 										firing_range=swip->lssm_lock_range;
@@ -944,11 +957,11 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 													} else {
 														t = swip->fire_wait;
 														if ((swip->burst_shots > 0) && (swip->burst_flags[Weapon::Burst_Flags::Random_length])) {
-															swp->burst_counter[current_bank_adjusted] = myrand() % swip->burst_shots;
+															swp->burst_counter[current_bank_adjusted] = Random::next(swip->burst_shots);
 														} else {
 															swp->burst_counter[current_bank_adjusted] = 0;
 														}
-														swp->burst_seed[current_bank_adjusted] = rand32();
+														swp->burst_seed[current_bank_adjusted] = Random::next();
 													}
 												} else {
 													if (swip->burst_shots > swp->burst_counter[current_bank_adjusted]) {
@@ -957,11 +970,11 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 													} else {
 														t = set_secondary_fire_delay(aip, temp_shipp, swip, false);
 														if ((swip->burst_shots > 0) && (swip->burst_flags[Weapon::Burst_Flags::Random_length])) {
-															swp->burst_counter[current_bank_adjusted] = myrand() % swip->burst_shots;
+															swp->burst_counter[current_bank_adjusted] = Random::next(swip->burst_shots);
 														} else {
 															swp->burst_counter[current_bank_adjusted] = 0;
 														}
-														swp->burst_seed[current_bank_adjusted] = rand32();
+														swp->burst_seed[current_bank_adjusted] = Random::next();
 													}
 												}
 												swp->next_secondary_fire_stamp[current_bank] = timestamp((int) (t*1000.0f));
@@ -1448,7 +1461,7 @@ void ai_big_strafe_attack()
 		if (ai_new_maybe_reposition_attack_subsys())
 			return;
 	} else if (ai_big_maybe_follow_subsys_path(0))
-		return
+		return;
 
 	ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);
 	if ( ai_big_strafe_maybe_retreat(&target_pos) )
@@ -1471,7 +1484,7 @@ void ai_big_strafe_attack()
 		if ( t > 0.0f && t < 1.5f ) {
 			// set up goal_point for avoid path to turn towards
 			aip->goal_point = Pl_objp->pos;
-			switch(rand()%4) {
+			switch(Random::next(4)) {
 			case 0:
 				vm_vec_scale_add(&rand_vec, &Pl_objp->orient.vec.fvec, &Pl_objp->orient.vec.uvec, 2.0f);
 				break;
@@ -1703,7 +1716,7 @@ void ai_big_strafe_retreat1()
 	if (Missiontime - aip->submode_start_time > fl2f(1.50f)) {
 		// set up goal_point for avoid path to turn towards
 		aip->prev_goal_point = Pl_objp->pos;
-		switch(rand()%4) {
+		switch(Random::next(4)) {
 		case 0:
 			vm_vec_add(&rand_vec, &Pl_objp->orient.vec.fvec, &Pl_objp->orient.vec.uvec);
 			break;

code/ai/aigoals.cpp

@@ -23,6 +23,7 @@
 #include "playerman/player.h"
 #include "scripting/scripting.h"
 #include "ship/ship.h"
+#include "ship/awacs.h"
 #include "weapon/weapon.h"
 
 // Just a reference to this struct being for looking up a ship's team in TVT
@@ -187,6 +188,11 @@ void ai_post_process_mission()
 	object *objp;
 	int i;
 
+	// make sure team visibility is updated first
+	if ( !Fred_running ) {
+		awacs_process();
+	}
+
 	// Check ships in player starting wings.  Those ships should follow these rules:
 	// (1) if they have no orders, they should get a form on my wing order
 	// (2) if they have an order, they are free to act on it.
@@ -203,7 +209,6 @@ void ai_post_process_mission()
 				wingp = &Wings[Starting_wings[i]];
 
 				ai_maybe_add_form_goal( wingp );
-
 			}
 		}
 	}
@@ -261,14 +266,20 @@ void ai_remove_ship_goal( ai_info *aip, int index )
 	// ai goal code look
 	Assert ( index >= 0 );			// must have a valid goal
 
+	if (index == aip->active_goal)
+	{
+		// rearm/repair needs a bit of extra cleanup
+		if (aip->goals[index].ai_mode == AI_GOAL_REARM_REPAIR)
+			ai_abort_rearm_request(&Objects[Ships[aip->shipnum].objnum]);
+
+		aip->active_goal = AI_GOAL_NONE;
+	}
+
 	aip->goals[index].ai_mode = AI_GOAL_NONE;
 	aip->goals[index].signature = -1;
 	aip->goals[index].priority = -1;
 	aip->goals[index].flags.reset(); // must reset the flags since not doing so will screw up goal sorting.
 
-	if ( index == aip->active_goal )
-		aip->active_goal = AI_GOAL_NONE;
-
 	// mwa -- removed this line 8/5/97.  Just because we remove a goal doesn't mean to do the default
 	// behavior.  We will make the call commented out below in a more reasonable location
 	//ai_do_default_behavior( &Objects[Ships[aip->shipnum].objnum] );
@@ -293,9 +304,11 @@ void ai_clear_ship_goals( ai_info *aip )
 	}
 
 	// add scripting hook for 'On Goals Cleared' --wookieejedi
-	Script_system.SetHookObject("Ship", &Objects[Ships[aip->shipnum].objnum]);
-	Script_system.RunCondition(CHA_ONGOALSCLEARED);
-	Script_system.RemHookVars({"Ship"});
+	if (Script_system.IsActiveAction(CHA_ONGOALSCLEARED)) {
+		Script_system.SetHookObject("Ship", &Objects[Ships[aip->shipnum].objnum]);
+		Script_system.RunCondition(CHA_ONGOALSCLEARED);
+		Script_system.RemHookVars({"Ship"});
+	}
 }
 
 void ai_clear_wing_goals( wing *wingp )

code/ai/aiinternal.h

@@ -32,6 +32,6 @@ int check_ok_to_fire(int objnum, int target_objnum, weapon_info *wip, int second
 bool check_los(int objnum, int target_objnum, float threshold, int primary_bank, int secondary_bank, ship_subsys* turret);
 
 //Does all the stuff needed to aim and fire a turret.
-void ai_fire_from_turret(ship *shipp, ship_subsys *ss);
+void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss);
 
 #endif

code/ai/aiturret.cpp

@@ -18,6 +18,7 @@
 #include "render/3d.h"
 #include "ship/ship.h"
 #include "ship/shipfx.h"
+#include "utils/Random.h"
 #include "weapon/beam.h"
 #include "weapon/flak.h"
 #include "weapon/muzzleflash.h"
@@ -87,6 +88,18 @@ typedef struct eval_enemy_obj_struct {
 	int			nearest_objnum;
 }	eval_enemy_obj_struct;
 
+// the current world orientation of the turret matrix, corresponding to its fvec and uvec defined in the model
+// is NOT affected by the turret's current aiming
+void turret_instance_find_world_orient(matrix* out_mat, int model_instance_num, int submodel_num, const matrix* objorient)
+{
+	auto pmi = model_get_instance(model_instance_num);
+	auto pm = model_get(pmi->model_num);
+	vec3d fvec, uvec;
+	model_instance_local_to_global_dir(&fvec, &pm->submodel[submodel_num].frame_of_reference.vec.fvec, pm, pmi, pm->submodel[submodel_num].parent, objorient);
+	model_instance_local_to_global_dir(&uvec, &pm->submodel[submodel_num].frame_of_reference.vec.uvec, pm, pmi, pm->submodel[submodel_num].parent, objorient);
+	vm_vector_2_matrix_norm(out_mat, &fvec, &uvec);
+}
+
 /**
  * Is object in turret field of view?
  *
@@ -98,124 +111,53 @@ typedef struct eval_enemy_obj_struct {
  *
  * @return 1 if objp is in fov of the specified turret.  Otherwise return 0.
  */
-int object_in_turret_fov(object *objp, ship_subsys *ss, vec3d *tvec, vec3d *tpos, float dist)
+bool object_in_turret_fov(object *objp, ship_subsys *ss, vec3d *tvec, vec3d *tpos, float dist)
 {
 	vec3d	v2e;
 	float size_mod;
-	bool  in_fov;
+	bool  in_fov = false;
+
+	if (ss->flags[Ship::Subsystem_Flags::FOV_edge_check]) {
+		int model_num;
+		switch (objp->type) {
+			case OBJ_SHIP:
+				model_num = Ship_info[Ships[objp->instance].ship_info_index].model_num;
+				break;
+			case OBJ_ASTEROID:
+				model_num = Asteroid_info[Asteroids[objp->instance].asteroid_type].model_num[Asteroids[objp->instance].asteroid_subtype];
+				break;
+			default:
+				vm_vec_normalized_dir(&v2e, &objp->pos, tpos);
+				size_mod = objp->radius / (dist + objp->radius);
+
+				in_fov = turret_fov_test(ss, tvec, &v2e, size_mod);
+
+				return in_fov;
+		}
+
+		auto pm = model_get(model_num);
+		for (int i = 0; i < 8; i++) {
+			vec3d bbox_point;
+			vm_vec_unrotate(&bbox_point, &pm->bounding_box[i], &objp->orient);
+			bbox_point += objp->pos;
+
+			vm_vec_normalized_dir(&v2e, &bbox_point, tpos);
+			in_fov = turret_fov_test(ss, tvec, &v2e, -0.2f);
+
+			if (in_fov)
+				return true;
+		}
+	} 
+	// if the bbox points method didn't work (or fov_edge_checks isn't on)
+	// try the normal method
 
 	vm_vec_normalized_dir(&v2e, &objp->pos, tpos);
 	size_mod = objp->radius / (dist + objp->radius);
 
 	in_fov = turret_fov_test(ss, tvec, &v2e, size_mod);
 
-	if ( in_fov ) {
- 		return 1;
-	}
 
-	return 0;
-}
-
-bool is_object_radius_in_turret_fov(object *objp, ship_subsys *ss, vec3d *tvec, vec3d *tpos, vec3d *v2e, vec3d *predicted_pos, float distance)
-{
-	float target_dist = distance;
-	if (distance == 0.0f)
-		target_dist = vm_vec_dist(predicted_pos,tpos);
-
-	if (object_in_turret_fov(objp, ss, tvec, tpos, target_dist + objp->radius)) {
-		// so the targeted spot in not in fov but the enemy + radius is
-		// lets align the darn gun and try shooting there
-		vec3d temp_vec;
-		float multiplier = 0;
-		model_subsystem *tp = ss->system_info;
-
-		// project v2e_from_turret to turret normal
-		// substract resultant vector from the temp_vec (v2e_from_turret)
-		// adjust z component as necessary
-		// calculate multiplier for the resultant vector
-		// use multiplier and the z component and compose a new vector
-		float dot = vm_vec_dot(v2e, tvec);
-
-		vm_vec_scale_add(&temp_vec, v2e, tvec, -dot);
-
-		if (IS_VEC_NULL_SQ_SAFE(&temp_vec)) {
-			// return false, target is perfectly aligned over or below the turret
-			// safe bet is to allow turret to reacquire better target
-			return false;
-		}
-
-		// normalize the vec, it needs to be done regardless
-		vm_vec_normalize(&temp_vec);
-		bool fix_elevation = false;
-		bool fix_base_rot = false;
-
-		if (dot < tp->turret_fov) {
-			dot = tp->turret_fov;
-			fix_elevation = true;
-		}
-		if (dot > tp->turret_max_fov) {
-			dot = tp->turret_max_fov;
-			fix_elevation = true;
-		}
-
-		if (tp->flags[Model::Subsystem_Flags::Turret_alt_math]) {
-			// Since we no longer maintain world_to_turret_matrix, regenerate it here.
-			vec3d turret_norm;
-			matrix turret_matrix, world_to_turret_matrix;
-			model_instance_find_world_dir(&turret_norm, &tp->turret_norm, Ships[objp->instance].model_instance_num, tp->subobj_num, &vmd_identity_matrix);
-			vm_vector_2_matrix(&turret_matrix, &turret_norm, nullptr, nullptr);
-			vm_matrix_x_matrix(&world_to_turret_matrix, &objp->orient, &turret_matrix);
-
-			vec3d temp_vec2;
-			vm_vec_rotate(&temp_vec2, &temp_vec, &world_to_turret_matrix);
-
-			// now in turrets frame of reference
-			// check if math is actually possible
-			if (!((temp_vec2.xyz.x == 0) && (temp_vec2.xyz.y == 0))) {
-				float temp_z = temp_vec2.xyz.z;
-				temp_vec2.xyz.z = 0.0f;
-				// make sure null vecs wont happen
-				if (!IS_VEC_NULL_SQ_SAFE(&temp_vec2)) {
-					vm_vec_normalize(&temp_vec2);
-					// only do this if it actually is required
-					if (-temp_vec2.xyz.y < tp->turret_y_fov) {
-						float check_pos = 1;
-
-						fix_base_rot = true;
-						temp_vec2.xyz.y = -tp->turret_y_fov;
-						if (temp_vec2.xyz.x < 0)
-						check_pos = -1;
-						temp_vec2.xyz.x = check_pos * sqrtf(1 - (temp_vec2.xyz.y*temp_vec2.xyz.y));
-
-						// restore z component
-						float scaler = sqrtf(1 - (temp_z*temp_z));
-						vm_vec_scale(&temp_vec2,scaler);
-						temp_vec2.xyz.z = temp_z;
-						// back to world frame
-						vm_vec_unrotate(&temp_vec, &temp_vec2, &world_to_turret_matrix);
-					}
-				}
-			}
-		}
-
-		if (fix_elevation || fix_base_rot) {
-			if (fix_elevation) {
-				multiplier = sqrtf(1 - (dot*dot));
-				// keep the temp_vec scaled with the tweaked vector
-				vm_vec_scale(&temp_vec, multiplier);
-			}
-			vm_vec_scale_add(v2e, &temp_vec, tvec, dot);
-			// and we are done with v2e...
-			vm_vec_scale_add(predicted_pos, tpos, v2e, target_dist);
-			// and we are done with predicted position
-			return true;
-		} else {
-			mprintf(("Warning: Function 'is_object_radius_in_turret_fov' was called\nwithout need to fix turret alignments\n"));
-			return false;
-		}
-	}
-	// outside of the expanded radii, unable to align, return false
-	return false;
+	return in_fov;
 }
 
 /**
@@ -1196,17 +1138,11 @@ int find_turret_enemy(ship_subsys *turret_subsys, int objnum, vec3d *tpos, vec3d
 						if ( tagged_only_flag && ship_is_tagged(&Objects[aip->target_objnum]) ) {
 							// select new target if aip->target_objnum is out of field of view
 							vec3d v2e;
-							float dist;
 							bool in_fov;
-							dist = vm_vec_normalized_dir(&v2e, &Objects[aip->target_objnum].pos, tpos);
+							vm_vec_normalized_dir(&v2e, &Objects[aip->target_objnum].pos, tpos);
 
 							in_fov = turret_fov_test(turret_subsys, tvec, &v2e);
 
-							if (turret_subsys->flags[Ship::Subsystem_Flags::FOV_edge_check]) {
-								if (in_fov == false)
-									if (object_in_turret_fov(&Objects[aip->target_objnum], turret_subsys, tvec, tpos, dist + Objects[aip->target_objnum].radius))
-										in_fov = true;
-							}
 							// MODIFY FOR ATTACKING BIG SHIP
 							// dot += (0.5f * Objects[aip->target_objnum].radius / dist);
 							if (in_fov) {
@@ -1254,9 +1190,9 @@ void ship_get_global_turret_info(const object *objp, const model_subsystem *tp,
 {
 	auto model_instance_num = Ships[objp->instance].model_instance_num;
 	if (gpos)
-		model_instance_find_world_point(gpos, &vmd_zero_vector, model_instance_num, tp->subobj_num, &objp->orient, &objp->pos);
+		model_instance_local_to_global_point(gpos, &vmd_zero_vector, model_instance_num, tp->subobj_num, &objp->orient, &objp->pos);
 	if (gvec)
-		model_instance_find_world_dir(gvec, &tp->turret_norm, model_instance_num, tp->subobj_num, &objp->orient);
+		model_instance_local_to_global_dir(gvec, &tp->turret_norm, model_instance_num, tp->subobj_num, &objp->orient, true);
 }
 
 void turret_ai_update_aim(ai_info *aip, object *En_Objp, ship_subsys *ss);
@@ -1284,15 +1220,15 @@ void ship_get_global_turret_gun_info(object *objp, ship_subsys *ssp, vec3d *gpos
 
 	gun_pos = &tp->turret_firing_point[ssp->turret_next_fire_pos % tp->turret_num_firing_points];
 
-	model_instance_find_world_point(gpos, gun_pos, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
+	model_instance_local_to_global_point(gpos, gun_pos, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
 
 	if (use_angles) {
-		model_instance_find_world_dir(gvec, &tp->turret_norm, pm, pmi, tp->turret_gun_sobj, &objp->orient);
+		model_instance_local_to_global_dir(gvec, &tp->turret_norm, pm, pmi, tp->turret_gun_sobj, &objp->orient);
 	} else if (tp->flags[Model::Subsystem_Flags::Share_fire_direction]) {
 		vec3d avg, tmp_pos, tmp_target, enemy_point, turret_norm;
 		vm_vec_avg_n(&avg, tp->turret_num_firing_points, tp->turret_firing_point);
 
-		model_instance_find_world_point(&tmp_pos, &avg, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
+		model_instance_local_to_global_point(&tmp_pos, &avg, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
 
 		if (targetp == nullptr) {
 			ship* shipp = &Ships[Objects[ssp->parent_objnum].instance];
@@ -1317,7 +1253,7 @@ void ship_get_global_turret_gun_info(object *objp, ship_subsys *ssp, vec3d *gpos
 			} else {
 				if ((lep->type == OBJ_SHIP) && (Ship_info[Ships[lep->instance].ship_info_index].is_big_or_huge())) {
                     // the turret norm here is from the perspective of the base submodel, not the gun submodel
-					model_instance_find_world_dir(&turret_norm, &tp->turret_norm, pm, pmi, tp->subobj_num, &objp->orient);
+					model_instance_local_to_global_dir(&turret_norm, &tp->turret_norm, pm, pmi, pm->submodel[tp->subobj_num].parent, &objp->orient);
 					ai_big_pick_attack_point_turret(lep, ssp, &tmp_pos, &turret_norm, &enemy_point, MIN(wip->max_speed * wip->lifetime, wip->weapon_range), tp->turret_fov);
 				}
 				else {
@@ -1448,18 +1384,13 @@ int aifft_rotate_turret(object *objp, ship *shipp, ship_subsys *ss, object *lep,
 
 		in_fov = turret_fov_test(ss, gvec, &v2e);
 
-		if (ss->flags[Ship::Subsystem_Flags::FOV_edge_check]) {
-			if (in_fov == false)
-				in_fov = is_object_radius_in_turret_fov(&Objects[ss->turret_enemy_objnum], ss, gvec, &gun_pos, &v2e, predicted_enemy_pos, 0.0f);
-		}
-
 		if (in_fov) {
-			ret_val = model_rotate_gun(objp, pm, pmi, tp, predicted_enemy_pos);
+			ret_val = model_rotate_gun(objp, pm, pmi, ss, predicted_enemy_pos);
 		} else if ((tp->flags[Model::Subsystem_Flags::Turret_reset_idle]) &&(timestamp_elapsed(ss->rotation_timestamp))) {
-			ret_val = model_rotate_gun(objp, pm, pmi, tp, predicted_enemy_pos, true);
+			ret_val = model_rotate_gun(objp, pm, pmi, ss, predicted_enemy_pos, true);
 		}
 	} else if ((ss->system_info->flags[Model::Subsystem_Flags::Turret_reset_idle]) && (timestamp_elapsed(ss->rotation_timestamp))) {
-		ret_val = model_rotate_gun(objp, pm, pmi, ss->system_info, predicted_enemy_pos, true);
+		ret_val = model_rotate_gun(objp, pm, pmi, ss, predicted_enemy_pos, true);
 	}
 
 	// by default "ret_val" should be set to 1 for multi-part turrets, and 0 for single-part turrets
@@ -1491,7 +1422,7 @@ float	aifft_compute_turret_dot(object *objp, object *enemy_objp, vec3d *abs_gunp
 	if (ship_subsystem_in_sight(enemy_objp, enemy_subsysp, abs_gunposp, &subobj_pos, 1, &dot_out, &vector_out)) {
 		vec3d	turret_norm;
 
-		model_instance_find_world_dir(&turret_norm, &turret_subsysp->system_info->turret_norm, Ships[objp->instance].model_instance_num, turret_subsysp->system_info->subobj_num, &objp->orient);
+		model_instance_local_to_global_dir(&turret_norm, &turret_subsysp->system_info->turret_norm, Ships[objp->instance].model_instance_num, turret_subsysp->system_info->subobj_num, &objp->orient, true);
 		float dot_return = vm_vec_dot(&turret_norm, &vector_out);
 
 		if (Ai_info[Ships[objp->instance].ai_index].ai_profile_flags[AI::Profile_Flags::Smart_subsystem_targeting_for_turrets]) {
@@ -1674,8 +1605,10 @@ void turret_set_next_fire_timestamp(int weapon_num, weapon_info *wip, ship_subsy
 {
 	Assert(weapon_num < MAX_SHIP_WEAPONS);
 	float wait = 1000.0f;
+	// should subtract 1 from firepoints to match behavior of wip->burst_shots
+	int burst_shots = (wip->burst_flags[Weapon::Burst_Flags::Num_firepoints_burst_shots] ? turret->system_info->turret_num_firing_points - 1 : wip->burst_shots);
 
-	if (wip->burst_shots > turret->weapons.burst_counter[weapon_num]) {
+	if (burst_shots > turret->weapons.burst_counter[weapon_num]) {
 		wait *= wip->burst_delay;
 		turret->weapons.burst_counter[weapon_num]++;
 	} else {
@@ -1685,12 +1618,12 @@ void turret_set_next_fire_timestamp(int weapon_num, weapon_info *wip, ship_subsy
 		} 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);
-			turret->weapons.burst_seed[weapon_num] = rand32();
+		if ((burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Random_length])) {
+			turret->weapons.burst_counter[weapon_num] = Random::next(burst_shots);
+			turret->weapons.burst_seed[weapon_num] = Random::next();
 		} else {
 			turret->weapons.burst_counter[weapon_num] = 0;
-			turret->weapons.burst_seed[weapon_num] = rand32();
+			turret->weapons.burst_seed[weapon_num] = Random::next();
 		}
 	}
 
@@ -1701,7 +1634,7 @@ void turret_set_next_fire_timestamp(int weapon_num, weapon_info *wip, ship_subsy
 		fs_dest = &turret->weapons.next_secondary_fire_stamp[weapon_num - MAX_SHIP_PRIMARY_BANKS];
 
 	//Check for the new cooldown flag
-	if(!((wip->wi_flags[Weapon::Info_Flags::Same_turret_cooldown]) || ((wip->burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Fast_firing]))))
+	if(!((wip->wi_flags[Weapon::Info_Flags::Same_turret_cooldown]) || ((burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Fast_firing]))))
 	{
 
 		// make side even for team vs. team
@@ -1857,8 +1790,19 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 
 		vm_vector_2_matrix(&turret_orient, firing_vec, nullptr, nullptr);
 
-		// set next fire timestamp for the turret
+		// grab and set some burst data before turret_set_next_fire_timestamp wipes it
 		int old_burst_seed = swp->burst_seed[weapon_num];
+		int old_burst_counter = swp->burst_counter[weapon_num];
+		// only used by type 5 beams
+		if (turret->weapons.burst_counter[weapon_num] == 0) {
+			swp->per_burst_rot += wip->b_info.t5info.per_burst_rot;
+			if (swp->per_burst_rot > PI2)
+				swp->per_burst_rot -= PI2;
+			else if (swp->per_burst_rot < -PI2)
+				swp->per_burst_rot += PI2;
+		}
+
+		// set next fire timestamp for the turret
 		if (last_shot_in_salvo)
 			turret_set_next_fire_timestamp(weapon_num, wip, turret, parent_aip);
 
@@ -1884,6 +1828,8 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 			fire_info.turret = turret;
 			fire_info.burst_seed = old_burst_seed;
 			fire_info.fire_method = BFM_TURRET_FIRED;
+			fire_info.per_burst_rotation = swp->per_burst_rot;
+			fire_info.burst_index = old_burst_counter;
 
 			// fire a beam weapon
 			weapon_objnum = beam_fire(&fire_info);
@@ -1894,9 +1840,11 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 				parent_ship->last_fired_turret = turret;
 				turret->last_fired_weapon_info_index = turret_weapon_class;
 
-				Script_system.SetHookObjects(4, "Ship", &Objects[parent_objnum], "Weapon", nullptr, "Beam", objp, "Target", &Objects[turret->turret_enemy_objnum]);
-				Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[parent_objnum]);
-				Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+				if (Script_system.IsActiveAction(CHA_ONTURRETFIRED)) {
+					Script_system.SetHookObjects(4, "Ship", &Objects[parent_objnum], "Weapon", nullptr, "Beam", objp, "Target", &Objects[turret->turret_enemy_objnum]);
+					Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[parent_objnum]);
+					Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+				}
 			}
 
 			turret->flags.set(Ship::Subsystem_Flags::Has_fired); //set fired flag for scripting -nike
@@ -1908,7 +1856,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 				swp->current_secondary_bank = 0;
 			}
 			int bank_to_fire = swp->current_secondary_bank;
-			if ((turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo]) && (swp->secondary_bank_ammo[bank_to_fire] < 0)) {
+			if ((turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo]) && !ship_secondary_has_ammo(swp, bank_to_fire)) {
 				if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns])) {
 					swp->current_secondary_bank++;
 					if (swp->current_secondary_bank >= swp->num_secondary_banks) {
@@ -1956,7 +1904,10 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 							points = 1;
 						}
 
-						if (swp->primary_bank_ammo[bank_to_fire] >= 0) {
+						if (swp->primary_bank_ammo[bank_to_fire] >= points) {
+							swp->primary_bank_ammo[bank_to_fire] -= points;
+						} else if ((swp->primary_bank_ammo[bank_to_fire] >= 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
+							// default behavior allowed ammo to be negative
 							swp->primary_bank_ammo[bank_to_fire] -= points;
 						} else if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns]) && (swp->primary_bank_ammo[bank_to_fire] < 0)) {
 							swp->current_primary_bank++;
@@ -1988,11 +1939,17 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 						for (int j = start_slot; j <= end_slot; j++) {
 							swp->secondary_next_slot[bank_to_fire]++;
 
+							if (Weapon_info[swp->secondary_bank_weapons[bank_to_fire]].wi_flags[Weapon::Info_Flags::SecondaryNoAmmo])
+								continue;
+
 							if (swp->secondary_next_slot[bank_to_fire] > (num_slots - 1)){
 								swp->secondary_next_slot[bank_to_fire] = 0;
 							}
 
-							if (swp->secondary_bank_ammo[bank_to_fire] >= 0) {
+							if (swp->secondary_bank_ammo[bank_to_fire] > 0) {
+								swp->secondary_bank_ammo[bank_to_fire]--;
+							} else if ((swp->secondary_bank_ammo[bank_to_fire] == 0) && !(The_mission.ai_profile->flags[AI::Profile_Flags::Prevent_negative_turret_ammo])) {
+								// default behavior allowed ammo to be negative
 								swp->secondary_bank_ammo[bank_to_fire]--;
 							} else if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns]) && (swp->secondary_bank_ammo[bank_to_fire] < 0)) {
 								swp->current_secondary_bank++;
@@ -2026,9 +1983,11 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 					// AL 1-6-97: Store pointer to turret subsystem
 					wp->turret_subsys = turret;	
 
-					Script_system.SetHookObjects(4, "Ship", &Objects[parent_objnum], "Weapon", objp, "Beam", nullptr, "Target", &Objects[turret->turret_enemy_objnum]);
-					Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[parent_objnum]);
-					Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+					if (Script_system.IsActiveAction(CHA_ONTURRETFIRED)) {
+						Script_system.SetHookObjects(4, "Ship", &Objects[parent_objnum], "Weapon", objp, "Beam", nullptr, "Target", &Objects[turret->turret_enemy_objnum]);
+						Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[parent_objnum]);
+						Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+					}
 
 					// if the gun is a flak gun
 					if (wip->wi_flags[Weapon::Info_Flags::Flak]) {
@@ -2091,7 +2050,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 	turret->flags.set(Ship::Subsystem_Flags::Has_fired); //set has fired flag for scriptng - nuke
 
 	//Fire animation stuff
-	model_anim_start_type(turret, AnimationTriggerType::TurretFired, ANIMATION_SUBTYPE_ALL, 1);
+	Ship_info[parent_ship->ship_info_index].animations.start(model_get_instance(parent_ship->model_instance_num), animation::ModelAnimationTriggerType::TurretFired, animation::anim_name_from_subsys(turret->system_info), animation::ModelAnimationDirection::FWD, true);
 	return true;
 }
 
@@ -2142,9 +2101,11 @@ void turret_swarm_fire_from_turret(turret_swarm_info *tsi)
 		Ships[Objects[tsi->parent_objnum].instance].last_fired_turret = tsi->turret;
 		tsi->turret->last_fired_weapon_info_index = tsi->weapon_class;
 
-		Script_system.SetHookObjects(4, "Ship", &Objects[tsi->parent_objnum], "Weapon", &Objects[weapon_objnum], "Beam", nullptr, "Target", &Objects[tsi->turret->turret_enemy_objnum]);
-		Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[tsi->parent_objnum]);
-		Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+		if (Script_system.IsActiveAction(CHA_ONTURRETFIRED)) {
+			Script_system.SetHookObjects(4, "Ship", &Objects[tsi->parent_objnum], "Weapon", &Objects[weapon_objnum], "Beam", nullptr, "Target", &Objects[tsi->turret->turret_enemy_objnum]);
+			Script_system.RunCondition(CHA_ONTURRETFIRED, &Objects[tsi->parent_objnum]);
+			Script_system.RemHookVars({"Ship", "Weapon", "Beam", "Target"});
+		}
 
 		// muzzle flash?
 		if (Weapon_info[tsi->weapon_class].muzzle_flash >= 0) {
@@ -2175,13 +2136,15 @@ int Num_find_turret_enemy = 0;
 int Num_turrets_fired = 0;
 
 /**
- * Given a turret tp and its parent parent_objnum, fire from the turret at its enemy.
+ * Previously called ai_fire_from_turret()
+ * Given a ship and a turret subsystem, handle all its behavior, mostly targeting and shooting but also 
+ * all turret movement and resetting when idle
  */
 extern int Nebula_sec_range;
-void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
+void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 {
 	float		weapon_firing_range;
-    float		WeaponMinRange;			// *Weapon minimum firing range -Et1
+    float		weapon_min_range;			// *Weapon minimum firing range -Et1
 	vec3d	v2e;
 	object	*lep;		//	Last enemy pointer
 	model_subsystem	*tp = ss->system_info;
@@ -2356,12 +2319,12 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 		if (wip->wi_flags[Weapon::Info_Flags::Local_ssm])
 		{
 			weapon_firing_range = wip->lssm_lock_range;
-			WeaponMinRange = 0.0f;
+			weapon_min_range = 0.0f;
 		}
 		else
 		{
 			weapon_firing_range = MIN(wip->lifetime * wip->max_speed, wip->weapon_range);
-			WeaponMinRange = wip->WeaponMinRange;
+			weapon_min_range = wip->weapon_min_range;
 		}
 
 		// if beam weapon in nebula and target not tagged, decrease firing range
@@ -2374,7 +2337,7 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 		}
 
 		// Don't try to fire beyond weapon_limit_range (or within min range)
-		if (dist_to_enemy < WeaponMinRange || dist_to_enemy > weapon_firing_range) {
+		if (dist_to_enemy < weapon_min_range || dist_to_enemy > weapon_firing_range) {
 			// it's possible another weapon is in range, but if not,
 			// we will end up selecting a new target
 			continue;
@@ -2441,6 +2404,11 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 				tentative_return = true;
 				continue;
 			}
+
+			if (!weapon_target_satisfies_lock_restrictions(wip, lep)) {
+				tentative_return = true;
+				continue;
+			}
 		}
 		else {
 			// check tagged-only for bombs only if the flag is set; see Mantis #3114
@@ -2507,9 +2475,10 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 			if (( lep->type == OBJ_SHIP ) && !(ss->flags[Ship::Subsystem_Flags::No_SS_targeting])) {
 				ss->targeted_subsys = aifft_find_turret_subsys(objp, ss, lep, &dot);				
 			}
-			ss->turret_next_enemy_check_stamp = timestamp((int) (MAX(dot, 0.5f)*2000.0f) + 1000);
+			// recheck in 2-3 seconds
+			ss->turret_next_enemy_check_stamp = timestamp((int)((MAX(dot, 0.5f) * The_mission.ai_profile->turret_target_recheck_time) + (The_mission.ai_profile->turret_target_recheck_time / 2.0f)));
 		} else {
-			ss->turret_next_enemy_check_stamp = timestamp((int) (2000.0f * frand_range(0.9f, 1.1f)));	//	Check every two seconds
+			ss->turret_next_enemy_check_stamp = timestamp((int)(The_mission.ai_profile->turret_target_recheck_time * frand_range(0.9f, 1.1f)));	//	Check every two seconds
 		}
 	}
 
@@ -2698,8 +2667,15 @@ void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 			{
 				// starting animation checks
 				if (ss->turret_animation_position == MA_POS_NOT_SET) {
-					if ( model_anim_start_type(shipp, AnimationTriggerType::TurretFiring, ss->system_info->subobj_num, 1) ) {
-						ss->turret_animation_done_time = model_anim_get_time_type(shipp, AnimationTriggerType::TurretFiring, ss->system_info->subobj_num);
+					bool started = false;
+					//For legacy animations using subtype for turret number
+					started |= Ship_info[shipp->ship_info_index].animations.startAll(model_get_instance(shipp->model_instance_num), animation::ModelAnimationTriggerType::TurretFiring, animation::ModelAnimationDirection::FWD, false, false, false, ss->system_info->subobj_num, true);
+					//For modern animations using proper triggered-by-subsys name
+					started |= Ship_info[shipp->ship_info_index].animations.start(model_get_instance(shipp->model_instance_num), animation::ModelAnimationTriggerType::TurretFiring, animation::anim_name_from_subsys(ss->system_info), animation::ModelAnimationDirection::FWD);
+					if (started) {
+						int duration = Ship_info[shipp->ship_info_index].animations.getTimeAll(model_get_instance(shipp->model_instance_num), animation::ModelAnimationTriggerType::TurretFiring, ss->system_info->subobj_num, true);
+						int duration2 = Ship_info[shipp->ship_info_index].animations.getTime(model_get_instance(shipp->model_instance_num), animation::ModelAnimationTriggerType::TurretFiring, animation::anim_name_from_subsys(ss->system_info));
+						ss->turret_animation_done_time = timestamp(duration > duration2 ? duration : duration2);
 						ss->turret_animation_position = MA_POS_SET;
 					}
 				}
@@ -2812,25 +2788,20 @@ bool turret_adv_fov_test(ship_subsys *ss, vec3d *gvec, vec3d *v2e, float size_mo
 	model_subsystem *tp = ss->system_info;
 	float dot = vm_vec_dot(v2e, gvec);
 	if (((dot + size_mod) >= tp->turret_fov) && ((dot - size_mod) <= tp->turret_max_fov)) {
-
-		// Since we no longer maintain world_to_turret_matrix, regenerate it here.
-		object *objp = &Objects[ss->parent_objnum];
-		vec3d turret_norm;
-		matrix turret_matrix, world_to_turret_matrix;
-		model_instance_find_world_dir(&turret_norm, &tp->turret_norm, Ships[objp->instance].model_instance_num, tp->subobj_num, &vmd_identity_matrix);
-		vm_vector_2_matrix(&turret_matrix, &turret_norm, nullptr, nullptr);
-		vm_matrix_x_matrix(&world_to_turret_matrix, &objp->orient, &turret_matrix);
+		object* objp = &Objects[ss->parent_objnum];
+		matrix turret_matrix;
+		turret_instance_find_world_orient(&turret_matrix, Ships[objp->instance].model_instance_num, tp->subobj_num, &objp->orient);
 
 		vec3d of_dst;
-		vm_vec_rotate( &of_dst, v2e, &world_to_turret_matrix );
-		if ((of_dst.xyz.x == 0) && (of_dst.xyz.y == 0)) {
-			return true;
-		} else {
-			of_dst.xyz.z = 0;
+		vm_vec_rotate(&of_dst, v2e, &turret_matrix);
+		if ((of_dst.xyz.x == 0) && (of_dst.xyz.z == 0)) 
+			return true; 
+		else {
+			of_dst.xyz.y = 0;
 			if (!IS_VEC_NULL_SQ_SAFE(&of_dst)) {
 				vm_vec_normalize(&of_dst);
 				// now we have 2d vector with lenght of 1 that points at the targets direction after being rotated to turrets FOR
-				if ((-of_dst.xyz.y + size_mod) >= tp->turret_y_fov)
+				if ((of_dst.xyz.z + size_mod) >= tp->turret_base_fov)
 					return true;
 			}
 		}
@@ -2841,7 +2812,7 @@ bool turret_adv_fov_test(ship_subsys *ss, vec3d *gvec, vec3d *v2e, float size_mo
 bool turret_fov_test(ship_subsys *ss, vec3d *gvec, vec3d *v2e, float size_mod)
 {
 	bool in_fov = false;
-	if (ss->system_info->flags[Model::Subsystem_Flags::Turret_alt_math])
+	if (ss->system_info->flags[Model::Subsystem_Flags::Turret_restricted_fov])
 		in_fov = turret_adv_fov_test(ss, gvec, v2e, size_mod);
 	else
 		in_fov = turret_std_fov_test(ss, gvec, v2e, size_mod);

code/asteroid/asteroid.cpp

@@ -55,8 +55,6 @@ const float LARGE_DEBRIS_WEIGHT = 1.0f;
 
 int	Asteroids_enabled = 1;
 int	Num_asteroids = 0;
-int	Asteroid_throw_objnum = -1;		//	Object index of ship to throw asteroids at.
-int	Next_asteroid_throw;
 
 SCP_vector< asteroid_info > Asteroid_info;
 asteroid			Asteroids[MAX_ASTEROIDS];
@@ -73,6 +71,55 @@ float	Asteroid_icon_closeup_zoom;
 #define	ASTEROID_UPDATE_COLLIDE_TIMESTAMP	2000	// how often asteroid is checked for impending collisions with escort ships
 #define	ASTEROID_MIN_COLLIDE_TIME				24		// time in seconds to check for asteroid colliding
 
+SCP_vector<SCP_string> Asteroid_target_ships;
+bool Default_asteroid_throwing_behavior = true;
+
+typedef struct asteroid_target {
+	int objnum;
+	int signature;
+	int throw_stamp;
+	int incoming_asteroids;
+} asteroid_target;
+
+// if default throwing behavior is enabled, then this should always have at most 1 target or possibly none, determined the retail way
+// if not, then this is whatever number of mission-specified ships (after they arrive, list is sanitized when they exit)
+SCP_vector<asteroid_target> Asteroid_targets;
+
+
+/**
+ * Return number of asteroids expected to collide with a ship.
+ */
+static int count_incident_asteroids(int target_objnum)
+{
+	object* asteroid_objp;
+	int		count;
+
+	count = 0;
+
+	for (asteroid_objp = GET_FIRST(&obj_used_list); asteroid_objp != END_OF_LIST(&obj_used_list); asteroid_objp = GET_NEXT(asteroid_objp)) {
+		if (asteroid_objp->type == OBJ_ASTEROID) {
+			asteroid* asp = &Asteroids[asteroid_objp->instance];
+
+			if (asp->target_objnum == target_objnum) {
+				count++;
+			}
+		}
+	}
+
+	return count;
+}
+
+// add a ship as a new asteroid target
+void asteroid_add_target(object* objp) {
+	asteroid_target new_target;
+	new_target.objnum = OBJ_INDEX(objp);
+	new_target.signature = objp->signature;
+	new_target.throw_stamp = timestamp(Random::next(500, 2000));
+	new_target.incoming_asteroids = count_incident_asteroids(OBJ_INDEX(objp)); // this *should* normally be 0
+
+	Asteroid_targets.push_back(new_target);
+}
+
 /**
  * Force updating of pair stuff for asteroid *objp.
  */
@@ -158,43 +205,28 @@ static float asteroid_cap_speed(int asteroid_info_index, float speed)
 	return speed;
 }
 
-/**
- * Returns whether position is inside inner bounding volume
- *
- * Sum together the following: 1 inside x, 2 inside y, 4 inside z
- * inside only when sum = 7
- */
-static int asteroid_in_inner_bound_with_axes(asteroid_field *asfieldp, vec3d *pos, float delta)
-{
-	Assert(asfieldp->has_inner_bound);
-
-	int rval = 0;
-	if ( (pos->xyz.x > asfieldp->inner_min_bound.xyz.x - delta) && (pos->xyz.x < asfieldp->inner_max_bound.xyz.x + delta) ) {
-		rval += 1;
-	}
-
-	if ( (pos->xyz.y > asfieldp->inner_min_bound.xyz.y - delta) && (pos->xyz.y < asfieldp->inner_max_bound.xyz.y + delta) ) {
-		rval += 2;
-	}
-
-	if ( (pos->xyz.z > asfieldp->inner_min_bound.xyz.z - delta) && (pos->xyz.z < asfieldp->inner_max_bound.xyz.z + delta) ) {
-		rval += 4;
-	}
-
-	return rval;
-}
-
 /**
  * Check if asteroid is within inner bound
  * @return 0 if not inside or no inner bound, 1 if inside inner bound
  */
-static int asteroid_in_inner_bound(asteroid_field *asfieldp, vec3d *pos, float delta) {
+static bool asteroid_in_inner_bound(asteroid_field *asfieldp, vec3d *pos, float delta) {
 
-	if (!asfieldp->has_inner_bound) {
-		return 0;
-	}
+	if (!asfieldp->has_inner_bound)
+		return false;
 
-	return (asteroid_in_inner_bound_with_axes(asfieldp, pos, delta) == 7);
+	return (pos->xyz.x > asfieldp->inner_min_bound.xyz.x - delta) && (pos->xyz.x < asfieldp->inner_max_bound.xyz.x + delta) &&
+		(pos->xyz.y > asfieldp->inner_min_bound.xyz.y - delta) && (pos->xyz.y < asfieldp->inner_max_bound.xyz.y + delta) &&
+		(pos->xyz.z > asfieldp->inner_min_bound.xyz.z - delta) && (pos->xyz.z < asfieldp->inner_max_bound.xyz.z + delta);
+}
+
+static bool asteroid_is_ship_inside_field(asteroid_field* asfieldp, vec3d* pos, float radius) {
+
+	radius *= 2.0f;
+
+	return pos->xyz.x + radius > Asteroid_field.min_bound.xyz.x && pos->xyz.x - radius < Asteroid_field.max_bound.xyz.x &&
+		   pos->xyz.y + radius > Asteroid_field.min_bound.xyz.y && pos->xyz.y - radius < Asteroid_field.max_bound.xyz.y &&
+	       pos->xyz.z + radius > Asteroid_field.min_bound.xyz.z && pos->xyz.z - radius < Asteroid_field.max_bound.xyz.z &&
+		   !asteroid_in_inner_bound(asfieldp, pos, radius);
 }
 
 /**
@@ -324,7 +356,7 @@ object *asteroid_create(asteroid_field *asfieldp, int asteroid_type, int asteroi
     asteroid_default_flagset += Object::Object_Flags::Physics;
     asteroid_default_flagset += Object::Object_Flags::Collides;
     
-    objnum = obj_create(OBJ_ASTEROID, -1, n, &orient, &pos, radius, asteroid_default_flagset);
+    objnum = obj_create(OBJ_ASTEROID, -1, n, &orient, &pos, radius, asteroid_default_flagset, false);
 	
 	if ( (objnum == -1) || (objnum >= MAX_OBJECTS) ) {
 		mprintf(("Couldn't create asteroid -- out of object slots\n"));
@@ -334,8 +366,8 @@ object *asteroid_create(asteroid_field *asfieldp, int asteroid_type, int asteroi
 	asp->objnum = objnum;
 	asp->model_instance_num = -1;
 
-	if (model_get(asip->model_num[asteroid_subtype])->flags & PM_FLAG_HAS_INTRINSIC_ROTATE) {
-		asp->model_instance_num = model_create_instance(false, asip->model_num[asteroid_subtype]);
+	if (model_get(asip->model_num[asteroid_subtype])->flags & PM_FLAG_HAS_INTRINSIC_MOTION) {
+		asp->model_instance_num = model_create_instance(objnum, asip->model_num[asteroid_subtype]);
 	}
 
 	// Add to Asteroid_used_list
@@ -496,7 +528,7 @@ void asteroid_create_all()
 
 	// ship_debris_odds_table keeps track of debris type of the next debris piece
 	// each different type (size) of debris piece has a diffenent weight, smaller weighted more heavily than larger.
-	// choose next type from table ship_debris_odds_table by rand()%max_weighted_range,
+	// choose next type from table ship_debris_odds_table by Random::next()%max_weighted_range,
 	// the threshold *below* which the debris type is selected.
 	struct {
 		float random_threshold;
@@ -512,6 +544,11 @@ void asteroid_create_all()
 		return;
 	}
 
+	if (Asteroid_field.num_used_field_debris_types <= 0) {
+		Warning(LOCATION, "An asteroid field is enabled, but no asteroid types were enabled.");
+		return;
+	}
+
 	int max_asteroids = Asteroid_field.num_initial_asteroids; // * (1.0f - 0.1f*(MAX_DETAIL_LEVEL-Detail.asteroid_density)));
 
 	int num_debris_types = 0;
@@ -564,12 +601,20 @@ void asteroid_create_all()
 			// For asteroid, load only large asteroids
 
 			// get a valid subtype
-			int subtype = rand() % NUM_DEBRIS_POFS;
-			while (Asteroid_field.field_debris_type[subtype] == -1) {
-				subtype = (subtype + 1) % NUM_DEBRIS_POFS;
+			int counter = Random::next(Asteroid_field.num_used_field_debris_types);
+			int subtype = -1;
+			for (int j = 0; j < NUM_DEBRIS_POFS; j++) {
+				if (Asteroid_field.field_debris_type[j] >= 0) {
+					if (counter == 0) {
+						subtype = j;
+						break;
+					} else
+						counter--;
+				}
 			}
 
-			asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
+			if (subtype >= 0)
+				asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
 		} else {
 			Assert(num_debris_types > 0);
 
@@ -593,11 +638,13 @@ void asteroid_level_init()
 {
 	Asteroid_field.num_initial_asteroids=0;
 	Num_asteroids = 0;
-	Next_asteroid_throw = timestamp(1);
+	Asteroid_targets.clear();
+	Default_asteroid_throwing_behavior = true;
 	asteroid_obj_list_init();
 	SCP_vector<asteroid_info>::iterator ast;
 	for (ast = Asteroid_info.begin(); ast != Asteroid_info.end(); ++ast)
 		ast->damage_type_idx = ast->damage_type_idx_sav;
+	Asteroid_field.num_used_field_debris_types = 0;
 }
 
 /**
@@ -733,52 +780,75 @@ static void asteroid_aim_at_target(object *objp, object *asteroid_objp, float de
 }
 
 /**
- * Call once per frame to maybe throw an asteroid at a ship.
+* Sanitizes the Asteroid targets list removing ships that have died/become invalid etc
+*/
+static void sanitize_asteroid_targets_list() {
+	for (size_t i = 0; i < Asteroid_targets.size();) {
+		object* target_objp = &Objects[Asteroid_targets[i].objnum];
+		if (target_objp->type != OBJ_SHIP || target_objp->signature != Asteroid_targets[i].signature) {
+			Asteroid_targets[i] = Asteroid_targets.back();
+			Asteroid_targets.pop_back();
+		}
+		else  // if we needed to cull we should not advance because we just moved a new asteroid target into this spot
+			i++;
+	}
+}
+
+/**
+ * Call once per frame to maybe throw some asteroids at one or more ships.
  *
- * @param count asteroids already targeted on
  */
-static void maybe_throw_asteroid(int count)
+static void maybe_throw_asteroid()
 {
-	if (!timestamp_elapsed(Next_asteroid_throw)) {
-		return;
-	}
 
-	if (Asteroid_throw_objnum == -1) {
-		return;
-	}
+	for (asteroid_target& target : Asteroid_targets) {
+		if (!timestamp_elapsed(target.throw_stamp))
+			continue;
 
-	nprintf(("AI", "Incoming asteroids: %i\n", count));
+		object* target_objp = &Objects[target.objnum];
+		if (!asteroid_is_ship_inside_field(&Asteroid_field, &target_objp->pos, target_objp->radius))
+			continue;
+		
+		// This should've been greater equal, but alas...
+		if (target.incoming_asteroids > The_mission.ai_profile->max_incoming_asteroids[Game_skill_level])
+			continue;
 
-	if (count > The_mission.ai_profile->max_incoming_asteroids[Game_skill_level])
-		return;
+		nprintf(("AI", "Incoming asteroids to %s: %i\n", Ships[target_objp->instance].ship_name, target.incoming_asteroids));
 
-	Next_asteroid_throw = timestamp(1000 + 1200 * count/(Game_skill_level+1));
+		target.throw_stamp = timestamp(1000 + 1200 * target.incoming_asteroids /(Game_skill_level+1));
 
-	ship_obj	*so;
-	for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
-		object *A = &Objects[so->objnum];
-		if (so->objnum == Asteroid_throw_objnum) {
-			int subtype = rand() % NUM_DEBRIS_POFS;
-			while (Asteroid_field.field_debris_type[subtype] == -1) {
-				subtype = (subtype + 1) % NUM_DEBRIS_POFS;
+		int counter = Random::next(Asteroid_field.num_used_field_debris_types);
+		int subtype = -1;
+		for (int i = 0; i < NUM_DEBRIS_POFS; i++) {
+			if (Asteroid_field.field_debris_type[i] >= 0) {
+				if (counter == 0) {
+					subtype = i;
+					break;
+				}
+				else
+					counter--;
 			}
-			object *objp = asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
-			if (objp != NULL) {
-				asteroid_aim_at_target(A, objp, ASTEROID_MIN_COLLIDE_TIME + frand() * 20.0f);
+		}
 
-				// if asteroid is inside inner bound, kill it
-				if (asteroid_in_inner_bound(&Asteroid_field, &objp->pos, 0.0f)) {
-					objp->flags.set(Object::Object_Flags::Should_be_dead);
-				} else {
-					Asteroids[objp->instance].target_objnum = so->objnum;
+		// this really shouldn't happen but just in case...
+		if (subtype < 0)
+			return;
 
-					if ( MULTIPLAYER_MASTER ) {
-						send_asteroid_throw( objp );
-					}
+		object *objp = asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
+		if (objp != nullptr) {
+			asteroid_aim_at_target(target_objp, objp, ASTEROID_MIN_COLLIDE_TIME + frand() * 20.0f);
+
+			// if asteroid is inside inner bound, kill it
+			if (asteroid_in_inner_bound(&Asteroid_field, &objp->pos, 0.0f)) {
+				objp->flags.set(Object::Object_Flags::Should_be_dead);
+			} else {
+				Asteroids[objp->instance].target_objnum = target.objnum;
+				target.incoming_asteroids++;
+
+				if ( MULTIPLAYER_MASTER ) {
+					send_asteroid_throw( objp );
 				}
 			}
-
-			return;
 		}
 	}
 
@@ -800,6 +870,13 @@ void asteroid_delete( object * obj )
 	if (asp->model_instance_num >= 0)
 		model_delete_instance(asp->model_instance_num);
 
+	if (asp->target_objnum >= 0) {
+		for (asteroid_target& target : Asteroid_targets) {
+			if (asp->target_objnum == target.objnum)
+				target.incoming_asteroids--;
+		}
+	}
+
 	asp->flags = 0;
 	Num_asteroids--;
 	Assert(Num_asteroids >= 0);
@@ -838,7 +915,14 @@ static void asteroid_maybe_reposition(object *objp, asteroid_field *asfieldp)
 				} else {
 					// check to ensure player won't see asteroid appear either
 					asteroid_wrap_pos(objp, asfieldp);
-					Asteroids[objp->instance].target_objnum = -1;
+					asteroid* astp = &Asteroids[objp->instance];
+
+					// this doesnt count as a thrown asteroid anymore
+					for (asteroid_target& target : Asteroid_targets)
+						if (target.objnum == astp->target_objnum)
+							target.incoming_asteroids--;
+
+					astp->target_objnum = -1;
 
 					dist = vm_vec_normalized_dir(&vec_to_asteroid, &objp->pos, &Eye_position);
 					dot = vm_vec_dot(&Eye_matrix.vec.fvec, &vec_to_asteroid);
@@ -918,9 +1002,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 				vec3d normal;
 
 				if (mc.model_instance_num >= 0)
-					model_instance_find_world_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
+					model_instance_local_to_global_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
 				else
-					model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
+					model_local_to_global_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
 
 				*hitnormal = normal;
 			}
@@ -950,11 +1034,11 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 	// find the light object's position in the heavy object's reference frame at last frame and also in this frame.
 	vec3d p0_temp, p0_rotated;
 		
-	// Collision detection from rotation enabled if at rotaion is less than 30 degree in frame
+	// Collision detection from rotation enabled if at rotation is less than 30 degree in frame
 	// This should account for all ships
 	if ( (vm_vec_mag_squared( &heavy->phys_info.rotvel ) * flFrametime*flFrametime) < (PI*PI/36) ) {
 		// collide_rotate calculate (1) start position and (2) relative velocity
-		asteroid_hit_info->collide_rotate = 1;
+		asteroid_hit_info->collide_rotate = true;
 		vm_vec_rotate( &p0_temp, &p0, &heavy->last_orient );
 		vm_vec_unrotate( &p0_rotated, &p0_temp, &heavy->orient );
 		mc.p0 = &p0_rotated;				// Point 1 of ray to check
@@ -962,11 +1046,11 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		vm_vec_scale( &asteroid_hit_info->light_rel_vel, 1/flFrametime );
 		// HACK - this applies to big ships warping in/out of asteroid fields - not sure what it does
 		if (vm_vec_mag(&asteroid_hit_info->light_rel_vel) > 300) {
-			asteroid_hit_info->collide_rotate = 0;
+			asteroid_hit_info->collide_rotate = false;
 			vm_vec_sub( &asteroid_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel );
 		}
 	} else {
-		asteroid_hit_info->collide_rotate = 0;
+		asteroid_hit_info->collide_rotate = false;
 		vm_vec_sub( &asteroid_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel );
 	}
 
@@ -998,18 +1082,18 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 
 			// Do collision the cool new way
 			if ( asteroid_hit_info->collide_rotate ) {
-				// We collide with the sphere, find the list of rotating submodels and test one at a time
+				// We collide with the sphere, find the list of moving submodels and test one at a time
 				SCP_vector<int> submodel_vector;
-				model_get_rotating_submodel_list(&submodel_vector, heavy_obj);
+				model_get_moving_submodel_list(submodel_vector, heavy_obj);
 
-				// turn off all rotating submodels, collide against only 1 at a time.
-				// turn off collision detection for all rotating submodels
+				// turn off all moving submodels, collide against only 1 at a time.
+				// turn off collision detection for all moving submodels
 				for (auto submodel: submodel_vector) {
 					pmi->submodel[submodel].collision_checked = true;
 				}
 
-				// reset flags to check MC_CHECK_MODEL | MC_CHECK_SPHERELINE and maybe MC_CHECK_INVISIBLE_FACES and MC_SUBMODEL_INSTANCE
-				mc.flags = copy_flags | MC_SUBMODEL_INSTANCE;
+				// Only check single submodel now, since children of moving submodels are handled as moving as well
+				mc.flags = copy_flags | MC_SUBMODEL;
 
 				// check each submodel in turn
 				for (auto submodel: submodel_vector) {
@@ -1018,15 +1102,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 					// turn on just one submodel for collision test
 					smi->collision_checked = false;
 
-					// set angles for last frame (need to set to prev to get p0)
-					matrix copy_matrix = smi->canonical_orient;
-
 					// find the start and end positions of the sphere in submodel RF
-					smi->canonical_orient = smi->canonical_prev_orient;
-					world_find_model_instance_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos);
-
-					smi->canonical_orient = copy_matrix;
-					world_find_model_instance_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
+					model_instance_global_to_local_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos, true);
+					model_instance_global_to_local_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
 
 					mc.p0 = &p0;
 					mc.p1 = &p1;
@@ -1039,18 +1117,18 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 							mc_ret_val = 1;
 
 							// set up asteroid_hit_info common
-							set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_ROT_HIT);
+							set_hit_struct_info(asteroid_hit_info, &mc, true);
 
 							// set up asteroid_hit_info for rotating submodel
-							if (asteroid_hit_info->edge_hit == 0) {
-								model_instance_find_world_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+							if (!asteroid_hit_info->edge_hit) {
+								model_instance_local_to_global_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 							}
 
 							// find position in submodel RF of light object at collison
 							vec3d int_light_pos, diff;
 							vm_vec_sub(&diff, mc.p1, mc.p0);
 							vm_vec_scale_add(&int_light_pos, mc.p0, &diff, mc.hit_dist);
-							model_instance_find_world_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							model_instance_local_to_global_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
 						}
 					}
 					// Don't look at this submodel again
@@ -1071,11 +1149,11 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 				if (mc.hit_dist < asteroid_hit_info->hit_time) {
 					mc_ret_val = 1;
 
-					set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_NO_ROT_HIT);
+					set_hit_struct_info(asteroid_hit_info, &mc, false);
 
 					// get collision normal if not edge hit
-					if (asteroid_hit_info->edge_hit == 0) {
-						model_instance_find_world_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+					if (!asteroid_hit_info->edge_hit) {
+						model_instance_local_to_global_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 					}
 
 					// find position in submodel RF of light object at collison
@@ -1100,7 +1178,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 		mc_ret_val = model_collide(&mc);
 
 		if (mc_ret_val) {
-			set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_NO_ROT_HIT);
+			set_hit_struct_info(asteroid_hit_info, &mc, false);
 
 			// set normal if not edge hit
 			if ( !asteroid_hit_info->edge_hit ) {
@@ -1324,7 +1402,7 @@ static void asteroid_do_area_effect(object *asteroid_objp)
 		if ( weapon_area_calc_damage(ship_objp, &asteroid_objp->pos, asip->inner_rad, asip->outer_rad, asip->blast, asip->damage, &blast, &damage, asip->outer_rad) == -1 )
 			continue;
 
-		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage );
+		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage, asip->damage_type_idx);
 		weapon_area_apply_blast(NULL, ship_objp, &asteroid_objp->pos, blast, 0);
 	}	// end for
 }
@@ -1432,9 +1510,14 @@ static void asteroid_maybe_break_up(object *pasteroid_obj)
 
 	if ( timestamp_elapsed(asp->final_death_time) ) {
 		vec3d	relvec, vfh, tvec;
+		bool skip = false;
+		bool hooked = Script_system.IsActiveAction(CHA_DEATH);
 
-		Script_system.SetHookObject("Self", pasteroid_obj);
-		if(!Script_system.IsConditionOverride(CHA_DEATH, pasteroid_obj))
+		if (hooked) {
+			Script_system.SetHookObject("Self", pasteroid_obj);
+			skip = Script_system.IsConditionOverride(CHA_DEATH, pasteroid_obj);
+		}
+		if (!skip)
 		{
 			pasteroid_obj->flags.set(Object::Object_Flags::Should_be_dead);
 
@@ -1484,7 +1567,7 @@ static void asteroid_maybe_break_up(object *pasteroid_obj)
 						int num_roids_var = split->max - split->min;
 
 						if (num_roids_var > 0)
-							num_roids += rand() % num_roids_var;
+							num_roids += Random::next(num_roids_var);
 
 						if (num_roids > 0)
 							for (int i=0; i<num_roids; i++)
@@ -1539,8 +1622,10 @@ static void asteroid_maybe_break_up(object *pasteroid_obj)
 			}
 			asp->final_death_time = timestamp(-1);
 		}
-		Script_system.RunCondition(CHA_DEATH, pasteroid_obj);
-		Script_system.RemHookVar("Self");
+		if (hooked) {
+			Script_system.RunCondition(CHA_DEATH, pasteroid_obj);
+			Script_system.RemHookVar("Self");
+		}
 	}
 }
 
@@ -2005,29 +2090,6 @@ static void asteroid_parse_tbl()
 	}
 }
 
-/**
- * Return number of asteroids expected to collide with a ship.
- */
-static int count_incident_asteroids()
-{
-	object	*asteroid_objp;
-	int		count;
-
-	count = 0;
-
-	for ( asteroid_objp = GET_FIRST(&obj_used_list); asteroid_objp !=END_OF_LIST(&obj_used_list); asteroid_objp = GET_NEXT(asteroid_objp) ) {
-		if (asteroid_objp->type == OBJ_ASTEROID ) {
-			asteroid *asp = &Asteroids[asteroid_objp->instance];
-
-			if ( asp->target_objnum >= 0 ) {
-				count++;
-			}
-		}
-	}
-
-	return count;
-}
-
 /**
  * Pick object to throw asteroids at.
  * Pick any capital or big ship inside the bounds of the asteroid field.
@@ -2042,17 +2104,10 @@ static int set_asteroid_throw_objnum()
 
 	for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
 		ship_objp = &Objects[so->objnum];
-		float		radius = ship_objp->radius*2.0f;
 
 		if (Ship_info[Ships[ship_objp->instance].ship_info_index].is_big_or_huge()) {
-			if (ship_objp->pos.xyz.x + radius > Asteroid_field.min_bound.xyz.x)
-				if (ship_objp->pos.xyz.y + radius > Asteroid_field.min_bound.xyz.y)
-				if (ship_objp->pos.xyz.z + radius > Asteroid_field.min_bound.xyz.z)
-				if (ship_objp->pos.xyz.x - radius < Asteroid_field.max_bound.xyz.x)
-				if (ship_objp->pos.xyz.y - radius < Asteroid_field.max_bound.xyz.y)
-				if (ship_objp->pos.xyz.z - radius < Asteroid_field.max_bound.xyz.z)
-				if (!asteroid_in_inner_bound(&Asteroid_field, &ship_objp->pos, radius))
-					return so->objnum;
+			if (asteroid_is_ship_inside_field(&Asteroid_field, &ship_objp->pos, ship_objp->radius))
+				return so->objnum;
 		}
 	}
 	return -1;
@@ -2069,9 +2124,18 @@ void asteroid_frame()
 		return;
 	}
 
-	Asteroid_throw_objnum = set_asteroid_throw_objnum();
+	if (Default_asteroid_throwing_behavior) {
+		int objnum = set_asteroid_throw_objnum();
+		if (Asteroid_targets.empty() || Asteroid_targets[0].objnum != objnum) {
+			Asteroid_targets.clear();
+			if (objnum >= 0)
+				asteroid_add_target(&Objects[objnum]);
+		}
+	} 
 
-	maybe_throw_asteroid(count_incident_asteroids());
+	sanitize_asteroid_targets_list();
+
+	maybe_throw_asteroid();
 }
 
 /**

code/asteroid/asteroid.h

@@ -36,6 +36,11 @@ class model_draw_list;
 // Goober5000 - currently same as MAX_SHIP_DETAIL_LEVELS (put here to avoid an #include)
 #define MAX_ASTEROID_DETAIL_LEVELS	5
 
+// whether to do retail behavior, just throw at the first big ship in the field
+// must be explicitly opted out of by the mission
+extern bool Default_asteroid_throwing_behavior;
+
+extern SCP_vector<SCP_string> Asteroid_target_ships;
 
 // Data structure to track the active asteroids
 typedef struct asteroid_obj {
@@ -138,6 +143,7 @@ typedef	struct asteroid_field {
 	field_type_t		field_type;		// active throws and wraps, passive does not
 	debris_genre_t	debris_genre;		// type of debris (ship or asteroid)  [generic type]
 	int				field_debris_type[MAX_ACTIVE_DEBRIS_TYPES];	// one of the debris type defines above
+	int				num_used_field_debris_types;	// how many of the above are used
 } asteroid_field;
 
 extern SCP_vector< asteroid_info > Asteroid_info;
@@ -165,6 +171,7 @@ int	asteroid_collide_objnum(object *asteroid_objp);
 float asteroid_time_to_impact(object *asteroid_objp);
 void	asteroid_show_brackets();
 void	asteroid_target_closest_danger();
+void asteroid_add_target(object* objp);
 
 // need to extern for multiplayer
 void asteroid_sub_create(object *parent_objp, int asteroid_type, vec3d *relvec);

code/autopilot/autopilot.cpp

@@ -716,7 +716,7 @@ bool StartAutopilot()
 		vm_vec_scale(&pos, 5*speed_cap*tc_factor); // pos is now scaled by 5 times the speed (5 seconds ahead)
 		vm_vec_add(&pos, &pos, &Autopilot_flight_leader->pos); // pos is now 5*speed cap in front of player ship
 
-		switch (myrand()%24) 
+		switch (Random::next(24))
 		// 8 different ways of getting perp points
 		// 4 of which will not be used when capships are present (anything below, or straight above)
 		{
@@ -795,7 +795,8 @@ bool StartAutopilot()
 		vm_vec_scale(&perp,  Autopilot_flight_leader->radius+radius);
 
 		// randomly scale up/down by up to 20%
-		j = 20-myrand()%40; // [-20,20]
+		// jg18 - original comment said [-20,20] but preserving existing behavior
+		j = Random::next(-19, 20);
 
 		vm_vec_scale(&perp, 1.0f+(float(j)/100.0f));
 		vm_vec_add(&cameraPos, &pos, &perp);

code/bmpman/bmpman.cpp

@@ -1120,7 +1120,7 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int
 	return 0;
 }
 
-int bm_load(const char *real_filename) {
+int bm_load(const char *real_filename, int dir_type) {
 	int free_slot = -1;
 	int w, h, bpp = 8;
 	int rc = 0;
@@ -1152,6 +1152,7 @@ int bm_load(const char *real_filename) {
 	if (Is_standalone) {
 		char standalone_filename[MAX_FILENAME_LEN] = "right_bracket";
 		strcpy_s(filename, standalone_filename);
+		dir_type = CF_TYPE_INTERFACE;
 	}
 
 	// safety catch for strcat...
@@ -1164,11 +1165,11 @@ int bm_load(const char *real_filename) {
 	// Lets find out what type it is
 	{
 		// see if it's already loaded (checks for any type with filename)
-		if (bm_load_sub_fast(filename, &handle))
+		if (bm_load_sub_fast(filename, &handle, dir_type))
 			return handle;
 
 		// if we are still here then we need to fall back to a file-based search
-		int rval = bm_load_sub_slow(filename, BM_NUM_TYPES, bm_ext_list, &img_cfp);
+		int rval = bm_load_sub_slow(filename, BM_NUM_TYPES, bm_ext_list, &img_cfp, dir_type);
 
 		if (rval < 0)
 			return -1;
@@ -1224,7 +1225,7 @@ int bm_load(const char *real_filename) {
 	entry->bm.palette = nullptr;
 	entry->num_mipmaps = mm_lvl;
 	entry->mem_taken = (size_t)bm_size;
-	entry->dir_type = CF_TYPE_ANY;
+	entry->dir_type = dir_type;
 	entry->handle = handle;
 
 	entry->load_count++;
@@ -1235,8 +1236,8 @@ int bm_load(const char *real_filename) {
 	return handle;
 }
 
-int bm_load(const SCP_string& filename) {
-	return bm_load(filename.c_str());
+int bm_load(const SCP_string& filename, int dir_type) {
+	return bm_load(filename.c_str(), dir_type);
 }
 
 bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int *nfps, int *key, BM_TYPE *type) {
@@ -1424,7 +1425,7 @@ static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
 	return 0;
 }
 
-int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *keyframe, float *total_time, bool can_drop_frames, int dir_type) {
+int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *keyframe, float *total_time, bool can_drop_frames, int dir_type, bool rethrow_exceptions) {
 	int	i, n;
 	anim	the_anim;
 	CFILE	*img_cfp = nullptr;
@@ -1466,6 +1467,7 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 	if (Is_standalone) {
 		char standalone_filename[MAX_FILENAME_LEN] = "cursorweb";
 		strcpy_s(filename, standalone_filename);
+		dir_type = CF_TYPE_INTERFACE;
 	}
 
 	// safety catch for strcat...
@@ -1594,10 +1596,15 @@ int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *ke
 			img_size = the_apng.imgsize();
 		}
 		catch (const apng::ApngException& e) {
-			mprintf(("Failed to load apng: %s\n", e.what() ));
 			if (img_cfp != nullptr)
 				cfclose(img_cfp);
-			return -1;
+			if (rethrow_exceptions) {
+				throw e;
+			}
+			else {
+				mprintf(("Failed to load apng: %s\n", e.what()));
+				return -1;
+			}
 		}
 	}
 	else {
@@ -1789,7 +1796,7 @@ int bm_load_either(const char *filename, int *nframes, int *fps, int *keyframe,
 		*fps = 0;
 	int tidx = bm_load_animation(filename, nframes, fps, keyframe, nullptr, can_drop_frames, dir_type);
 	if (tidx == -1) {
-		tidx = bm_load(filename);
+		tidx = bm_load(filename, dir_type);
 		if (tidx != -1 && nframes != NULL)
 			*nframes = 1;
 	}

code/bmpman/bmpman.h

@@ -177,7 +177,7 @@ void clear_bm_lookup_cache();
  * @returns The bitmap number if successful, else
  * @returns a negative value if not
  */
-int bm_load(const char* filename);
+int bm_load(const char* filename, int dir_type = CF_TYPE_ANY);
 
 /**
  * @brief Loads a bitmap so we can draw with it later. (Preferred version)
@@ -187,7 +187,7 @@ int bm_load(const char* filename);
  * @returns The bitmap number if successful, else
  * @returns a negative value if not
  */
-int bm_load(const SCP_string& filename);
+int bm_load(const SCP_string& filename, int dir_type = CF_TYPE_ANY);
 
 /**
  * @brief Reloads a bitmap as a duplicate.
@@ -289,7 +289,14 @@ bool bm_release_rendertarget(int handle);
  * @returns The bm number of the first bitmap in the sequence if successful, or
  * @returns A negative value if unsuccessful
  */
-int bm_load_animation(const char *filename, int *nframes = nullptr, int *fps = nullptr, int *keyframe = nullptr, float *total_time = nullptr, bool can_drop_frames = 0, int dir_type = CF_TYPE_ANY);
+int bm_load_animation(const char *filename,
+	int *nframes = nullptr,
+	int *fps = nullptr,
+	int *keyframe = nullptr,
+	float *total_time = nullptr,
+	bool can_drop_frames = false,
+	int dir_type = CF_TYPE_ANY,
+	bool rethrow_exceptions = false);
 
 /**
  * @brief Loads either animation (bm_load_animation) or still image (bm_load)

code/camera/camera.cpp

@@ -43,7 +43,7 @@ auto FovOption = options::OptionBuilder<float>("Graphics.FOV", "Field Of View",
                      .finish();
 
 //*************************CLASS: camera*************************
-//This is where the camera class beings! :D
+//This is where the camera class begins! :D
 camera::camera(const char *in_name, int in_signature)
 {
 	set_name(in_name);
@@ -237,12 +237,15 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 {
 	matrix temp_matrix = IDENTITY_MATRIX;
 
-	if(in_target != NULL)
+	if (in_target != nullptr)
 	{
-		vec3d position = vmd_zero_vector;
-		this->get_info(&position, NULL);
+		vec3d position;
+		matrix orient_buf;
+		auto orient = Use_host_orientation_for_set_camera_facing ? &orient_buf : nullptr;
 
-		if(in_target->xyz.x == position.xyz.x && in_target->xyz.y == position.xyz.y && in_target->xyz.z == position.xyz.z)
+		this->get_info(&position, orient, false);
+
+		if (vm_vec_same(in_target, &position))
 		{
 			Warning(LOCATION, "Camera tried to point to self");
 			return;
@@ -250,7 +253,25 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 
 		vec3d targetvec;
 		vm_vec_normalized_dir(&targetvec, in_target, &position);
-		vm_vector_2_matrix(&temp_matrix, &targetvec, NULL, NULL);
+
+		if (Use_host_orientation_for_set_camera_facing)
+		{
+			// point along the target vector, but using the host orient's roll
+			vm_vector_2_matrix(&temp_matrix, &targetvec, &orient->vec.uvec, nullptr);
+
+			// if we have a host, we need the difference between the camera's current orient and the orient we want
+			// if not, we will later set the absolute orientation, rather than the orientation relative to the host
+			if (object_host.IsValid())
+			{
+				vm_transpose(orient);
+				temp_matrix = temp_matrix * *orient;
+			}
+		}
+		else
+		{
+			// point directly along the target vector
+			vm_vector_2_matrix(&temp_matrix, &targetvec, nullptr, nullptr);
+		}
 	}
 
 	set_rotation(&temp_matrix, in_rotation_time, in_rotation_acceleration_time, in_rotation_deceleration_time);
@@ -298,13 +319,16 @@ float camera::get_fov()
 }
 
 eye* get_submodel_eye(polymodel *pm, int submodel_num);
-void camera::get_info(vec3d *position, matrix *orientation)
+void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_orientation)
 {
 	if(position == NULL && orientation == NULL)
 		return;
 	
 	eye* eyep = NULL;
 	vec3d host_normal;
+	matrix host_orient = vmd_identity_matrix;
+	bool use_host_orient = false;
+
 	//POSITION
 	if(!(flags & CAM_STATIONARY_POS) || object_host.IsValid())
 	{
@@ -342,16 +366,19 @@ void camera::get_info(vec3d *position, matrix *orientation)
 					Assertion(objp->type == OBJ_SHIP, "This part of the code expects the object to be a ship");
 
 					vec3d c_pos_in;
-					find_submodel_instance_point_normal(&c_pos_in, &host_normal, pm, pmi, eyep->parent, &eyep->pnt, &eyep->norm);
+					model_instance_local_to_global_point_dir(&c_pos_in, &host_normal, &eyep->pnt, &eyep->norm, pm, pmi, eyep->parent);
 					vm_vec_unrotate(&c_pos, &c_pos_in, &objp->orient);
 					vm_vec_add2(&c_pos, &objp->pos);
 				}
 				else
 				{
 					if (pmi != nullptr)
-						model_instance_find_world_point(&c_pos, &pt, pm, pmi, object_host_submodel, &objp->orient, &objp->pos);
+					{
+						model_instance_local_to_global_point_orient(&c_pos, &host_orient, &pt, &vmd_identity_matrix, pm, pmi, object_host_submodel, &objp->orient, &objp->pos);
+						use_host_orient = true;
+					}
 					else
-						model_find_world_point( &c_pos, &pt, pm, object_host_submodel, &objp->orient, &objp->pos );
+						model_local_to_global_point( &c_pos, &pt, pm, object_host_submodel, &objp->orient, &objp->pos );
 				}
 			}
 		}
@@ -367,7 +394,7 @@ void camera::get_info(vec3d *position, matrix *orientation)
 		}
 	}
 
-	if(position != NULL)
+	if (position != nullptr)
 		*position = c_pos;
 
 	//ORIENTATION
@@ -378,32 +405,32 @@ void camera::get_info(vec3d *position, matrix *orientation)
 		{
 			if(object_target.IsValid())
 			{
-				object *objp = object_target.objp;
-				int model_num = object_get_model(objp);
-				polymodel *pm = nullptr;
-				polymodel_instance *pmi = nullptr;
+				object *target_objp = object_target.objp;
+				int model_num = object_get_model(target_objp);
+				polymodel *target_pm = nullptr;
+				polymodel_instance *target_pmi = nullptr;
 				vec3d target_pos = vmd_zero_vector;
 				
 				//See if we can get the model
 				if(model_num >= 0)
 				{
-					pm = model_get(model_num);
-					if (objp->type == OBJ_SHIP)
-						pmi = model_get_instance(Ships[objp->instance].model_instance_num);
+					target_pm = model_get(model_num);
+					if (target_objp->type == OBJ_SHIP)
+						target_pmi = model_get_instance(Ships[target_objp->instance].model_instance_num);
 				}
 
 				//If we don't have a submodel or don't have the model use object pos
 				//Otherwise, find the submodel pos as it is rotated
-				if(object_target_submodel < 0 || pm == NULL)
+				if (object_target_submodel < 0 || target_pm == nullptr)
 				{
-					target_pos = objp->pos;
+					target_pos = target_objp->pos;
 				}
 				else
 				{
-					if (pmi != nullptr)
-						model_instance_find_world_point(&target_pos, &vmd_zero_vector, pm, pmi, object_target_submodel, &objp->orient, &objp->pos);
+					if (target_pmi != nullptr)
+						model_instance_local_to_global_point(&target_pos, &vmd_zero_vector, target_pm, target_pmi, object_target_submodel, &target_objp->orient, &target_objp->pos);
 					else
-						model_find_world_point( &target_pos, &vmd_zero_vector, pm, object_target_submodel, &objp->orient, &objp->pos );
+						model_local_to_global_point( &target_pos, &vmd_zero_vector, target_pm, object_target_submodel, &target_objp->orient, &target_objp->pos );
 				}
 
 				vec3d targetvec;
@@ -418,6 +445,10 @@ void camera::get_info(vec3d *position, matrix *orientation)
 					vm_vector_2_matrix(&c_ori, &host_normal, vm_vec_same(&host_normal, &object_host.objp->orient.vec.uvec)?NULL:&object_host.objp->orient.vec.uvec, NULL);
 					target_set = true;
 				}
+				else if (use_host_orient)
+				{
+					c_ori = host_orient;
+				}
 				else
 				{
 					c_ori = object_host.objp->orient;
@@ -428,23 +459,30 @@ void camera::get_info(vec3d *position, matrix *orientation)
 				c_ori = vmd_identity_matrix;
 			}
 
-			matrix mtxA = c_ori;
-			matrix mtxB = IDENTITY_MATRIX;
-			float pos = 0.0f;
-			for(int i = 0; i < 9; i++)
+			//Do custom orientation stuff, if needed
+			if (func_custom_orientation != nullptr && !target_set)
 			{
-				ori[i].get(&pos, NULL);
-				mtxB.a1d[i] = pos;
+				func_custom_orientation(this, &c_ori);
 			}
-			vm_matrix_x_matrix(&c_ori, &mtxA, &mtxB);
 
-			vm_orthogonalize_matrix(&c_ori);
-		}
-		//Do custom orientation stuff, if needed
-		if(func_custom_orientation != NULL && !target_set)
-		{
-			func_custom_orientation(this, &c_ori);
+			// only do this if we want to find where the camera is actually pointing;
+			// skip this if we just want the orientation of the host
+			if (apply_camera_orientation)
+			{
+				matrix mtxA = c_ori;
+				matrix mtxB = IDENTITY_MATRIX;
+				float pos = 0.0f;
+				for (int i = 0; i < 9; i++)
+				{
+					ori[i].get(&pos, nullptr);
+					mtxB.a1d[i] = pos;
+				}
+				vm_matrix_x_matrix(&c_ori, &mtxA, &mtxB);
+
+				vm_orthogonalize_matrix(&c_ori);
+			}
 		}
+
 		*orientation = c_ori;
 	}
 }
@@ -560,9 +598,9 @@ void warp_camera::get_info(vec3d *position, matrix *orientation)
 #define MAX_SUBTITLE_LINES		64
 subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char* in_imageanim, float in_display_time,
 	float in_fade_time, const color *in_text_color, int in_text_fontnum, bool center_x, bool center_y, int in_width,
-	int in_height, bool in_post_shaded)
-	:display_time(-1.0f), fade_time(-1.0f), text_fontnum(-1), time_displayed(-1.0f), time_displayed_end(-1.0f),
-	post_shaded(false)
+	int in_height, bool in_post_shaded, float in_line_height_factor)
+	: display_time(-1.0f), fade_time(-1.0f), text_fontnum(-1), line_height_factor(1.0f),
+	image_id(-1), time_displayed(-1.0f), time_displayed_end(-1.0f), post_shaded(false)
 {
 	// Initialize color
 	gr_init_color(&text_color, 0, 0, 0);
@@ -573,7 +611,6 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 	memset( imageanim, 0, sizeof(imageanim) );
 	memset( &text_pos, 0, 2*sizeof(int) );
 	memset( &image_pos, 0, 4*sizeof(int) );
-	image_id = -1;
 
 	if ( ((in_text != NULL) && (strlen(in_text) <= 0)) && ((in_imageanim != NULL) && (strlen(in_imageanim) <= 0)) )
 		return;
@@ -585,7 +622,6 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 		in_text = text_buf.c_str();
 	}
 
-
 	int num_text_lines = 0;
 	const char *text_line_ptrs[MAX_SUBTITLE_LINES];
 	int text_line_lens[MAX_SUBTITLE_LINES];
@@ -608,6 +644,7 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 	else
 		gr_init_alphacolor(&text_color, 255, 255, 255, 255);
 	text_fontnum = in_text_fontnum;
+	line_height_factor = in_line_height_factor;
 
 	//Setup display and fade time
 	display_time = fl_abs(in_display_time);
@@ -646,7 +683,7 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 			if(w > tw)
 				tw = w;
 
-			th += h;
+			th += fl2i(line_height_factor * h);
 		}
 
 		// restore old font
@@ -744,7 +781,7 @@ void subtitle::do_frame(float frametime)
 	for(SCP_vector<SCP_string>::iterator line = text_lines.begin(); line != text_lines.end(); ++line)
 	{
 		gr_string(x, y, (char*)line->c_str(), GR_RESIZE_NONE);
-		y += font_height;
+		y += fl2i(line_height_factor * font_height);
 	}
 
 	// restore old font
@@ -793,9 +830,9 @@ subtitle::~subtitle()
 
 void subtitle::clone(const subtitle &sub)
 {
-
 	text_lines = sub.text_lines;
 	text_fontnum = sub.text_fontnum;
+	line_height_factor = sub.line_height_factor;
 
 	// copy the structs
 	text_pos = sub.text_pos;

code/camera/camera.h

@@ -75,7 +75,7 @@ public:
 	object *get_object_target();
 	int get_object_target_submodel();
 	float get_fov();
-	void get_info(vec3d *position, matrix *orientation);
+	void get_info(vec3d *position, matrix *orientation, bool apply_camera_orientation = true);
 
 	//Is
 	bool is_empty(){return sig < 0;}
@@ -123,6 +123,7 @@ private:
 	float fade_time;
 	color text_color;
 	int text_fontnum;
+	float line_height_factor;
 
 	//Done with set
 	char imageanim[MAX_FILENAME_LEN];
@@ -139,7 +140,8 @@ private:
 public:
 	subtitle(int in_x_pos, int in_y_pos, const char* in_text = NULL, const char* in_imageanim = NULL,
 			 float in_display_time = 0, float in_fade_time = 0.0f, const color *in_text_color = NULL, int in_text_fontnum = -1,
-			 bool center_x = false, bool center_y = false, int in_width = 0, int in_height = 0, bool post_shaded=false);
+			 bool center_x = false, bool center_y = false, int in_width = 0, int in_height = 0, bool post_shaded = false,
+			 float in_line_height_factor = 1.0f);
 	~subtitle();
 
     subtitle(const subtitle &sub) { clone(sub); }

code/cfile/cfile.cpp

@@ -80,7 +80,7 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ CF_TYPE_SINGLE_PLAYERS,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "single",				".pl2 .cs2 .plr .csg .css .json",	CF_TYPE_PLAYERS	},
 	{ CF_TYPE_MULTI_PLAYERS,		"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "multi",				".plr .json",						CF_TYPE_PLAYERS	},
 	{ CF_TYPE_CACHE,				"data" DIR_SEPARATOR_STR "cache",											".clr .tmp .bx",					CF_TYPE_DATA	}, 	//clr=cached color
-	{ CF_TYPE_MULTI_CACHE,			"data" DIR_SEPARATOR_STR "multidata",										".pcx .png .dds .fs2 .txt",				CF_TYPE_DATA	},
+	{ CF_TYPE_MULTI_CACHE,			"data" DIR_SEPARATOR_STR "multidata",										".pcx .png .jpg .dds .fs2 .txt",		CF_TYPE_DATA	},
 	{ CF_TYPE_MISSIONS,				"data" DIR_SEPARATOR_STR "missions",										".fs2 .fc2 .ntl .ssv",				CF_TYPE_DATA	},
 	{ CF_TYPE_CONFIG,				"data" DIR_SEPARATOR_STR "config",											".cfg .tbl .tbm .xml .csv",			CF_TYPE_DATA	},
 	{ CF_TYPE_DEMOS,				"data" DIR_SEPARATOR_STR "demos",											".fsd",								CF_TYPE_DATA	},
@@ -91,6 +91,7 @@ cf_pathtype Pathtypes[CF_MAX_PATH_TYPES]  = {
 	{ CF_TYPE_FREDDOCS,				"data" DIR_SEPARATOR_STR "freddocs",										".html",							CF_TYPE_DATA	},
 	{ CF_TYPE_INTERFACE_MARKUP,		"data" DIR_SEPARATOR_STR "interface" DIR_SEPARATOR_STR "markup",			".rml",								CF_TYPE_INTERFACE	},
 	{ CF_TYPE_INTERFACE_CSS,		"data" DIR_SEPARATOR_STR "interface" DIR_SEPARATOR_STR "css",				".rcss",							CF_TYPE_INTERFACE	},
+	{ CF_TYPE_PLAYER_BINDS,			"data" DIR_SEPARATOR_STR "players" DIR_SEPARATOR_STR "presets",				".json",							CF_TYPE_PLAYERS	},
 };
 // clang-format on
 
@@ -866,6 +867,7 @@ static int cfget_cfile_block()
 			cfile->data = nullptr;
 			cfile->fp = nullptr;
 			cfile->type = CFILE_BLOCK_USED;
+			cf_clear_compression_info(cfile);
 			return i;
 		}
 	}
@@ -921,7 +923,7 @@ int cfclose( CFILE * cfile )
 	} else {
 		// VP  do nothing
 	}
-
+	cf_clear_compression_info(cfile);
 	cfile->type = CFILE_BLOCK_UNUSED;
 	return result;
 }
@@ -973,7 +975,7 @@ static CFILE *cf_open_fill_cfblock(const char* source, int line, const char* ori
 		if(pos == -1L)
 			pos = 0;
 		cf_init_lowlevel_read_code(cfp,0,filelength(fileno(fp)), 0 );
-
+		cf_check_compression(cfp);
 		return cfp;
 	}
 }
@@ -1008,7 +1010,7 @@ static CFILE *cf_open_packed_cfblock(const char* source, int line, const char* o
 		cfp->line_num = line;
 
 		cf_init_lowlevel_read_code(cfp,offset, size, 0 );
-
+		cf_check_compression(cfp);
 		return cfp;
 	}
 
@@ -1052,6 +1054,7 @@ static CFILE *cf_open_mapped_fill_cfblock(const char* source, int line, const ch
 		cfp->line_num = line;
 
 		cf_init_lowlevel_read_code(cfp, 0, 0, 0 );
+		
 #if defined _WIN32
 		cfp->hMapFile = CreateFileMapping(cfp->hInFile, NULL, PAGE_READONLY, 0, 0, NULL);
 		if (cfp->hMapFile == NULL) {

code/cfile/cfile.h

@@ -81,9 +81,10 @@ typedef struct {
 #define CF_TYPE_FREDDOCS			37
 #define CF_TYPE_INTERFACE_MARKUP 38
 #define CF_TYPE_INTERFACE_CSS 39
+#define CF_TYPE_PLAYER_BINDS 40
 
 #define CF_MAX_PATH_TYPES                                                                                              \
-	40 // Can be as high as you'd like //DTP; yeah but beware alot of things uses CF_MAX_PATH_TYPES
+	41 // Can be as high as you'd like //DTP; yeah but beware alot of things uses CF_MAX_PATH_TYPES
 
 // TRUE if type is specified and valid
 #define CF_TYPE_SPECIFIED(path_type) (((path_type)>CF_TYPE_INVALID) && ((path_type)<CF_MAX_PATH_TYPES))

code/cfile/cfilearchive.cpp

@@ -24,6 +24,7 @@
 
 #include "cfile/cfile.h"
 #include "cfile/cfilearchive.h"
+#include "cfile/cfilecompression.h"
 #include "luaconf.h"
 
 #include <sstream>
@@ -33,7 +34,6 @@
 #define CHECK_POSITION
 
 // 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 )
 {
 	Assert(cfile != nullptr);
@@ -54,6 +54,33 @@ void cf_init_lowlevel_read_code( CFILE * cfile, size_t lib_offset, size_t size,
 	}
 }
 
+//This function checks the file header to see if the file is compressed, if so it fills the correct compression info.
+void cf_check_compression(CFILE* cfile)
+{
+	if (cfile->size <= 16)
+		return;
+	int header=cfread_int(cfile);
+	cfseek(cfile, 0, SEEK_SET);
+	if (comp_check_header(header) == COMP_HEADER_MATCH)
+		comp_create_ci(cfile, header);
+}
+
+//This function is called to cleanup compression info when the cfile handle is reused.
+void cf_clear_compression_info(CFILE* cfile)
+{
+	if (cfile->compression_info.header != 0)
+	{
+		free(cfile->compression_info.offsets);
+		free(cfile->compression_info.decoder_buffer);
+		cfile->compression_info.offsets = nullptr;
+		cfile->compression_info.decoder_buffer = nullptr;
+		cfile->compression_info.header = 0;
+		cfile->compression_info.block_size = 0;
+		cfile->compression_info.last_decoded_block_pos = 0;
+		cfile->compression_info.last_decoded_block_bytes = 0;
+		cfile->compression_info.num_offsets = 0;
+	}
+}
 
 
 // cfeof() Tests for end-of-file on a stream
@@ -61,11 +88,11 @@ void cf_init_lowlevel_read_code( CFILE * cfile, size_t lib_offset, size_t size,
 // returns a nonzero value after the first read operation that attempts to read
 // past the end of the file. It returns 0 if the current position is not end of file.
 // There is no error return.
-
 int cfeof(CFILE *cfile)
 {
 	Assert(cfile != NULL);
-
+	if (cfile->compression_info.header != 0)
+		return comp_feof(cfile);
 	int result = 0;
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
@@ -92,6 +119,8 @@ int cfeof(CFILE *cfile)
 int cftell( CFILE * cfile )
 {
 	Assert(cfile != NULL);
+	if (cfile->compression_info.header != 0)
+		return (int)comp_ftell(cfile);
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
     if (cfile->fp) {
@@ -117,6 +146,9 @@ int cfseek( CFILE *cfile, int offset, int where )
 
 	Assert(cfile != NULL);
 
+	if (cfile->compression_info.header != 0)
+		return comp_fseek(cfile, offset, where);
+
 	// TODO: seek to offset in memory mapped file
 	Assert( !cfile->mem_mapped );
 	
@@ -202,23 +234,31 @@ int cfread(void *buf, int elsize, int nelem, CFILE *cfile)
 		// This is a file from memory
 		bytes_read = size;
 		memcpy(buf, reinterpret_cast<const char*>(cfile->data) + cfile->raw_position, size);
+	} else if (cfile->compression_info.header != 0) {
+		bytes_read = comp_fread(cfile, reinterpret_cast<char*>(buf),size);
+		if (bytes_read != size)
+		{
+			mprintf(("\nFile: %s decompression error. Result was: %d expected: %d\n", cfile->original_filename.c_str(), (int)bytes_read, (int)size));
+			Assertion(bytes_read == size, "File decompression error!");
+		}
 	} else {
-		bytes_read = fread( buf, 1, size, cfile->fp );
+		bytes_read = fread(buf, 1, size, cfile->fp);
 	}
+
 	if ( bytes_read > 0 )	{
 		cfile->raw_position += bytes_read;
 		Assertion(cfile->raw_position <= cfile->size, "Invalid raw_position value detected!");
 	}		
 
 	#if defined(CHECK_POSITION) && !defined(NDEBUG)
-    if (cfile->fp) {
+	//Raw position is not the fp position with compressed files
+    if (cfile->fp && cfile->compression_info.header == 0) {
 		auto tmp_offset = ftell(cfile->fp) - cfile->lib_offset;
-		Assert(tmp_offset==cfile->raw_position);
+		Assert(tmp_offset == cfile->raw_position);
 	}
 	#endif
 
 	return (int)(bytes_read / elsize);
-
 }
 
 int cfread_lua_number(double *buf, CFILE *cfile)
@@ -266,4 +306,3 @@ int cfread_lua_number(double *buf, CFILE *cfile)
 	return items_read;
 
 }
-

code/cfile/cfilearchive.h

@@ -7,7 +7,6 @@
  *
 */ 
 
-
 #ifndef _CFILEARCHIVE_H
 #define _CFILEARCHIVE_H
 
@@ -23,6 +22,17 @@
 #define CFILE_BLOCK_UNUSED		0
 #define CFILE_BLOCK_USED		1
 
+struct COMPRESSION_INFO {
+	int header = 0;
+	size_t compressed_size = 0;
+	int block_size = 0;
+	int num_offsets = 0;
+	int* offsets = nullptr;
+	char* decoder_buffer = nullptr;
+	int last_decoded_block_pos = 0;
+	int last_decoded_block_bytes = 0;
+};
+
 struct CFILE {
 	int type = CFILE_BLOCK_UNUSED;                // CFILE_BLOCK_UNUSED, CFILE_BLOCK_USED
 	int dir_type;        // directory location
@@ -44,12 +54,19 @@ struct CFILE {
 	SCP_string original_filename;
 	const char* source_file;
 	int line_num;
+	COMPRESSION_INFO compression_info;
 };
 
 #define MAX_CFILE_BLOCKS	64
 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 );
+void cf_init_lowlevel_read_code(CFILE* cfile, size_t lib_offset, size_t size, size_t pos);
+
+// This checks if the file is compressed or not, and creates the proper compression info if so.
+void cf_check_compression(CFILE* cfile);
+
+// Used to clear compression info data and free dynamic memory used by compression
+void cf_clear_compression_info(CFILE* cfile);
 
 #endif

code/cfile/cfilecompression.cpp

@@ -0,0 +1,206 @@
+#define _CFILE_INTERNAL 
+
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+
+#ifdef _WIN32
+#include <io.h>
+#include <direct.h>
+#include <windows.h>
+#include <winbase.h>
+#endif
+
+#include "lz4.h"
+#include "cfilecompression.h"
+#include "cfilearchive.h"
+
+/*INTERNAL FUNCTIONS*/
+/*LZ41*/
+void lz41_load_offsets(CFILE* cf);
+size_t lz41_stream_random_access(CFILE* cf, char* bytes_out, size_t offset, size_t length);
+void lz41_create_ci(CFILE* cf, int header);
+/*MISC*/
+int fso_fseek(CFILE* cfile, int offset, int where);
+/*END OF INTERNAL FUNCTIONS*/
+
+int comp_check_header(int header)
+{
+	if (LZ41_FILE_HEADER == header)
+		return COMP_HEADER_MATCH;
+
+	return COMP_HEADER_MISMATCH;
+}
+
+void comp_create_ci(CFILE* cf, int header)
+{
+	//mprintf(("(CI)Compressed File Opened: %s \n", cf->original_filename.c_str()));
+
+	if (LZ41_FILE_HEADER == header)
+		lz41_create_ci(cf, header);
+
+	//mprintf(("(CI)Uncompressed FileSize: %d \n", cf->size));
+	//mprintf(("(CI)Compressed FileSize: %d \n", cf->compression_info.compressed_size));
+	//mprintf(("(CI)Block Size: %d \n", cf->compression_info.block_size));
+}
+
+size_t comp_fread(CFILE* cf, char* buffer, size_t length)
+{
+	/* Check the request to be at least 1 byte */
+	Assertion(length > 0, "Invalid length requested.");
+
+	/* Check that we are not requesting to read beyond end of file */
+	Assertion(cf->raw_position + length <= cf->size, "Invalid length requested.");
+
+	if (LZ41_FILE_HEADER == cf->compression_info.header)
+		return lz41_stream_random_access(cf, buffer, cf->raw_position, length);
+
+	return 0;
+}
+
+size_t comp_ftell(CFILE* cf)
+{
+	return cf->raw_position;
+}
+
+int comp_feof(CFILE* cf)
+{
+	if (cf->raw_position >= cf->size)
+		return 1;
+	else
+		return 0;
+}
+
+int comp_fseek(CFILE* cf, int offset, int where)
+{
+	size_t goal_position;
+	switch (where) {
+	case SEEK_SET: goal_position = offset; break;
+	case SEEK_CUR: goal_position = cf->raw_position + offset; break;
+	case SEEK_END: goal_position = cf->size + offset; break;
+	default: return 1;
+	}
+
+	// Make sure we don't seek beyond the end of the file
+	CAP(goal_position,(size_t)0, cf->size);
+
+	cf->raw_position = goal_position;
+
+	return 0;
+}
+
+//Special fseek for compressed files handled by FSO, only SEEK_SET and SEEK_END is supported.
+int fso_fseek(CFILE* cfile, int offset, int where)
+{
+	size_t goal_position;
+
+	switch (where) {
+	case SEEK_SET: goal_position = offset + cfile->lib_offset; break;
+	case SEEK_END: goal_position = cfile->compression_info.compressed_size + offset + cfile->lib_offset; break;
+	default: return 0;
+	}
+	
+	// Make sure we don't seek beyond the end of the file
+	CAP(goal_position, cfile->lib_offset, cfile->lib_offset + cfile->compression_info.compressed_size);
+	
+	int result = 0;
+	if (cfile->fp)
+	{
+		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);
+	}
+	return result;
+}
+
+void lz41_create_ci(CFILE* cf, int header)
+{
+	cf->compression_info.header = header;
+	cf->compression_info.compressed_size = cf->size;
+	fso_fseek(cf, (int)sizeof(int)*-3, SEEK_END);
+	auto fNumoffsets = fread(&cf->compression_info.num_offsets, sizeof(int), 1, cf->fp);
+	auto fSize = fread(&cf->size, sizeof(int), 1, cf->fp);
+	auto fBsize = fread(&cf->compression_info.block_size, sizeof(int), 1, cf->fp);
+
+	Assertion(cf->compression_info.num_offsets > 0, "Invalid number of offsets, compressed file is possibly in the wrong format or corrupted.");
+	#if !defined(NDEBUG)
+	Assertion(cf->size > 4, "Invalid filesize, compressed file is possibly in the wrong format or corrupted.");
+	Assertion(cf->compression_info.block_size > 16, "Invalid block size, compressed file is possibly in the wrong format or corrupted.");
+	Assertion(fNumoffsets == 1, "Error while reading the number of offsets, compressed file is possibly in the wrong format or corrupted.");
+	Assertion(fSize == 1, "Error while reading original filesize, compressed file is possibly in the wrong format or corrupted.");
+	Assertion(fBsize == 1, "Error while reading block size, compressed file is possibly in the wrong format or corrupted.");
+	#endif
+
+	cf->compression_info.decoder_buffer = (char*)malloc(LZ4_compressBound(cf->compression_info.block_size));
+	cf->compression_info.last_decoded_block_pos = 0;
+	cf->compression_info.last_decoded_block_bytes = 0;
+	lz41_load_offsets(cf);
+}
+
+void lz41_load_offsets(CFILE* cf)
+{
+	cf->compression_info.offsets = (int*)malloc(cf->compression_info.num_offsets * sizeof(int));
+	int block;
+	int* offsets_ptr = cf->compression_info.offsets;
+
+	/* Seek to the first offset position, remember to consider the trailing ints */
+	fso_fseek(cf, ( ( sizeof(int) * cf->compression_info.num_offsets ) * -1 ) - (sizeof(int)*3 ), SEEK_END);
+	for (block = 0; block < cf->compression_info.num_offsets; ++block)
+	{
+		auto bytes_read = fread(offsets_ptr++, sizeof(int), 1, cf->fp);
+		Assertion(bytes_read == 1, "Error reading offset list.");
+	}
+}
+
+size_t lz41_stream_random_access(CFILE* cf, char* bytes_out, size_t offset, size_t length)
+{
+	LZ4_streamDecode_t lz4_stream_decode_body;
+	LZ4_streamDecode_t* lz4_stream_decode = &lz4_stream_decode_body;
+	/* The blocks (current_block to end_block) contain the data we want */
+	size_t current_block = offset / cf->compression_info.block_size;
+	size_t end_block = ((offset + length - 1) / cf->compression_info.block_size) + 1;
+	size_t written_bytes = 0;
+
+	if (cf->compression_info.num_offsets <= (int)end_block)
+		return (size_t)LZ41_OFFSETS_MISMATCH;
+
+	/* Seek to the first block to read, if it matches the cached block, search the next one instead */
+	if (cf->compression_info.last_decoded_block_pos == cf->compression_info.offsets[current_block] && current_block + 1 <= end_block)
+		fso_fseek(cf, cf->compression_info.offsets[current_block+1], SEEK_SET);
+	else
+		fso_fseek(cf, cf->compression_info.offsets[current_block], SEEK_SET);
+	
+	offset = offset % cf->compression_info.block_size;
+	char* cmp_buf = (char*)malloc(LZ4_compressBound(cf->compression_info.block_size));
+
+	/* Start decoding */
+	for (; current_block < end_block; ++current_block)
+	{
+		/* Only read and decode if the requested block is not the cached one */
+		if (cf->compression_info.last_decoded_block_pos != cf->compression_info.offsets[current_block])
+		{
+			cf->compression_info.last_decoded_block_pos = cf->compression_info.offsets[current_block];
+
+			/* The difference in offsets is the size of the block */
+			int cmp_bytes = cf->compression_info.offsets[current_block + 1] - cf->compression_info.offsets[current_block];
+			auto bytes_read = fread(cmp_buf, cmp_bytes, 1, cf->fp);
+			Assertion(bytes_read == 1, "Error reading from compressed file.");
+
+			cf->compression_info.last_decoded_block_bytes = LZ4_decompress_safe_continue(lz4_stream_decode, cmp_buf, cf->compression_info.decoder_buffer, cmp_bytes, cf->compression_info.block_size);
+			if (cf->compression_info.last_decoded_block_bytes <= 0)
+			{
+				free(cmp_buf);
+				return (size_t)LZ41_DECOMPRESSION_ERROR;
+			}
+		}
+
+		/* Write out the part of the data we care about from buffer */
+		size_t block_length = (length < (cf->compression_info.last_decoded_block_bytes - offset) ? length : (cf->compression_info.last_decoded_block_bytes - offset));
+		memcpy(bytes_out + written_bytes, cf->compression_info.decoder_buffer + offset, (size_t)block_length);
+		written_bytes += block_length;
+		offset = 0;
+		length -= block_length;
+	}
+
+	free(cmp_buf);
+	return written_bytes;
+}

code/cfile/cfilecompression.h

@@ -0,0 +1,66 @@
+/*
+ShivanSpS - Compressed files support for FSO. Many thanks to ngld, taylor and everyone elsewho helped me in getting this done.
+
+-The file header is a version, this is used to tell FSO how to decompress that file, always use 4 chars to mantain alignment.
+-The header ID can be used to add diferent revisions to LZ41 decompression system or to add other compression format supports whiout breaking compatibility.
+-The system uses a offset list to record the position of every block in file, this list, along with the number of offsets, original filesize,
+and block size, must be written by the compressor app.
+-A decoder cache is used to store the last decoded block, this ensures each block is read and decoded only once in sequential reads. This cache
+is a little bit bigger than the block size, a higher block size means less overhead added to the file, but it also means a little more ram will
+be used during decompression.
+-All this dynamic memory is assigned at cfopen() and it is cleared on cfclose().
+
+................................char[4]..........(n ints)...(int)..........(int)..........(int)
+-COMPRESSED FILE DATA STUCTURE: HEADER|N BLOCKS|N OFFSETS|NUM_OFFSETS|ORIGINAL_FILESIZE|BLOCK_SIZE
+*/
+
+#ifndef _CFILECOMPRESSION_H
+#define _CFILECOMPRESSION_H
+struct CFILE;
+
+/*LZ41*/
+#define LZ41_FILE_HEADER 0x31345A4C // "14ZL" -> "LZ41", inverted
+#define LZ41_DECOMPRESSION_ERROR -1
+#define LZ41_MAX_BLOCKS_OVERFLOW -2
+#define LZ41_HEADER_MISMATCH -3
+#define LZ41_OFFSETS_MISMATCH -4
+/******/
+
+#define COMP_HEADER_MATCH 1
+#define COMP_HEADER_MISMATCH 0
+
+/*
+	Returns COMP_HEADER_MATCH if header is a valid compressed file header,
+	returns COMP_HEADER_MISMATCH if it dosent.
+*/
+int comp_check_header(int header);
+
+/*
+	This is called to generate the correct compression_info data
+	after the file has been indentified as a compressed file.
+	This must be done before calling any other function.
+*/
+void comp_create_ci(CFILE* cf, int header);
+
+/*
+	Read X bytes from the uncompressed file starting from X offset.
+	Returns the amount of bytes read, and 0 or lower to indicate errors.
+*/
+size_t comp_fread(CFILE* cf, char* buffer, size_t length);
+
+/*
+	Returns the current uncompressed file position.
+*/
+size_t comp_ftell(CFILE* cf);
+
+/*
+	Returns 1 of the uncompressed file has been completely read, otherwise it returns a 0.
+*/
+int comp_feof(CFILE* cf);
+
+/*
+	Used to move the uncompressed file current position.
+*/
+int comp_fseek(CFILE* cf, int offset, int where);
+
+#endif

code/cmdline/cmdline.cpp

@@ -220,6 +220,8 @@ Flag exe_params[] =
 	{ "-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", },
+	{ "-prefer_ipv4",		"Prefer IPv4 DNS lookups",					true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-prefer_ipv4", },
+	{ "-prefer_ipv6",		"Prefer IPv6 DNS lookups",					true,	0,									EASY_DEFAULT,					"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-prefer_ipv6", },
 #ifdef WIN32
 	{ "-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
@@ -246,11 +248,13 @@ Flag exe_params[] =
 	{ "-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_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", },
+	{ "-stdout_log",		"Output log file to stdout",				true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-stdout_log", },
+	{ "-slow_frames_ok",	"Don't adjust timestamps for slow frames",	true,	0,									EASY_DEFAULT,					"Dev Tool",		"http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-slow_frames_ok", },
 };
 // clang-format on
 
@@ -375,21 +379,23 @@ int Cmdline_rearm_timer = 0;
 int Cmdline_targetinfo = 0;
 
 // Gameplay related
-cmdline_parm use_3dwarp("-3dwarp", NULL, AT_NONE);			// Cmdline_3dwarp
-cmdline_parm ship_choice_3d_arg("-ship_choice_3d", NULL, AT_NONE);	// Cmdline_ship_choice_3d
-cmdline_parm weapon_choice_3d_arg("-weapon_choice_3d", NULL, AT_NONE);	// Cmdline_weapon_choice_3d
-cmdline_parm use_warp_flash("-warp_flash", NULL, AT_NONE);	// Cmdline_warp_flash
-cmdline_parm allow_autpilot_interrupt("-no_ap_interrupt", NULL, AT_NONE);
-cmdline_parm stretch_menu("-stretch_menu", NULL, AT_NONE);	// Cmdline_stretch_menu
+cmdline_parm use_3dwarp("-3dwarp", nullptr, AT_NONE);			// Is now Fireball_use_3d_warp
+cmdline_parm ship_choice_3d_arg("-ship_choice_3d", nullptr, AT_NONE);	// Cmdline_ship_choice_3d
+cmdline_parm weapon_choice_3d_arg("-weapon_choice_3d", nullptr, AT_NONE);	// Cmdline_weapon_choice_3d
+cmdline_parm use_warp_flash("-warp_flash", nullptr, AT_NONE);	// Cmdline_warp_flash
+cmdline_parm allow_autpilot_interrupt("-no_ap_interrupt", nullptr, AT_NONE);
+cmdline_parm stretch_menu("-stretch_menu", nullptr, AT_NONE);	// Cmdline_stretch_menu
 cmdline_parm no_screenshake("-no_screenshake", nullptr, AT_NONE); // Cmdline_no_screenshake
+cmdline_parm deadzone("-deadzone", 
+"Sets the joystick deadzone. Integer value from 0 to 100 as a percentage of the joystick's range (100% would make the stick do nothing). Disables deadzone slider in the in-game Options menu.", AT_INT); //Cmdline_deadzone
 
-int Cmdline_3dwarp = 0;
 int Cmdline_ship_choice_3d = 0;
 int Cmdline_weapon_choice_3d = 0;
 int Cmdline_warp_flash = 0;
 int Cmdline_autopilot_interruptable = 1;
 int Cmdline_stretch_menu = 0;
 int Cmdline_no_screenshake = 0;
+int Cmdline_deadzone = -1;
 
 // Audio related
 cmdline_parm voice_recognition_arg("-voicer", NULL, AT_NONE);	// Cmdline_voice_recognition
@@ -436,6 +442,8 @@ cmdline_parm no_geo_sdr_effects("-no_geo_effects", NULL, AT_NONE);
 cmdline_parm set_cpu_affinity("-set_cpu_affinity", NULL, AT_NONE);
 cmdline_parm nograb_arg("-nograb", NULL, AT_NONE);
 cmdline_parm noshadercache_arg("-noshadercache", NULL, AT_NONE);
+cmdline_parm prefer_ipv4_arg("-prefer_ipv4", nullptr, AT_NONE);
+cmdline_parm prefer_ipv6_arg("-prefer_ipv6", nullptr, AT_NONE);
 #ifdef WIN32
 cmdline_parm fix_registry("-fix_registry", NULL, AT_NONE);
 #endif
@@ -454,6 +462,8 @@ bool Cmdline_no_geo_sdr_effects = false;
 bool Cmdline_set_cpu_affinity = false;
 bool Cmdline_nograb = false;
 bool Cmdline_noshadercache = false;
+bool Cmdline_prefer_ipv4 = false;
+bool Cmdline_prefer_ipv6 = false;
 #ifdef WIN32
 bool Cmdline_alternate_registry_path = false;
 #endif
@@ -479,6 +489,7 @@ cmdline_parm reparse_mainhall_arg("-reparse_mainhall", NULL, AT_NONE); //Cmdline
 cmdline_parm frame_profile_write_file("-profile_write_file", NULL, AT_NONE); // Cmdline_profile_write_file
 cmdline_parm no_unfocused_pause_arg("-no_unfocused_pause", NULL, AT_NONE); //Cmdline_no_unfocus_pause
 cmdline_parm benchmark_mode_arg("-benchmark_mode", NULL, AT_NONE); //Cmdline_benchmark_mode
+cmdline_parm pilot_arg("-pilot", nullptr, AT_STRING); //Cmdline_pilot
 cmdline_parm noninteractive_arg("-noninteractive", NULL, AT_NONE); //Cmdline_noninteractive
 cmdline_parm json_profiling("-json_profiling", NULL, AT_NONE); //Cmdline_json_profiling
 cmdline_parm show_video_info("-show_video_info", NULL, AT_NONE); //Cmdline_show_video_info
@@ -486,6 +497,7 @@ cmdline_parm frame_profile_arg("-profile_frame_time", NULL, AT_NONE); //Cmdline_
 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
+cmdline_parm slow_frames_ok_arg("-slow_frames_ok", nullptr, AT_NONE);	// Cmdline_slow_frames_ok
 
 
 char *Cmdline_start_mission = NULL;
@@ -510,6 +522,7 @@ int Cmdline_reparse_mainhall = 0;
 bool Cmdline_profile_write_file = false;
 bool Cmdline_no_unfocus_pause = false;
 bool Cmdline_benchmark_mode = false;
+const char *Cmdline_pilot = nullptr;
 bool Cmdline_noninteractive = false;
 bool Cmdline_json_profiling = false;
 bool Cmdline_frame_profile = false;
@@ -517,6 +530,7 @@ bool Cmdline_show_video_info = false;
 bool Cmdline_debug_window = false;
 bool Cmdline_graphics_debug_output = false;
 bool Cmdline_log_to_stdout = false;
+bool Cmdline_slow_frames_ok = false;
 
 // Other
 cmdline_parm get_flags_arg(GET_FLAGS_STRING, "Output the launcher flags file", AT_STRING);
@@ -1317,6 +1331,7 @@ static json_t* json_get_v1() {
 		json_array_append_new(caps_array, json_string("No D3D"));
 		json_array_append_new(caps_array, json_string("New Sound"));
 		json_array_append_new(caps_array, json_string("SDL"));
+		json_array_append_new(caps_array, json_string("Multijoy"));
 
 		json_object_set_new(root, "caps", caps_array);
 	}
@@ -1408,24 +1423,7 @@ static json_t* json_get_v1() {
 		json_object_set_new(root, "openal", openal_obj);
 	}
 	{
-		auto joystick_array = json_array();
-
-		auto joysticks = io::joystick::getJoystickInformations();
-		for (auto& info : joysticks) {
-			auto joystick_obj = json_object();
-
-			json_object_set_new(joystick_obj, "name", json_string(info.name.c_str()));
-			json_object_set_new(joystick_obj, "guid", json_string(info.guid.c_str()));
-
-			json_object_set_new(joystick_obj, "num_axes", json_integer(info.num_axes));
-			json_object_set_new(joystick_obj, "num_balls", json_integer(info.num_balls));
-			json_object_set_new(joystick_obj, "num_buttons", json_integer(info.num_buttons));
-			json_object_set_new(joystick_obj, "num_hats", json_integer(info.num_hats));
-
-			json_object_set_new(joystick_obj, "is_haptic", json_boolean(info.is_haptic));
-
-			json_array_append_new(joystick_array, joystick_obj);
-		}
+		auto joystick_array = io::joystick::getJsonArray();
 
 		json_object_set_new(root, "joysticks", joystick_array);
 	}
@@ -1617,7 +1615,7 @@ bool SetCmdlineParams()
 		Cmdline_game_name = gamename_arg.str();
 
 		// be sure that this string fits in our limits
-		if ( strlen(Cmdline_game_name) > MAX_GAMENAME_LEN ) {
+		if ( strlen(Cmdline_game_name) >= MAX_GAMENAME_LEN ) {
 			Cmdline_game_name[MAX_GAMENAME_LEN-1] = '\0';
 		}
 	}
@@ -1627,8 +1625,9 @@ bool SetCmdlineParams()
 		Cmdline_game_password = gamepassword_arg.str();
 
 		// be sure that this string fits in our limits
-		if ( strlen(Cmdline_game_name) > MAX_PASSWD_LEN ) {
-			Cmdline_game_name[MAX_PASSWD_LEN-1] = '\0';
+		if ( strlen(Cmdline_game_password) >= MAX_PASSWD_LEN ) {
+			ReleaseWarning(LOCATION, "Multi game password is longer than max of %d charaters and will be trimmed to fit!", MAX_PASSWD_LEN-1);
+			Cmdline_game_password[MAX_PASSWD_LEN-1] = '\0';
 		}
 	}
 
@@ -1713,7 +1712,7 @@ bool SetCmdlineParams()
 			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));
+			mprintf(("Failed to parse -res parameter \"%s\". Must be in format \"<width>x<height>\".\n", Cmdline_res));
 		}
 	}
 	if(center_res_arg.found()){
@@ -1839,6 +1838,10 @@ bool SetCmdlineParams()
 		Cmdline_no_screenshake = 1;
 	}
 	
+	if ( deadzone.found() ) {
+		Cmdline_deadzone = deadzone.get_int();
+	}
+
 	if ( stretch_menu.found() )	{
 		Cmdline_stretch_menu = 1;
 	}
@@ -2123,6 +2126,11 @@ bool SetCmdlineParams()
 		Cmdline_benchmark_mode = true;
 	}
 
+	if (pilot_arg.found())
+	{
+		Cmdline_pilot = pilot_arg.str();
+	}
+
 	if (noninteractive_arg.found())
 	{
 		Cmdline_noninteractive = true;
@@ -2150,6 +2158,10 @@ bool SetCmdlineParams()
 		Cmdline_log_to_stdout = true;
 	}
 
+	if (slow_frames_ok_arg.found()) {
+		Cmdline_slow_frames_ok = true;
+	}
+
 	if (show_video_info.found())
 	{
 		Cmdline_show_video_info = true;
@@ -2251,6 +2263,22 @@ bool SetCmdlineParams()
 			}
 		}
 	}
+
+	if (prefer_ipv4_arg.found()) {
+		Cmdline_prefer_ipv4 = true;
+	}
+
+	if (prefer_ipv6_arg.found()) {
+		Cmdline_prefer_ipv6 = true;
+
+		// Rule 2: Not both
+		if (Cmdline_prefer_ipv4) {
+			ReleaseWarning(LOCATION, "Cannot set preference for both IPv4 and IPv6! Reverting to default behavior...\n");
+
+			Cmdline_prefer_ipv4 = false;
+			Cmdline_prefer_ipv6 = false;
+		}
+	}
  
 	return true; 
 }

code/cmdline/cmdline.h

@@ -83,13 +83,13 @@ extern int Cmdline_rearm_timer;
 extern int Cmdline_targetinfo;
 
 // Gameplay related
-extern int Cmdline_3dwarp;
 extern int Cmdline_ship_choice_3d;
 extern int Cmdline_weapon_choice_3d;
 extern int Cmdline_warp_flash;
 extern int Cmdline_autopilot_interruptable;
 extern int Cmdline_stretch_menu;
 extern int Cmdline_no_screenshake;
+extern int Cmdline_deadzone;
 
 // Audio related
 extern int Cmdline_voice_recognition;
@@ -123,6 +123,8 @@ extern bool Cmdline_no_geo_sdr_effects;
 extern bool Cmdline_set_cpu_affinity;
 extern bool Cmdline_nograb;
 extern bool Cmdline_noshadercache;
+extern bool Cmdline_prefer_ipv4;
+extern bool Cmdline_prefer_ipv6;
 #ifdef WIN32
 extern bool Cmdline_alternate_registry_path;
 #endif
@@ -143,6 +145,7 @@ extern int Cmdline_reparse_mainhall;
 extern bool Cmdline_profile_write_file;
 extern bool Cmdline_no_unfocus_pause;
 extern bool Cmdline_benchmark_mode;
+extern const char *Cmdline_pilot;
 extern bool Cmdline_noninteractive;
 extern bool Cmdline_json_profiling;
 extern bool Cmdline_frame_profile;
@@ -150,6 +153,7 @@ 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_slow_frames_ok;
 
 enum class WeaponSpewType { NONE = 0, STANDARD, ALL };
 extern WeaponSpewType Cmdline_spew_weapon_stats;

code/controlconfig/controlsconfig.h

@@ -15,68 +15,62 @@
 
 #define CONTROL_CONFIG_XSTR	507
 
+#define CCF_AXIS_BTN    0x40    //!< axis is a button on positive side. If also inverted, is on negative side instead
+#define CCF_RELATIVE    0x20    //!< axis is relative
+#define CCF_INVERTED    0x10    //!< axis is inverted
+#define CCF_AXIS        0x08    //!< btn is an axis
+#define CCF_HAT         0x04    //!< btn is a hat
+#define CCF_BALL        0x02    //!< btn is a ball
+
 /*!
- * These are used to index a corresponding joystick axis value from an array.
+ * These are used to index a corresponding axis value from an array.
  * Currently only used by ::Axis_map_to[] and ::Axis_map_to_defaults[]
  */
-enum Joy_axis_index {
+enum Joy_axis_index : short {
 	JOY_X_AXIS		=0,
 	JOY_Y_AXIS,
 	JOY_Z_AXIS,
 	JOY_RX_AXIS,
 	JOY_RY_AXIS,
-	JOY_RZ_AXIS
+	JOY_RZ_AXIS,
+
+	JOY_NUM_AXES	// Number of axes a joystick may have. Must be last enum in Joy_axis_index.
 };
 
+// Aliases for mouse axes.  Really should unify this...
+const short MOUSE_X_AXIS = JOY_X_AXIS;
+const short MOUSE_Y_AXIS = JOY_Y_AXIS;
+const short MOUSE_Z_AXIS = JOY_Z_AXIS;
+const short MOUSE_NUM_AXES = 3;
+const short MOUSE_NUM_BUTTONS = 9;	// Keep this up to date with mouse.h until z64555 stops being lazy and does it right
+
 /*!
  * Controller index enumeration
  * @details For use with hardcoded bindings and scripting API to allow human-readable translation
  * @note These enums are hardcoded so that an int value of 0 would be JOY0
  */
-enum CID : short {
-	CID_NONE     = -3,	// No device bound
-	CID_KEYBOARD = -2,	// button belongs to keyboard
-	CID_MOUSE    = -1,  // to mouse
-	CID_JOY0     =  0,  // to Joy0
-	CID_JOY1     =  1,  // to Joy1 (Throttle?)
-	CID_JOY2     =  2,  // to Joy2 (Pedals?)
-	CID_JOY3     =  3   // to Joy3 (Head tracker?)
-	                    // Any additional joystick is an int >3
-};
-
-/*!
- * These are used to index a corresponding (analog) action, namely controlling the orientation angles and throttle.
- */
-enum Joy_axis_action_index {
-	JOY_HEADING_AXIS	=0,	//
-	JOY_PITCH_AXIS,
-	JOY_BANK_AXIS,
-	JOY_ABS_THROTTLE_AXIS,
-	JOY_REL_THROTTLE_AXIS,
-
-	/*!
-	 * This must always be below the last defined item
-	 */
-	NUM_JOY_AXIS_ACTIONS			//!< The total number of actions an axis may map to
-};
-
-/*!
- * Joystick action modes
- * note: should this be in joy.h?
- */
-enum Joy_axis_action_mode {
-	JAAM_ABS,       //!< Absolute mode.  Axis position = output value
-	JAAM_REL,       //!< Relative mode.  Axis postion away from its center adds or subtracts an output value register.
-	JAAM_BTN_NEG,   //!< Button mode, negative side.  Axis position in the negative side will trigger a button action
-	JAAM_BTN_POS,   //!< Button mode, positive side.  Axis position in the positive side will trigger a button action
+enum CID : int8_t {
+	CID_NONE     = -3,	//!< No device bound
+	CID_KEYBOARD = -2,	//!< belongs to keyboard
+	CID_MOUSE    = -1,  //!< to mouse
+	CID_JOY0     =  0,  //!< to Joy0
+	CID_JOY1     =  1,  //!< to Joy1 (Throttle?)
+	CID_JOY2     =  2,  //!< to Joy2 (Pedals?)
+	CID_JOY3     =  3,  //!< to Joy3 (Head tracker?)
+	
+	CID_JOY_MAX         //!< Maximum supported joysticks, must be last in the enum definition
 };
 
 /*!
  * Control Configuration Types. Namely differ in how the control is activated
  */
 enum CC_type {
-	CC_TYPE_TRIGGER			=0,		//!< A normal, one-shot type control that is activated when a key is or button is pressed
-	CC_TYPE_CONTINUOUS				//!< A continous control that is activated as long as the key or button is held down
+	CC_TYPE_TRIGGER = 0,    //!< A normal, one-shot type control that is activated when a key is or button is pressed
+	CC_TYPE_CONTINUOUS,     //!< A continous control that is activated as long as the key or button is held down
+	CC_TYPE_AXIS_ABS,       //!< Absolute Axis mode.  Axis position = output value
+	CC_TYPE_AXIS_REL,       //!< Relative Axis mode.  Axis postion away from its center adds or subtracts an output value register
+	CC_TYPE_AXIS_BTN_NEG,   //!< Axis Button mode, negative side.  Axis position in the negative side will trigger a button action
+	CC_TYPE_AXIS_BTN_POS    //!< Axis Button mode, positive side.  Axis position in the positive side will trigger a button action
 };
 
 /*!
@@ -86,7 +80,7 @@ enum CC_type {
  *
  * Note: Do not adjust the order or numeric value
  */
-enum IoActionId  {
+enum IoActionId : int {
 	TARGET_NEXT										=0,		//!< target next
 	TARGET_PREV										=1,		//!< target previous
 	TARGET_NEXT_CLOSEST_HOSTILE						=2,		//!< target the next hostile target
@@ -288,52 +282,77 @@ enum IoActionId  {
 	CUSTOM_CONTROL_4								= 122,
 	CUSTOM_CONTROL_5								= 123,
 
+	//!< @n
+	//!< Analog controls
+	//!<-----------------------------
+	//!< All axis actions must be kept together
+	JOY_HEADING_AXIS								= 124,
+	JOY_PITCH_AXIS									= 125,
+	JOY_BANK_AXIS									= 126,
+	JOY_ABS_THROTTLE_AXIS							= 127,
+	JOY_REL_THROTTLE_AXIS							= 128,
+
 	/*!
 	 * This must always be below the last defined item
 	 */
 	CCFG_MAX                                  //!<  The total number of defined control actions (or last define + 1)
 };
 
+// Constants for array-based checking (within Control_config) for the axis actions.
+// z64: Yes, this is hackish. No I don't really like it.
+const int JOY_AXIS_BEGIN = JOY_HEADING_AXIS;
+const int JOY_AXIS_END = JOY_REL_THROTTLE_AXIS + 1;
+const int NUM_JOY_AXIS_ACTIONS = JOY_AXIS_END - JOY_AXIS_BEGIN;
+
+/*!
+ * @brief Enum for indexing into axis action arrays.
+ * @note Keep this up to date with JOY_HEADING_AXIS and friends.  Pay attention to their order and copy to here
+ */
+namespace Action {
+enum {
+	HEADING = 0,
+	PITCH,
+	BANK,
+	ABS_THROTTLE,
+	REL_THROTTLE,
+
+	NUM_VALUES
+};
+}
+
 class CCB;
 
 /*!
  *  A singular button binding
  */
 class CC_bind {
-public:
-	CID cid   = CID_NONE;   //!< Which controller this belongs to
-	short btn = -1;         //!< Which button to index; If cid == CID_KEYBOARD, this is a key hash.
-
 public:
 	CC_bind() = default;
+	CC_bind(CID _cid, short _btn) : cid(_cid), btn(_btn) { validate(); };
+	CC_bind(CID _cid, short _btn, char _flags) : cid(_cid), flags(_flags), btn(_btn) { validate(); };
 	CC_bind(const CC_bind &A) = default;
 
-	CC_bind(CID _cid, short _btn) : cid(_cid), btn(_btn) {};
-
-	CC_bind& operator=(const CC_bind &A);
+	CC_bind& operator=(const CC_bind &A) = default;
 
 	/*!
 	 * Checks if this CC_bind is equal to the given CC_bind
+	 *
+	 * @note EQUAL means EQUAL, this will return FALSE if the flags differ by a single bit
 	 */
 	bool operator==(const CC_bind &B) const;
 
-	/*!
-	 * Checks if this CC_bind is equal to either in the pair
-	 */
-	bool operator==(const CCB &pair) const;
-
 	/*!
 	 * Checks if this CC_bind is not equal to the given CC_bind
 	 */
 	bool operator!=(const CC_bind &B) const;
 
 	/*!
-	 * Checks if this CC_bind is not equal to either in the pair
+	 * Checks if this CC_bind is equal to the given CC_bind, disregarding the inversion flag
 	 */
-	bool operator!=(const CCB &pair) const;
+	bool invert_agnostic_equals(const CC_bind &B) const;
 
 	/*!
-	 * Clears the binding
+	 * Clears the binding and flags.  Some flags are retained.
 	 */
 	void clear();
 
@@ -342,10 +361,62 @@ public:
 	 */
 	bool empty() const;
 
+	/*!
+	 * Returns a copy of ::btn
+	 */
+	short get_btn() const;
+
+	/*!
+	 * Returns a copy of ::cid
+	 */
+	CID get_cid() const;
+
+	/*!
+	 * Returns a copy of ::flags
+	 */
+	char get_flags() const;
+
+	/**
+	 * Takes the given binding.
+	 */
+	void take(CID _cid, short _btn, char _flags = 0);
+
+	/**
+	 * Validates the binding, clearing it if necassary
+	 */
+	void validate();
+
 	/*!
 	 * Returns a human-readable string of this binding
 	 */
 	SCP_string textify() const;
+
+	/*!
+	 * Sets the inversion state of this binding according to the passed bool. True = inverted, false = normal
+	 */
+	void invert(bool);
+
+	/*!
+	 * Toggles the inversion state
+	 */
+	void invert_toggle();
+
+	/*!
+	 * Is true if inverted, false otherwise
+	 */
+	bool is_inverted() const;
+
+	/*!
+	 * Checks if this CC_bind conflicts with the given argument
+	 *
+	 * @note Similar to operator==, but ignores certain combinations of flags.
+	 */
+	bool conflicts_with(const CC_bind&) const;
+
+private:
+	CID cid = CID_NONE; //!< Which controller this belongs to
+	char flags = 0;     //!< mask to determine various additional attributes of btn
+	short btn = -1;     //!< The button, key combo, or axis that's bound.
 };
 
 /*!
@@ -392,17 +463,42 @@ public:
 	/*!
 	 * Assigns the contents of the given CCB to this CCB
 	 */
-	CCB& operator=(const CCB&);
+	CCB& operator=(const CCB&) = default;
 
 	/*!
-	 * Returns True if this CCB's first isn't empty and the given CCB has a binding equal to it
+	 * Checks if the given CCB is exactly equal to this
 	 */
-	bool has_first(const CCB&) const;
+	bool operator==(const CCB&);
 
 	/*!
-	 * Returns True if this CCB's second isn't empty and the given CCB has a binding equal to it
+	 * Checks if the given CCB differs from this
 	 */
-	bool has_second(const CCB&) const;
+	bool operator!=(const CCB&);
+
+	/*!
+	 * Returns True if this CCB's first isn't empty and the given CCB has a binding that can conflict with it
+	 */
+	bool has_first_conflict(const CCB&) const;
+
+	/*!
+	 * Returns True if this CCB's second isn't empty and the given CCB has a binding that can conflict with it
+	 */
+	bool has_second_conflict(const CCB&) const;
+
+	/*!
+	 * Returns a pointer to first, or second, whichever has a binding equal to the given CC_bind, or nullptr if neither
+	 */
+	CC_bind* find(const CC_bind&);
+
+	/*!
+	 * Returns a pointer to first, or second, whichever has a CID equal to the given CID, or nullptr if neither
+	 */
+	CC_bind* find(CID);
+
+	/*!
+	 * Returns a pointer to first, or second, whichever has *all* flags in the given mask
+	 */
+	CC_bind* find_flags(const char);
 };
 
 /*!
@@ -412,6 +508,12 @@ class CC_preset {
 public:
 	SCP_vector<CCB> bindings;
 	SCP_string name;
+
+public:
+	/*!
+	 * Checks if the given preset is a duplicate of this one
+	 */
+	bool is_duplicate_of(CC_preset&);
 };
 
 /*!
@@ -449,6 +551,11 @@ public:
 	 * @brief Takes the bindings of the given CCB, but leaves all other members alone
 	 */
 	CCI& operator=(const CCB&);
+
+	/*!
+	 * Returns true if this item is analogue or an axis
+	 */
+	bool is_axis();
 };
 
 /*!
@@ -473,9 +580,23 @@ public:
 
 	/*!
 	 * Assigns the hardcoded binding to the given action
+	 *
 	 * @note This differs from the original hardcode from :V: in the hopes of it being more intuitive to future IoAction additions
+	 *
+	 * param[in] action_id  The IoActionId enum associated with the control
+	 * param[in] primary    The btn, key combo, or axis for the default primary binding
+	 * param[in] secondary  The btn, key combo, or axis for the default secondary binding
+	 * param[in] tab        Category tab this control should show up under on the config menu
+	 * param[in] indexXSTR  ID for the XSTR localization utility. 0 for no localization, 1 for automatic lookup, all other values are index for item in strings.tbl
+	 * param[in] text       Label text displayed in the config menu.
+	 * param[in] type       How the control should be treated. see doxy on CC_type for details
+	 * param[in] disabled   If true, this control will not be available in the game.  Controlsconfigdefaults.tbl may override this.  Don't use this to temporarily disable controls in mission.
+	 * 
+	 * @details The CID for the default primary and secondary is determined by the type parameter.
+	 *   If the type is CC_TYPE_TRIGGER or CC_TYPE_CONTINOUS, the primary is assumed to be a key combo and secondary is assumed to be a joy button.
+	 *   If the type is CC_TYPE_AXIS_ABS, CC_TYPE_AXIS_REL, CC_TYPE_AXIS_BTN_POS, or CC_TYPE_AXIS_BTN_NEG, the primary is a Joy0 axis and the secondary is a Mouse axis
 	 */
-	CCI_builder& operator()(IoActionId action_id, short key_default, short joy_default, char tab, int indexXSTR, const char *text, CC_type type, bool disabled = false);
+	CCI_builder& operator()(IoActionId action_id, short primary, short secondary, char tab, int indexXSTR, const char *text, CC_type type, bool disabled = false);
 
 private:
 	CCI_builder();	// Only one builder per Control Config, so a default constructor is useless
@@ -485,11 +606,6 @@ private:
 
 extern int Failed_key_index;
 
-extern int Axis_map_to[];           // Array to map an axis action to a joy axis. size() = NUM_JOY_AXIS_ACTIONS
-extern int Axis_map_to_defaults[];
-extern int Invert_axis[];           // Array to hold inversion bools for a joy axis. size() = JOY_NUM_AXES
-extern int Invert_axis_defaults[];
-
 extern int Joy_dead_zone_size;
 extern int Joy_sensitivity;
 
@@ -498,7 +614,14 @@ extern int Control_config_overlay_id;
 extern SCP_vector<CCI> Control_config;		//!< Stores the keyboard configuration
 extern SCP_vector<CC_preset> Control_config_presets; // tabled control presets; pointers to config_item arrays
 extern const char **Scan_code_text;
-extern const char **Joy_button_text;
+extern const char **Joy_button_text;			// String table of button labels.  XSTR'd on init.
+
+// string table constants for labels and stuff.
+#define NUM_AXIS_TEXT			JOY_NUM_AXES
+#define NUM_MOUSE_TEXT			MOUSE_NUM_BUTTONS
+
+extern char *Axis_text[NUM_AXIS_TEXT];			// String table of axis labels (joystick and mice).  XSTR'd on init.
+extern char *Mouse_button_text[NUM_MOUSE_TEXT];	// String table of mouse button labels.  XSTR'd on init.
 
 /*!
  * @brief Checks if either binding in the CCB has the given cid
@@ -509,6 +632,11 @@ extern const char **Joy_button_text;
  */
 int is_cid_either(CID, const CCB);
 
+/*!
+ * Allows CID to be assigned by a short.  Has Assert to check values
+ */
+void cid_assign(CID&, const short);
+
 /*!
 * @brief initialize common control config stuff - call at game startup after localization has been initialized
 */
@@ -540,51 +668,76 @@ void control_config_close();
 void control_config_cancel_exit();
 
 /*!
- * @brief Resets all controls to values within the currently selected preset
+ * @brief Copies all bindings within preset into Control_config
  */
-void control_config_reset_defaults();
+void control_config_use_preset(CC_preset &preset);
 
 /*!
- * Returns the IoActionId of a control bound to the given key
+ * @brief Search for a given preset by name and use it, if it exists.
+ *
+ * @returns TRUE    if the preset was found and selected
+ * @returns FALSE   if the preset was not found, and the defaults were selected
+ *
+ * @details If the preset does not exist, then defaults are used instead.
+ * @see control_config_use_preset()
+ */
+bool control_config_use_preset_by_name(const SCP_string &name);
+
+/**
+ * @brief Gets the currently used preset
+ *
+ * @param[in] invert_agnostic  If true, check the bindings in Control_config against the preset, ignoring inversion flags
+ * 
+ * @returns an iterator to the current preset, or
+ * @returns ::iterator Control_config_presets.end() if current bindings are not in a preset
+ */
+SCP_vector<CC_preset>::iterator control_config_get_current_preset(bool invert_agnostic = false);
+
+/*!
+ * Returns the IoActionId (index within Control_config[]) of a control bound to the given key
+ *
+ * @param[in]   key           The key combo to look for
+ * @param[in]   find_override If true, return the IoActionId of a control that has this key as its default
+ *
+ * @return  -1 if the given key is NULL or not bound.
  *
- * @param[in] key           The key combo to look for
- * @param[in] find_override If true, return the IoActionId of a control that has this key as its default
  * @details If find_override is set to true, then this returns the index of the action
  */
 int translate_key_to_index(const char *key, bool find_override=true);
 
 
 /*!
- * @brief Given the system default key 'key', return the current key that is bound to that function.
+ * @brief Given the system default key 'key', return the current control input(s) that is bound to that function.
  *
- * @param[in] key  The default key combo (as string) to a certain control
+ * @param[in]   key     The default key combo (as cstring) to a certain control
  *
- * @returns The key combo (as string) currently bound to the control
+ * @return  The key combo (as cstring) currently bound to the control, or
+ * @return  nullptr if the given key is not a system default key, or
+ * @return  "None" if there is nothing bound to the control
  *
  * @details Both the 'key' and the return value are descriptive strings that can be displayed
  * directly to the user.  If 'key' isn't a real key, is not normally bound to anything,
- * or there is no key currently bound to the function, NULL is returned.
+ * or there is no key currently bound to the function, nullptr is returned.
+ *
+ * @note Not thread safe.  Has an internal buffer for the return value which is overwritten on each call.
+ *
+ * @note Uses CC_bind::textify for translations
  */
-char *translate_key(char *key);
+const char *translate_key(char *key);
 
 /**
- * @brief Converts the specified key code to a human readable string
+ * @brief Converts the specified key code to a human readable string, according to the selected locale
  *
- * @note The returned value is localized to the current language
+ * @param[in]   code    The key code to convert
+ * @param[in]   use_default_locale  If true, return the default locale (English) translation of the key
  *
- * @param code The key code to convert
- * @return The text representation of the code. The returned value is stored in a temporary location, copy it to your
- * own buffer if you want to continue using it.
+ * @return  The text representation of the code.
+ *
+ * @note Not thread safe.  Has an internal buffer for the return value which is overwritten on each call.
+ *
+ * @note The return value is translated according to localization settings
  */
-const char *textify_scancode(int code);
-
-/**
- * @note Same as textify_scancode but always returns the same value regardless of current language
- * @param code The key code to convert
- * @return The name of the key
- * @see textify_scancode
- */
-const char *textify_scancode_universal(int code);
+const char *textify_scancode(int code, bool use_default_locale = false);
 
 /*!
  * @brief Checks how long a control has been active
@@ -600,26 +753,29 @@ float check_control_timef(int id);
 /**
  * @brief Wrapper for check_control_used. Allows the game to ignore the key if told to do so by the ignore-key SEXP.
  *
- * @brief id    The IoActionId of the control to check
- * @brief key   The key combo to check against the control.
+ * @param[in] id    The IoActionId of the control to check
+ * @param[in] key   The key combo to check against the control. If -1, re-check the last key passed to this function
  *
  * @returns 0 If the control wasn't used, or
  * @returns 1 If the control was used
+ *
+ * @details If the given control is CC_CONTINOUS, param key is effectively ignored and instead keyd_press[] is checked.
+ * This function also checks against joy and mouse presses.
  */
 int check_control(int id, int key = -1);
 
 /**
  * @brief Gets the scaled reading for all control axes.
  *
- * @param[out] h  heading
- * @param[out] p pitch
- * @param[out] b bank
- * @param[out] ta Throttle - Absolute
- * @param[out] tr Throttle - Relative
+ * @param[in]   frametime   Frametime used to scale the mouse axes
+ * @param[out]  axis_v      Output array of all control axes, must have size of JOY_NUM_AXIS_ACTIONS
  *
- * @note None of the input pointers may be nullptr
+ * @details
+ * * Clamps output to stay within +/-JOY_AXIS_RANGE.
+ * * Should multiple axes be bound to a control, their values are blended with a simple sum.  This is to save a bit of
+ *   processing for speed.
  */
-void control_get_axes_readings(int *h, int *p, int *b, int *ta, int *tr);
+void control_get_axes_readings(int *axis_v, float frame_time);
 
 /**
  * @brief Markes the given control (by IoActionId) as used
@@ -652,4 +808,118 @@ void control_config_clear_used_status();
  */
 int joy_get_scaled_reading(int raw);
 
+/**
+ * Lookups the given stringified enum to find its value
+ * @return -1 if not found, or
+ * @return IoActionId if found
+ */
+int ActionToVal(const char * str);
+
+/**
+ * Reverse lookups the IoActionId to get its stringified name
+ * @return  Pointer to the stringified name of the action, or
+ * @return  nullptr if not found
+ */
+const char * ValToAction(IoActionId id);
+
+/**
+ * Reverse lookups the IoActionId to get its stringified name
+ * @return Pointer to the stringified name of the action, or
+ * @return nullptr if not found, or invalid id
+ */
+const char * ValToAction(int id);
+
+/**
+ * Lookups the given stringified enum to find its value
+ */
+CID CIDToVal(const char * str);
+
+/**
+ * Reverse lookups the CID to get its stringified name
+ * @return  Pointer to the stringified name of the CID, or
+ * @return  nullptr if not found
+ */
+const char * ValToCID(CID id);
+
+/**
+ * Reverse lookups the CID to get its stringified name
+ * @return Pointer to the stringified name of the CID, or
+ * @return nullptr if not found, or invalid id
+ */
+const char * ValToCID(int id);
+
+/**
+ * Lookups the given stringified enum to find its value
+ */
+char CCFToVal(const char * str);
+
+/**
+ * Constructs a enum string from the CCF_FLAGS
+ * @return Pointer to the stringified name of the CCF, or
+ * @return nullptr if not found, or invalid id
+ */
+SCP_string ValToCCF(char id);
+
+/**
+ * Lookups the given stringified enum to find its value
+ */
+short InputToVal(CID cid, const char * str);
+
+/**
+ * Constructs a enumstring from the input binding, depending on the CID
+ *
+ * @return Pointer to the stringified name of the input, or
+ * @return nullptr if not found, or invalid CC_bind
+ *
+ * @note This requires a CCB due to the way things are encoded
+ */
+SCP_string ValToInput(const CC_bind &bind);
+
+/**
+ * Lookups the given stringified enum to find its btn value
+ */
+short MouseToVal(const char * str);
+
+/**
+ * Constructs a enum string from the mouse input
+ *
+ * @return Pointer to the stringified name of the input, or
+ * @return nullptr if not found, or invalid CC_bind
+ * TODO XSTR
+ *
+ * @note This requires a CCB due to the way things are encoded
+ */
+SCP_string ValToMouse(const CC_bind &bind);
+
+/**
+ * Lookups the given stringified enum to find its btn value
+ */
+short KeyboardToVal(const char * str);
+
+/**
+ * Constructs an enum string from the key binding
+ *
+ * @return Pointer to the stringified name of the input, or
+ * @return nullptr if not found, or invalid CC_bind
+ *
+ * @note This requires a CCB due to the way things are encoded
+ * TODO XSTR
+ */
+SCP_string ValToKeyboard(const CC_bind &bind);
+
+/**
+ * Lookups the given stringified enum to find its value
+ */
+short JoyToVal(const char * str);
+
+/**
+ * Constructs a enum string from the Joystick input
+ *
+ * @return Pointer to the stringified name of the input, or
+ * @return nullptr if not found, or invalid CC_bind
+ *
+ * @note This requires a CCB due to the way things are encoded
+ * TODO XSTR
+ */
+SCP_string ValToJoy(const CC_bind &bind);
 #endif

code/controlconfig/presets.cpp

@@ -0,0 +1,481 @@
+#include "controlconfig/controlsconfig.h"
+#include "controlconfig/presets.h"
+#include "libs/jansson.h"
+#include "parse/parselo.h"
+
+#include <jansson.h>
+
+using namespace io::presets;
+
+const SCP_vector<std::pair<Section, const char*>> SectionMapping {
+	std::pair<Section, const char*>(Section::Unnamed, nullptr),
+	std::pair<Section, const char*>(Section::Actions, "actions"),
+	std::pair<Section, const char*>(Section::Primary, "primary"),
+	std::pair<Section, const char*>(Section::Secondary, "secondary"),
+};
+
+const char * lookupSectionName(Section id) {
+	for (const auto& pair: SectionMapping) {
+		if (pair.first == id) {
+			return pair.second;
+		}
+	}
+
+	return nullptr;
+}
+
+Section lookupSectionValue(const char* name) {
+	Assertion(name != nullptr, "Key name must be a valid pointer!");
+
+	for (auto& pair : SectionMapping) {
+		if (!strcmp(pair.second, name)) {
+			return pair.first;
+		}
+	}
+	return Section::Invalid;
+}
+
+void load_preset_files() {
+	SCP_vector<SCP_string> filelist;
+	cf_get_file_list(filelist, CF_TYPE_PLAYER_BINDS, NOX("*.json"), CF_SORT_NAME, nullptr,
+	                 CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
+
+	std::unique_ptr<PresetFileHandler> handler = nullptr;
+
+	for (const auto &file : filelist) {
+		CFILE* fp = cfopen((file + ".json").c_str(), "r", CFILE_NORMAL, CF_TYPE_PLAYER_BINDS, false,
+						   CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
+
+		if (!fp) {
+			mprintf(("PLR => Unable to open '%s' for loading!\n", file.c_str()));
+			// try next
+			continue;
+		}
+
+		try {
+			handler.reset(new PresetFileHandler(fp, true));
+		} catch (const std::exception& e) {
+			mprintf(("PLR => Failed to open JSON: `%s`\n", e.what()));
+			continue;
+		}
+
+		// Check the signature
+		int pst_id = handler->readInt("signature");
+		if (pst_id != PST_FILE_ID) {
+			mprintf(("PST => Invalid header id for `%s`, skipping...\n", file.c_str()));
+			continue;
+		}
+
+		// Version
+		int version = handler->readInt("version");
+		mprintf(("PST => Loading `%s` with version %i\n", file.c_str(), version));
+
+
+		// Start reading in data
+		CC_preset preset;
+		preset.name = file;
+		preset.bindings.resize(Control_config.size());
+
+		size_t size;
+		handler->beginArrayRead(Section::Actions, size);
+		for (size_t i = 0; i < size; ++i, handler->nextArrayElement()) {
+			SCP_string str;
+			int id;
+
+			//handler->beginSectionRead(Section::Unnamed);
+			str = handler->readString("bind");
+			id = ActionToVal(str.c_str());
+
+			if (id < 0) {
+				// Unknown bind, possibly custom.  Ignore for now
+				handler->endSectionRead();	// Unnamed
+				continue;
+			}
+
+			auto &item = preset.bindings[id];
+
+			handler->beginSectionRead(Section::Primary);
+			str = handler->readString("cid");
+			auto cid = CIDToVal(str.c_str());
+
+			str = handler->readString("flags");
+			auto flags = CCFToVal(str.c_str());
+
+			str = handler->readString("input");
+			auto btn = InputToVal(cid, str.c_str());
+			item.first.take(cid, btn, flags);
+			handler->endSectionRead(); // Primary
+
+
+			handler->beginSectionRead(Section::Secondary);
+			str = handler->readString("cid");
+			cid = CIDToVal(str.c_str());
+
+			str = handler->readString("flags");
+			flags = CCFToVal(str.c_str());
+
+			str = handler->readString("input");
+			btn = InputToVal(cid, str.c_str());
+			item.second.take(cid, btn, flags);
+			handler->endSectionRead(); // Secondary
+
+			//handler->endSectionRead(); // Unnamed
+		}
+		handler->endArrayRead(); // Actions
+
+		// Done with the file
+		bool unique = true;
+		auto it = Control_config_presets.begin();
+		for (; it != Control_config_presets.end(); ++it) {
+			if (preset.is_duplicate_of(*it)) {
+				unique = false;
+				break;
+			}
+		}
+
+		if (unique) {
+			Control_config_presets.push_back(preset);
+		} else {
+			Warning(LOCATION, "Preset '%s' is a duplicate of '%s', ignoring", preset.name.c_str(), it->name.c_str());
+		}
+		
+	}
+}
+
+bool preset_file_exists(SCP_string name) {
+	if (name.find(".json") == std::string::npos) {
+		name.append(".json");
+	}
+
+	return cf_exists(name.c_str(), CF_TYPE_PLAYER_BINDS) != 0;
+}
+
+bool save_preset_file(CC_preset preset, bool overwrite) {
+	// Must have a name
+	if (preset.name.empty()) {
+		mprintf(("PST => Unable to save preset, missing name!\n"));
+		return false;
+	}
+	
+	SCP_string filename = preset.name + ".json";
+	std::unique_ptr<PresetFileHandler> handler = nullptr;
+
+	// Check if there's a file already
+	CFILE* fp = cfopen(filename.c_str(), "r", CFILE_NORMAL, CF_TYPE_PLAYER_BINDS, false,
+	                  CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
+	
+	if ((fp != nullptr) && !overwrite) {
+		mprintf(("PST => Unable to save '%s', file already exists!\n", filename.c_str()));
+		return false;
+	}
+
+	// Try opening file for write
+	fp = cfopen(filename.c_str(), "w", CFILE_NORMAL, CF_TYPE_PLAYER_BINDS, false,
+					   CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
+
+	if (!fp) {
+		mprintf(("PST => Unable to save '%s', unknown error!\n", filename.c_str()));
+	}
+
+	try {
+		handler.reset(new PresetFileHandler(fp, false));
+	} catch (const std::exception& e) {
+		mprintf(("PST => Failed to open JSON: %s\n", e.what()));
+		return false;
+	}
+
+	// Write header and version
+	handler->writeInt("signature", PST_FILE_ID);
+	handler->writeInt("version", PST_VERSION);
+
+	mprintf(("PST => Saving %s with version %d...\n", filename.c_str(), (int)PST_VERSION));
+
+	handler->beginArrayWrite(Section::Actions);
+	for (int i = 0; static_cast<size_t>(i) < preset.bindings.size(); ++i) {
+		const auto& item = preset.bindings[i];
+		const auto& first = item.first;
+		const auto& second = item.second;
+
+		handler->beginSectionWrite(Section::Unnamed);
+		handler->writeString("bind", ValToAction(i));
+
+		handler->beginSectionWrite(Section::Primary);
+		handler->writeString("cid",   ValToCID(first.get_cid()));
+		handler->writeString("flags", ValToCCF(first.get_flags()));
+		handler->writeString("input", ValToInput(first));
+		handler->endSectionWrite(); // Primary
+
+		handler->beginSectionWrite(Section::Secondary);
+		handler->writeString("cid", ValToCID(second.get_cid()));
+		handler->writeString("flags", ValToCCF(second.get_flags()));
+		handler->writeString("input", ValToInput(second));
+		handler->endSectionWrite(); // Secondary
+
+		handler->endSectionWrite();	// Control_config[i]
+	}
+	handler->endArrayWrite(); // Actions
+
+	handler->flush();
+
+	return true;
+}
+
+PresetFileHandler::PresetFileHandler(CFILE* cfp, bool reading) : _cfp(cfp) {
+	Assertion(cfp != nullptr, "File pointer must be valid!");
+
+	if (reading) {
+		json_error_t error;
+		_rootObj = json_load_cfile(cfp, 0, &error);
+
+		if (!_rootObj) {
+			SCP_string errorStr;
+			sprintf(errorStr, "Error while reading pilot file! %d: %s", error.line, error.text);
+			throw std::runtime_error(errorStr);
+		}
+	} else {
+		_rootObj = json_object();
+	}
+	_currentEl = _rootObj;
+	_elementStack.push_back(_currentEl);
+};
+
+PresetFileHandler::~PresetFileHandler() {
+	json_decref(_rootObj);
+
+	cfclose(_cfp);
+	_cfp = nullptr;
+};
+
+bool PresetFileHandler::beginSectionRead(Section s) {
+	const char * sectionName = lookupSectionName(s);
+	ensureExists(sectionName);
+
+	auto section = json_object_get(_currentEl, sectionName);
+	if (json_typeof(section) != JSON_OBJECT) {
+		Error(LOCATION, "Section must be a JSON object!");
+		return false;
+	}
+
+	pushElement(section);
+
+	return true;
+};
+
+void PresetFileHandler::beginSectionWrite(Section s) {
+	auto key_name = lookupSectionName(s);
+
+	json_t* obj = json_object();
+
+	if (json_is_array(_currentEl)) {
+		// Currently in an array, section must be unnamed
+		Assertion(key_name == nullptr, "Elements of array may not be named sections!");
+		json_array_append_new(_currentEl, obj);
+	} else {
+		Assertion(key_name != nullptr, "Section outside of arrays must be named!");
+		json_object_set_new(_currentEl, key_name, obj);
+	}
+	pushElement(obj);
+};
+
+bool PresetFileHandler::beginArrayRead(Section s, size_t &size) {
+	Assertion(_arrayIndex == INVALID_SIZE, "Array nesting is not supported yet!");
+
+	const char * name = lookupSectionName(s);
+	ensureExists(name);
+
+	auto array = json_object_get(_currentEl, name);
+	if (json_typeof(array) != JSON_ARRAY) {
+		Error(LOCATION, "Expected an array for '%s' but it was a different type!", name);
+		return false;
+	}
+
+	pushElement(array);
+	size = json_array_size(array);
+
+	if (size == 0) {
+		// Nothing to do here, avoid calling nextArraySection since that assumes that there is at least one element
+		return true;
+	} // Else, advance to the first element in the array
+
+	_arrayIndex = 0;
+	nextArrayElement();
+
+	return true;
+}
+
+void PresetFileHandler::beginArrayWrite(Section s) {
+	const char * name = lookupSectionName(s);
+	auto array = json_array();
+
+	if (json_is_array(_currentEl)) {
+		// We are in an array, section must be unnamed
+		Assertion(name == nullptr, "Inside an array there can be no named section!");
+		json_array_append_new(_currentEl, array);
+	} else {
+		Assertion(name != nullptr, "Section outside of arrays must be named!");
+		json_object_set_new(_currentEl, name, array);
+	}
+	pushElement(array);
+}
+
+void PresetFileHandler::endSectionRead() {
+	Assertion(json_typeof(_currentEl) == JSON_OBJECT, "Current element for section reading is not an object!");
+
+	popElement();
+};
+
+void PresetFileHandler::endSectionWrite() {
+	Assertion(json_is_object(_currentEl), "Section ended while not in a section!");
+
+	popElement();
+};
+
+void PresetFileHandler::endArrayRead() {
+	// First, remove the element we are currently in if it exists
+	if (json_typeof(_currentEl) != JSON_ARRAY) {
+		popElement();
+	}
+
+	Assertion(json_typeof(_currentEl) == JSON_ARRAY, "Current element must be an array!");
+
+	// TODO Sections are straightforward, but Arrays may need special consideration re: index.
+	popElement();
+	_arrayIndex = INVALID_SIZE;
+};
+
+void PresetFileHandler::endArrayWrite() {
+	Assertion(json_is_array(_currentEl), "Array ended while not in an array!");
+
+	popElement();
+};
+
+void PresetFileHandler::ensureExists(const char* name) {
+	if (json_typeof(_currentEl) != JSON_OBJECT) {
+		Error(LOCATION, "JSON reading requires a value with name '%s' but the current element is not an object!", name);
+	}
+	if (json_object_get(_currentEl, name) == nullptr) {
+		Error(LOCATION, "JSON reading requires a value with name '%s' but there is no such value!", name);
+	}
+}
+
+void PresetFileHandler::ensureNotExists(const char* name) {
+	// Stuff debug checks into booleans, otherwise clang will trigger a false positive for static method with just the asserts
+	// Make sure we're in an element that can support keys
+	bool supports_keys = json_is_object(_currentEl);
+
+	// Make sure we don't overwrite previous values
+	bool element_is_unique = json_object_get(_currentEl, name) == nullptr;
+
+	Assertion(supports_keys, "Currently not in an element that supports keys!");
+	Assertion(element_is_unique, "Entry with name %s already exists!", name);
+}
+
+bool PresetFileHandler::exists(const char* name) {
+	if (json_typeof(_currentEl) != JSON_OBJECT) {
+		return false;
+	}
+	if (json_object_get(_currentEl, name) == nullptr) {
+		return false;
+	}
+
+	return true;
+}
+
+void PresetFileHandler::flush() {
+	Assertion(_elementStack.size() == 1, "Not all sections or arrays have been ended!");
+
+	json_dump_cfile(_rootObj, _cfp, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
+}
+
+void PresetFileHandler::nextArrayElement() {
+	Assertion(_arrayIndex != INVALID_SIZE, "Array index must be valid for this function!");
+	bool in_section = json_is_object(_currentEl);
+
+	if (in_section) {
+		// We have to pop the previous section first
+		popElement();
+
+		Assertion(json_typeof(_currentEl) == JSON_ARRAY, "The previous element should have been an array!");
+	}
+
+	auto max = json_array_size(_currentEl);
+	Assertion(_arrayIndex <= max, "Invalid array index detected!");
+
+	// Silently ignore if we are one past the last element since this function is used in a for loop where this function
+	// is executed one time after the index is incremented past the last element
+	if (_arrayIndex == max) {
+		// Increment the index so we catch usage errors the next time someone tries to call this function
+		++_arrayIndex;
+		return;
+	}
+
+	// We use the current array index and then increment it to avoid skipping the first element
+	auto el = json_array_get(_currentEl, _arrayIndex);
+	++_arrayIndex;
+
+	pushElement(el);
+}
+
+json_t * PresetFileHandler::popElement() {
+	Assertion(_elementStack.size() > 1, "Element stack may not get smaller than one element!");
+
+	_elementStack.pop_back();
+	_currentEl = _elementStack.back();
+	return _currentEl;
+}
+
+void PresetFileHandler::pushElement(json_t* el) {
+	Assertion(el != nullptr, "Invalid JSON element pointer passed!");
+
+	_currentEl = el;
+	_elementStack.push_back(_currentEl);
+}
+
+SCP_string PresetFileHandler::readString(const char* key) {
+	auto el = json_object_get(_currentEl, key);
+
+	if (el == nullptr || json_typeof(el) != JSON_STRING) {
+		Error(LOCATION, "JSON element %s must be a string but it is not valid!", key);
+		return SCP_string();
+	}
+	auto json_str = json_string_value(el);
+	SCP_string val;
+	val.assign(json_str, json_str + json_string_length(el));
+
+	return val;
+}
+
+int PresetFileHandler::readInt(const char* key) {
+	auto el = json_object_get(_currentEl, key);
+
+	if (el == nullptr || json_typeof(el) != JSON_INTEGER) {
+		Error(LOCATION, "JSON element %s must be an integer but it is not valid!", key);
+		return 0;
+	}
+
+	return static_cast<int>(json_integer_value(el));
+}
+
+void PresetFileHandler::writeString(const char* key, SCP_string s) {
+	ensureNotExists(key);
+	json_t *jstr = nullptr;
+
+	if (!s.empty()) {
+		// if this string isn't proper UTF-8, try to convert it
+		if (utf8::find_invalid(s.begin(), s.end()) != s.end()) {
+			SCP_string buffer;
+			coerce_to_utf8(buffer, s.c_str());
+			jstr = json_string(buffer.c_str());
+		} else {
+			jstr = json_string(s.c_str());
+		}
+	}
+
+	json_object_set_new(_currentEl, key, jstr);
+};
+
+void PresetFileHandler::writeInt(const char* key, int val) {
+	ensureNotExists(key);
+
+	json_object_set_new(_currentEl, key, json_integer(val));
+}

code/controlconfig/presets.h

@@ -0,0 +1,222 @@
+#pragma once
+
+#include "cfile/cfile.h"
+#include "controlconfig/controlsconfig.h"
+#include "globalincs/pstypes.h"
+#include "globalincs/vmallocator.h"
+
+#include <jansson.h>
+
+/** API for saving and loading player custom bindings, known as Presets
+
+ Init.  If the player/preset dir doesn't exist. Create it, and print a help.txt with all enums (as strings) to label
+ the button names and action names.
+
+ Example output:
+ {
+	"actions": {
+		"TARGET_NEXT": {
+			"first": {
+				"cid": 0,
+				"flags": 0,
+				"btn": 0
+			},
+			"second": {
+				"cid": 0,
+				"flags": 0,
+				"btn": 0
+			}
+		},
+		"TARGET_PREV" : {
+			"first": {
+				"cid": 0,
+				"flags": 0,
+				"btn": 0
+			},
+			"second": {
+				"cid": 0,
+				"flags": 0,
+				"btn": 0
+			}
+		},
+	},
+	"version": 0
+ }
+
+
+*/
+namespace io {
+namespace presets {
+
+static const unsigned int PST_VERSION = 0;
+static const unsigned int PST_FILE_ID = 0x5f545350;  // "PST_" in file
+
+enum class Section {
+	Invalid = -1,
+	Unnamed = 0,
+	
+	// arrays
+	Actions,
+
+	// subsections
+	Primary,
+	Secondary
+};
+
+class PresetFileHandler {
+public:
+	PresetFileHandler(CFILE* cfp, bool reading);
+	~PresetFileHandler();
+
+	/**
+	 * begins writing to a section using the presets::Section as its name
+	 * @param[in] s     id of the section
+	 */
+	void beginSectionWrite(presets::Section s);
+
+	/**
+	 * begins reading a section, if it exists
+	 * @param[in] s    id of the section
+	 */
+	bool beginSectionRead(presets::Section s);
+
+	/**
+	 * Begins writing to an array using the presets::Section as its name
+	 *
+	 * @param[in] s     id of the array
+	 */
+	void beginArrayWrite(presets::Section s);
+
+	/**
+	 * Begins reading from an array
+	 * @param[int] s    id of the array
+	 * @param[out] size the size of the array
+	 */
+	bool beginArrayRead(presets::Section s, size_t &size);
+
+	/**
+	 * ends writing to a section
+	 */
+	void endSectionWrite();
+
+	/**
+	 * ends reading a section
+	 */
+	void endSectionRead();
+
+	/**
+	 * ends writing to an array.
+	 */
+	void endArrayWrite();
+
+	/**
+	 * ends reading from an array
+	 */
+	void endArrayRead();
+
+	/**
+	 * Writes a string with the given key name
+	 */
+	void writeString(const char* key, SCP_string s);
+
+	/**
+	 * Reads a string with the given key name
+	 */
+	SCP_string readString(const char* key);
+
+	/**
+	 * Writes an int with the given key name
+	 */
+	void writeInt(const char* key, int val);
+
+	/**
+	 * Reads an int with the given key name
+	 */
+	int readInt(const char* key);
+
+	/**
+	 * For writing, Flushes the buffers and dumps to file
+	 */
+	void flush();
+
+	/**
+	 * Advances the array parser to the next element
+	 */
+	void nextArrayElement();
+
+private:
+	CFILE* _cfp = nullptr;
+
+	json_t* _rootObj = nullptr;
+
+	json_t* _currentEl = nullptr;
+
+	/**
+	 * BufferStack of all json elements being read/written
+	 */
+	SCP_vector<json_t*> _elementStack;
+
+	/**
+	 * Stack to keep track of the heirachy/nesting. Back is immediate parent, Front is root
+	 */
+	SCP_vector<void*> _parentStack;
+
+	size_t _arrayIndex = INVALID_SIZE;
+
+	//void* _sectionIterator = nullptr;	//!< Pointer to the current section/array we're in
+
+private:
+	/**
+	 * Pushes an element onto the elementStack
+	 */
+	void pushElement(json_t* el);
+	
+	/**
+	 * Pops an element off the elementStack
+	 */
+	json_t * popElement();
+
+	/**
+	 * Used for optionals, checks if an element exists with the given name
+	 * @return True     if the element exists
+	 * @return False    otherwise
+	 */
+	bool exists(const char* name);
+
+	/**
+	 * Throws an error if an element with the given name does not exist
+	 */
+	void ensureExists(const char* name);
+
+	/**
+	 * Throws an error if an element with the given name exists
+	 */
+	void ensureNotExists(const char* name);
+};
+
+} // namespace presets
+} // namespace io
+
+/**
+ * @brief Saves the given preset to file.
+ * @param[in] preset    The preset to save
+ * @param[in] overwrite If true, overwrite existing preset file which have the same name as the given preset
+ *
+ * @returns True    if successful, or
+ * @returns False   Preset does not have a name, or
+ * @returns False   Preset file exists and overwrite == false, or
+ * @returns False   Preset file .JSON could not be written
+ */
+bool save_preset_file(CC_preset preset, bool overwrite);
+
+/**
+ * @brief Loads in all preset .json files from 'players/presets'
+ * @details If a preset file is unique, it is loaded into the game and available for use by the player.  However, if
+ * a preset is a duplicate of another preset, it is ignored, and the player is warned of it
+ */
+void load_preset_files();
+
+/**
+ * @brief Returns true if a preset file with the given name exists.
+ */
+bool preset_file_exists(SCP_string name);

code/cutscene/Decoder.h

@@ -93,13 +93,12 @@ class Decoder {
 	bool m_decoding;
 	size_t m_queueSize = 0;
 
-	Decoder(const Decoder&) SCP_DELETED_FUNCTION;
-
-	Decoder& operator=(const Decoder&) SCP_DELETED_FUNCTION;
  protected:
 	Decoder();
 
  public:
+	Decoder(const Decoder&) = delete;
+	Decoder& operator=(const Decoder&) = delete;
 
 	virtual ~Decoder();
 

code/cutscene/cutscenes.cpp

@@ -613,7 +613,7 @@ void cutscenes_screen_do_frame()
 			if (src)
 			{
 				Text_size = split_str(src, Cutscene_desc_coords[gr_screen.res][2], Text_line_size, Text_lines,
-									  Cutscene_max_text_lines[gr_screen.res]);
+									  Cutscene_max_text_lines[gr_screen.res], MAX_TEXT_LINE_LEN);
 				Assert(Text_size >= 0 && Text_size < Cutscene_max_text_lines[gr_screen.res]);
 			}
 		}

code/cutscene/ffmpeg/FFMPEGDecoder.cpp

@@ -229,7 +229,7 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 
 	auto ctx = stream->m_ctx->ctx();
 
-	auto videoStream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &status->videoCodec, 0);
+	auto videoStream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
 	if (videoStream < 0) {
 		if (videoStream == AVERROR_STREAM_NOT_FOUND) {
 			mprintf(("FFmpeg: No video stream found in file!\n"));
@@ -242,10 +242,26 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 		return nullptr;
 	}
 
+	status->videoStreamIndex = videoStream;
+	status->videoStream = ctx->streams[videoStream];
+	status->videoCodecPars = getCodecParameters(status->videoStream);
+
+	status->videoCodec = avcodec_find_decoder(status->videoCodecPars.codec_id);
+
+	if ( !status->videoCodec ) {
+		mprintf(("FFmpeg: Cannot find decoder for video stream!\n"));
+		return nullptr;
+	}
+
+	if (properties.looping && status->videoCodecPars.codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
+		mprintf(("FFmpeg: Looping is not supported for inteplay (MVE) movies!\n"));
+		return nullptr;
+	}
+
 	int audioStream = -1;
 
 	if (properties.with_audio) {
-		audioStream = av_find_best_stream(ctx, AVMEDIA_TYPE_AUDIO, -1, videoStream, &status->audioCodec, 0);
+		audioStream = av_find_best_stream(ctx, AVMEDIA_TYPE_AUDIO, -1, videoStream, nullptr, 0);
 		if (audioStream < 0) {
 			if (audioStream == AVERROR_STREAM_NOT_FOUND) {
 				mprintf(("FFmpeg: No audio stream found in file!\n"));
@@ -254,17 +270,21 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 			} else {
 				mprintf(("FFmpeg: Unknown error while finding audio stream!\n"));
 			}
+		} else {
+			status->audioStreamIndex = audioStream;
+			status->audioStream = ctx->streams[audioStream];
+			status->audioCodecPars = getCodecParameters(status->audioStream);
+
+			status->audioCodec = avcodec_find_decoder(status->audioCodecPars.codec_id);
+
+			if ( !status->audioCodec ) {
+				mprintf(("FFmpeg: Cannot find decoder for audio stream!\n"));
+				status->audioStreamIndex = -1;
+				audioStream = -1;
+			}
 		}
 	}
 
-	status->videoStreamIndex = videoStream;
-	status->videoStream = ctx->streams[videoStream];
-
-	if (audioStream >= 0) {
-		status->audioStreamIndex = audioStream;
-		status->audioStream = ctx->streams[audioStream];
-	}
-
 	if (subt) {
 		auto subtCtx = subt->m_ctx->ctx();
 
@@ -278,9 +298,13 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 				mprintf(("FFmpeg: Unknown error while finding subtitle stream!\n"));
 			}
 		} else {
+			status->subtitleStreamIndex = subtStream;
 			status->subtitleStream      = subtCtx->streams[subtStream];
 			status->externalSubtitles   = true;
-			status->subtitleStreamIndex = subtStream;
+			// Not really sure if this makes sense for subtitles but it shouldn't break anything...
+			status->subtitleCodecPars = getCodecParameters(status->subtitleStream);
+
+			status->subtitleCodec = avcodec_find_decoder(status->subtitleCodecPars.codec_id);
 		}
 	}
 
@@ -312,13 +336,6 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 		}
 	}
 
-    status->videoCodecPars = getCodecParameters(status->videoStream);
-
-	if (properties.looping && status->videoCodecPars.codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
-		mprintf(("FFmpeg: Looping is not supported for inteplay (MVE) movies!\n"));
-		return nullptr;
-	}
-
 	int err;
 #if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(57, 24, 255)
 	status->videoCodecCtx = avcodec_alloc_context3(status->videoCodec);
@@ -348,8 +365,6 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 
 	// Now initialize audio, if this fails it's not a fatal error
 	if (audioStream >= 0) {
-		status->audioCodecPars = getCodecParameters(status->audioStream);
-
 #if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(57, 24, 255)
 		status->audioCodecCtx = avcodec_alloc_context3(status->audioCodec);
 
@@ -376,11 +391,6 @@ std::unique_ptr<DecoderStatus> initializeStatus(std::unique_ptr<InputStream>& st
 	}
 
 	if (status->subtitleStream != nullptr) {
-		// Not really sure if this makes sense for subtitles but it shouldn't break anything...
-		status->subtitleCodecPars = getCodecParameters(status->subtitleStream);
-
-		status->subtitleCodec = avcodec_find_decoder(status->subtitleCodecPars.codec_id);
-
 #if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(57, 24, 255)
 		status->subtitleCodecCtx = avcodec_alloc_context3(status->subtitleCodec);
 

code/cutscene/ffmpeg/internal.h

@@ -24,13 +24,13 @@ struct DecoderStatus {
 	int videoStreamIndex = -1;
 	AVStream* videoStream = nullptr;
 	CodecContextParameters videoCodecPars;
-	AVCodec* videoCodec = nullptr;
+	const AVCodec* videoCodec = nullptr;
 	AVCodecContext* videoCodecCtx = nullptr;
 
 	int audioStreamIndex = -1;
 	AVStream* audioStream = nullptr;
 	CodecContextParameters audioCodecPars;
-	AVCodec* audioCodec = nullptr;
+	const AVCodec* audioCodec = nullptr;
 	AVCodecContext* audioCodecCtx = nullptr;
 
 	// Subtitles are a bit different since they max come from a different file
@@ -38,17 +38,15 @@ struct DecoderStatus {
 	int subtitleStreamIndex = -1;
 	AVStream* subtitleStream = nullptr;
 	CodecContextParameters subtitleCodecPars;
-	AVCodec* subtitleCodec = nullptr;
+	const AVCodec* subtitleCodec = nullptr;
 	AVCodecContext* subtitleCodecCtx = nullptr;
 
 	DecoderStatus();
 
 	~DecoderStatus();
 
- private:
-	DecoderStatus(const DecoderStatus&) SCP_DELETED_FUNCTION;
-
-	DecoderStatus& operator=(const DecoderStatus&) SCP_DELETED_FUNCTION;
+	DecoderStatus(const DecoderStatus&) = delete;
+	DecoderStatus& operator=(const DecoderStatus&) = delete;
 };
 
 template<typename Frame>
@@ -67,8 +65,8 @@ class FFMPEGStreamDecoder {
 	explicit FFMPEGStreamDecoder(DecoderStatus* status);
 	virtual ~FFMPEGStreamDecoder();
 
-	FFMPEGStreamDecoder(const FFMPEGStreamDecoder&) SCP_DELETED_FUNCTION;
-	FFMPEGStreamDecoder& operator=(const FFMPEGStreamDecoder&) SCP_DELETED_FUNCTION;
+	FFMPEGStreamDecoder(const FFMPEGStreamDecoder&) = delete;
+	FFMPEGStreamDecoder& operator=(const FFMPEGStreamDecoder&) = delete;
 
 	virtual void decodePacket(AVPacket* packet) = 0;
 

code/cutscene/movie.cpp

@@ -205,14 +205,14 @@ void movie_display_loop(Player* player, PlaybackState* state) {
 	auto fpsCapSave = Cmdline_NoFPSCap;
 	Cmdline_NoFPSCap = 1;
 
-	auto lastDisplayTimestamp = timer_get_microseconds();
+	auto lastDisplayTime = timer_get_microseconds();
 	while (state->playing) {
 		TRACE_SCOPE(tracing::CutsceneStep);
 
-		auto timestamp = timer_get_microseconds();
+		auto now = timer_get_microseconds();
 
-		auto passed = timestamp - lastDisplayTimestamp;
-		lastDisplayTimestamp = timestamp;
+		auto passed = now - lastDisplayTime;
+		lastDisplayTime = now;
 
 		if (player->isPlaybackReady()) {
 			// Play as long as the player reports that there is more to display

code/debris/debris.cpp

@@ -30,8 +30,9 @@
 #include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "species_defs/species_defs.h"
-#include "weapon/weapon.h"
 #include "tracing/Monitor.h"
+#include "utils/Random.h"
+#include "weapon/weapon.h"
 
 #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
@@ -51,8 +52,6 @@ int Debris_model = -1;
 int Debris_vaporize_model = -1;
 int Debris_num_submodels = 0;
 
-#define	MAX_DEBRIS_DIST					10000.0f			//	Debris goes away if it's this far away.
-#define	DEBRIS_DISTANCE_CHECK_TIME		(10*1000)		//	Check every 10 seconds.
 #define	DEBRIS_INDEX(dp) (int)(dp-Debris.data())
 
 const auto OnDebrisCreatedHook = scripting::Hook::Factory(
@@ -75,7 +74,7 @@ static void debris_start_death_roll(object *debris_obj, debris *debris_p)
 
 		int fireball_type = fireball_ship_explosion_type(&Ship_info[debris_p->ship_info_index]);
 		if(fireball_type < 0) {
-			fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
+			fireball_type = FIREBALL_EXPLOSION_LARGE1 + Random::next(FIREBALL_NUM_LARGE_EXPLOSIONS);
 		}
 		fireball_create( &debris_obj->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(debris_obj), debris_obj->radius*1.75f);
 
@@ -196,34 +195,6 @@ void debris_delete( object * obj )
 	db->objnum = -1;
 }
 
-/**
- * If debris piece *db is far away from all players, make it go away very soon.
- * In single player game, delete if MAX_DEBRIS_DIST from player.
- * In multiplayer game, delete if MAX_DEBRIS_DIST from all players.
- */
-void maybe_delete_debris(debris *db)
-{
-	object	*objp;
-
-	if (Player_obj != nullptr && timestamp_elapsed(db->next_distance_check) && timestamp_elapsed(db->must_survive_until)) {
-		if (!(Game_mode & GM_MULTIPLAYER)) {		//	In single player game, just check against player.
-			if (vm_vec_dist_quick(&Player_obj->pos, &Objects[db->objnum].pos) > MAX_DEBRIS_DIST)
-				db->lifeleft = 0.1f;
-			else
-				db->next_distance_check = timestamp(DEBRIS_DISTANCE_CHECK_TIME);
-		} else {
-			for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
-				if (objp->flags[Object::Object_Flags::Player_ship]) {
-					if (vm_vec_dist_quick(&objp->pos, &Objects[db->objnum].pos) < MAX_DEBRIS_DIST) {
-						db->next_distance_check = timestamp(DEBRIS_DISTANCE_CHECK_TIME);
-						return;
-					}
-				}
-			}
-			db->lifeleft = 0.1f;
-		}
-	}
-}
 
 /**
  * Do various updates to debris:  check if time to die, start fireballs
@@ -246,7 +217,7 @@ void debris_process_post(object * obj, float frame_time)
 		radar_plot_object( obj );
 
 		if ( timestamp_elapsed(db->sound_delay) ) {
-			obj_snd_assign(objnum, db->ambient_sound, &vmd_zero_vector, 0);
+			obj_snd_assign(objnum, db->ambient_sound, &vmd_zero_vector);
 			db->sound_delay = 0;
 		}
 	}
@@ -260,8 +231,6 @@ void debris_process_post(object * obj, float frame_time)
 		}
 	}
 
-	maybe_delete_debris(db);	//	Make this debris go away if it's very far away.
-
 	// ================== DO THE ELECTRIC ARCING STUFF =====================
 	if ( db->arc_frequency <= 0 )	{
 		return;			// If arc_frequency <= 0, this piece has no arcs on it
@@ -274,7 +243,7 @@ void debris_process_post(object * obj, float frame_time)
 
 		if (db->is_hull)	{
 
-			int n, n_arcs = ((rand()>>5) % 3)+1;		// Create 1-3 sparks
+			int n, n_arcs = Random::next(1, 3);		// Create 1-3 sparks
 
 			vec3d v1, v2, v3, v4;
 
@@ -283,8 +252,7 @@ void debris_process_post(object * obj, float frame_time)
 
 			n = 0;
 
-			int a = 100, b = 1000;
-			int lifetime = (myrand()%((b)-(a)+1))+(a);
+			int lifetime = Random::next(100, 1000);
 
 			// Create the spark effects
 			for (int i=0; i<MAX_DEBRIS_ARCS; ++i)	{
@@ -351,8 +319,8 @@ void debris_process_post(object * obj, float frame_time)
 				db->arc_timestamp[i] = timestamp(-1);
 			} else {
 				// Maybe move a vertex....  20% of the time maybe?
-				int mr = myrand();
-				if ( mr < RAND_MAX/5 )	{
+				int mr = Random::next();
+				if ( mr < Random::MAX_VALUE/5 )	{
 					vec3d v1, v2;
 
 					submodel_get_two_random_points_better(db->model_num, db->submodel_num, &v1, &v2);
@@ -424,17 +392,6 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	sip = &Ship_info[shipp->ship_info_index];
 	vaporize = (shipp->flags[Ship::Ship_Flags::Vaporize]);
 
-	if ( !hull_flag )	{
-		// Make vaporize debris seen from farther away
-		float dist = vm_vec_dist_quick( pos, &Eye_position );
-		if (vaporize) {
-			dist /= 2.0f;
-		}
-		if ( dist > source_obj->radius * 20.0f ) {
-			return NULL;
-		}
-	}
-
 	// try to maintain our soft limit
 	if (hull_flag && (Num_hull_pieces >= SOFT_LIMIT_DEBRIS_PIECES)) {
 		// cause oldest hull debris chunk to blow up
@@ -460,15 +417,15 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	if (!hull_flag) {
 		if (model_num >= 0) {
 			db->model_num = model_num;
-			db->submodel_num = (myrand() >> 4) % sip->generic_debris_num_submodels;
+			db->submodel_num = Random::next(sip->generic_debris_num_submodels);
 		}
 		else if (vaporize) {
 			db->model_num = Debris_vaporize_model;
-			db->submodel_num = (myrand() >> 4) % Debris_num_submodels;
+			db->submodel_num = Random::next(Debris_num_submodels);
 		}
 		else {
 			db->model_num = Debris_model;
-			db->submodel_num = (myrand() >> 4) % Debris_num_submodels;
+			db->submodel_num = Random::next(Debris_num_submodels);
 		}
 	}
 	else {
@@ -476,12 +433,19 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		db->submodel_num = submodel_num;
 	}
 
-	db->model_instance_num = model_create_instance(false, db->model_num);
-
 	float radius = submodel_get_radius(db->model_num, db->submodel_num);
 
-	//WMC - We must survive until now, at least.
-	db->must_survive_until = timestamp();
+	// if its generic, maybe cull it if its too small and far
+	if (!hull_flag) {
+		float dist = vm_vec_dist_quick(pos, &Eye_position);
+		// Make vaporize debris seen from farther away
+		if (vaporize) {
+			dist /= 2.0f;
+		}
+		if (dist > radius * 200.0f) {
+			return nullptr;
+		}
+	}
 
 	if(hull_flag && sip->debris_min_lifetime >= 0.0f && sip->debris_max_lifetime >= 0.0f)
 	{
@@ -491,7 +455,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	{
 		// Create Debris piece n!
 		if ( hull_flag ) {
-			if (rand() < RAND_MAX/6)	// Make some pieces blow up shortly after explosion.
+			if (Random::next() < (Random::MAX_VALUE/6))	// Make some pieces blow up shortly after explosion.
 				db->lifeleft = 2.0f * (frand()) + 0.5f;
 			else {
 				db->flags.set(Debris_Flags::DoNotExpire);
@@ -509,12 +473,10 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	{
 		if(sip->debris_min_lifetime >= 0.0f && sip->debris_max_lifetime >= 0.0f)
 		{
-			db->must_survive_until = timestamp(fl2i(sip->debris_min_lifetime * 1000.0f));
 			db->lifeleft = (( sip->debris_max_lifetime - sip->debris_min_lifetime ) * frand()) + sip->debris_min_lifetime;
 		}
 		else if(sip->debris_min_lifetime >= 0.0f)
 		{
-			db->must_survive_until = timestamp(fl2i(sip->debris_min_lifetime * 1000.0f));
 			if(db->lifeleft < sip->debris_min_lifetime)
 				db->lifeleft = sip->debris_min_lifetime;
 		}
@@ -539,7 +501,6 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	db->fire_timeout = 0;	// if not changed, timestamp_elapsed() will return false
 	db->time_started = Missiontime;
 	db->species = Ship_info[shipp->ship_info_index].species;
-	db->next_distance_check = (myrand() % 2000) + 4*DEBRIS_DISTANCE_CHECK_TIME;
 	db->parent_alt_name = shipp->alt_type_index;
 	db->damage_mult = 1.0f;
 
@@ -560,7 +521,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 
 	db->next_fireball = timestamp_rand(500,2000);	//start one 1/2 - 2 secs later
 
-	if ( pos == NULL )
+	if ( pos == nullptr )
 		pos = &source_obj->pos;
 
     flagset<Object::Object_Flags> default_flags;
@@ -576,10 +537,10 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		vm_vector_2_matrix(&orient, &rand);
 	}
 
-    objnum = obj_create( OBJ_DEBRIS, parent_objnum, n, &orient, pos, radius, default_flags);
+	objnum = obj_create(OBJ_DEBRIS, parent_objnum, n, &orient, pos, radius, default_flags, false);
 	if ( objnum == -1 ) {
 		mprintf(("Couldn't create debris object -- out of object slots\n"));
-		return NULL;
+		return nullptr;
 	}
 
 	db->objnum = objnum;
@@ -587,6 +548,8 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	obj = &Objects[objnum];
 	pi = &obj->phys_info;
 
+	db->model_instance_num = model_create_instance(objnum, db->model_num);
+
 	// assign the network signature.  The signature will be 0 for non-hull pieces, but since that
 	// is our invalid signature, it should be okay.
 	obj->net_signature = 0;
@@ -629,7 +592,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 
 	if ( hull_flag )	{
 		float t;
-		scale = exp_force * i2fl((myrand()%20) + 10);	// for radial_vel away from location of blast center
+		scale = exp_force * i2fl(Random::next(10, 29));	// for radial_vel away from location of blast center
 		db->sound_delay = timestamp(DEBRIS_SOUND_DELAY);
 
 		// set up physics mass and I_inv for hull debris pieces
@@ -641,7 +604,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 
 		// limit the amount of time that fireballs appear
 		// let fireball length be linked to radius of ship.  Range is .33 radius => 3.33 radius seconds.
-		t = 1000*Objects[db->source_objnum].radius/3 + myrand()%(fl2i(1000*3*Objects[db->source_objnum].radius));
+		t = 1000*Objects[db->source_objnum].radius/3 + Random::next(fl2i(1000*3*Objects[db->source_objnum].radius));
 		db->fire_timeout = timestamp(fl2i(t));		// fireballs last from 5 - 30 seconds
 		
 		if ( Objects[db->source_objnum].radius < MIN_RADIUS_FOR_PERSISTANT_DEBRIS ) {
@@ -652,7 +615,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		}
 	}
 	else {
-		scale = exp_force * i2fl((myrand()%20) + 10);	// for radial_vel away from blast center (non-hull)
+		scale = exp_force * i2fl(Random::next(10, 29));	// for radial_vel away from blast center (non-hull)
 	}
 
 	if ( vm_vec_mag_squared( &to_center ) < 0.1f )	{
@@ -679,7 +642,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		radius = 1.0f;
 	}
 
-	scale = ( 6.0f + i2fl(myrand()%4) ) / radius;
+	scale = (6.0f + i2fl(Random::next(4))) / radius;
 
 	vm_vec_rand_vec_quick(&rotvel);
 	vm_vec_scale(&rotvel, scale);
@@ -812,9 +775,9 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 				vec3d normal;
 
 				if (mc.model_instance_num >= 0)
-					model_instance_find_world_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
+					model_instance_local_to_global_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
 				else
-					model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
+					model_local_to_global_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
 
 				*hitNormal = normal;
 			}
@@ -848,18 +811,18 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 	// find the light object's position in the heavy object's reference frame at last frame and also in this frame.
 	vec3d p0_temp, p0_rotated;
 		
-	// Collision detection from rotation enabled if at rotaion is less than 30 degree in frame
+	// Collision detection from rotation enabled if at rotation is less than 30 degree in frame
 	// This should account for all ships
 	if ( (vm_vec_mag_squared(&heavy->phys_info.rotvel) * flFrametime*flFrametime) < (PI*PI/36) ) {
 		// collide_rotate calculate (1) start position and (2) relative velocity
-		debris_hit_info->collide_rotate = 1;
+		debris_hit_info->collide_rotate = true;
 		vm_vec_rotate(&p0_temp, &p0, &heavy->last_orient);
 		vm_vec_unrotate(&p0_rotated, &p0_temp, &heavy->orient);
 		mc.p0 = &p0_rotated;				// Point 1 of ray to check
 		vm_vec_sub(&debris_hit_info->light_rel_vel, &p1, &p0_rotated);
 		vm_vec_scale(&debris_hit_info->light_rel_vel, 1/flFrametime);
 	} else {
-		debris_hit_info->collide_rotate = 0;
+		debris_hit_info->collide_rotate = false;
 		vm_vec_sub(&debris_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel);
 	}
 
@@ -891,18 +854,18 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 
 			// Do collision the cool new way
 			if ( debris_hit_info->collide_rotate ) {
-				// We collide with the sphere, find the list of rotating submodels and test one at a time
+				// We collide with the sphere, find the list of moving submodels and test one at a time
 				SCP_vector<int> submodel_vector;
-				model_get_rotating_submodel_list(&submodel_vector, heavy_obj);
+				model_get_moving_submodel_list(submodel_vector, heavy_obj);
 
-				// turn off all rotating submodels, collide against only 1 at a time.
-				// turn off collision detection for all rotating submodels
+				// turn off all moving submodels, collide against only 1 at a time.
+				// turn off collision detection for all moving submodels
 				for (auto submodel : submodel_vector) {
 					pmi->submodel[submodel].collision_checked = true;
 				}
 
-				// reset flags to check MC_CHECK_MODEL | MC_CHECK_SPHERELINE and maybe MC_CHECK_INVISIBLE_FACES and MC_SUBMODEL_INSTANCE
-				mc.flags = copy_flags | MC_SUBMODEL_INSTANCE;
+				// Only check single submodel now, since children of moving submodels are handled as moving as well
+				mc.flags = copy_flags | MC_SUBMODEL;
 
 				if (Ship_info[Ships[pship_obj->instance].ship_info_index].collision_lod > -1) {
 					mc.lod = Ship_info[Ships[pship_obj->instance].ship_info_index].collision_lod;
@@ -915,15 +878,9 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 					// turn on just one submodel for collision test
 					smi->collision_checked = false;
 
-					// set angles for last frame (need to set to prev to get p0)
-					matrix copy_matrix = smi->canonical_orient;
-
 					// find the start and end positions of the sphere in submodel RF
-					smi->canonical_orient = smi->canonical_prev_orient;
-					world_find_model_instance_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos);
-
-					smi->canonical_orient = copy_matrix;
-					world_find_model_instance_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
+					model_instance_global_to_local_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos, true);
+					model_instance_global_to_local_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
 
 					mc.p0 = &p0;
 					mc.p1 = &p1;
@@ -936,19 +893,19 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 							mc_ret_val = 1;
 
 							// set up debris_hit_info common
-							set_hit_struct_info(debris_hit_info, &mc, SUBMODEL_ROT_HIT);
-							model_instance_find_world_point(&debris_hit_info->hit_pos, &mc.hit_point, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							set_hit_struct_info(debris_hit_info, &mc, true);
+							model_instance_local_to_global_point(&debris_hit_info->hit_pos, &mc.hit_point, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
 
 							// set up debris_hit_info for rotating submodel
-							if (debris_hit_info->edge_hit == 0) {
-								model_instance_find_world_dir(&debris_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+							if (!debris_hit_info->edge_hit) {
+								model_instance_local_to_global_dir(&debris_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 							}
 
 							// find position in submodel RF of light object at collison
 							vec3d int_light_pos, diff;
 							vm_vec_sub(&diff, mc.p1, mc.p0);
 							vm_vec_scale_add(&int_light_pos, mc.p0, &diff, mc.hit_dist);
-							model_instance_find_world_point(&debris_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							model_instance_local_to_global_point(&debris_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
 						}
 					}
 
@@ -969,11 +926,11 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 				if (mc.hit_dist < debris_hit_info->hit_time) {
 					mc_ret_val = 1;
 
-					set_hit_struct_info(debris_hit_info, &mc, SUBMODEL_NO_ROT_HIT);
+					set_hit_struct_info(debris_hit_info, &mc, false);
 
 					// get collision normal if not edge hit
-					if (debris_hit_info->edge_hit == 0) {
-						model_instance_find_world_dir(&debris_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
+					if (!debris_hit_info->edge_hit) {
+						model_instance_local_to_global_dir(&debris_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 					}
 
 					// find position in submodel RF of light object at collison
@@ -999,7 +956,7 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 		mc_ret_val = model_collide(&mc);
 
 		if (mc_ret_val) {
-			set_hit_struct_info(debris_hit_info, &mc, SUBMODEL_NO_ROT_HIT);
+			set_hit_struct_info(debris_hit_info, &mc, false);
 
 			// set normal if not edge hit
 			if ( !debris_hit_info->edge_hit ) {
@@ -1133,7 +1090,7 @@ void debris_render(object * obj, model_draw_list *scene)
 	if ( vm_vec_dist_quick( &obj->pos, &Eye_position ) < obj->radius*50.0f )	{
 		for (i=0; i<MAX_DEBRIS_ARCS; i++ )	{
 			if ( timestamp_valid( db->arc_timestamp[i] ) )	{
-				model_instance_add_arc( pm, pmi, db->submodel_num, &db->arc_pts[i][0], &db->arc_pts[i][1], MARC_TYPE_NORMAL );
+				model_instance_add_arc( pm, pmi, db->submodel_num, &db->arc_pts[i][0], &db->arc_pts[i][1], MARC_TYPE_DAMAGED );
 			}
 		}
 	}

code/debris/debris.h

@@ -40,7 +40,6 @@ typedef struct debris {
 	gamesnd_id ambient_sound;		// Ambient looping sound
 	int		objnum = -1;			// What object this is linked to
 	float		lifeleft;			// When 0 or less object dies
-	int		must_survive_until;		//WMC - timestamp of earliest point that it can be murthered.
 	int		model_num;				// What model this uses
 	int		model_instance_num;		// What model instance this uses - needed for arcs
 	int		submodel_num;			// What submodel this uses
@@ -50,7 +49,6 @@ typedef struct debris {
 	int		fire_timeout;			// timestamp that holds time for fireballs to stop appearing
 	int		sound_delay;			// timestamp to signal when sound should start
 	fix		time_started;			// time when debris was created
-	int		next_distance_check;	//	timestamp to determine whether to delete this piece of debris.
 
 	vec3d	arc_pts[MAX_DEBRIS_ARCS][2];	// The endpoints of each arc
 	int		arc_timestamp[MAX_DEBRIS_ARCS];	// When this times out, the spark goes away.  -1 is not used

code/decals/decals.cpp

@@ -244,6 +244,9 @@ struct Decal {
 		if (!object.IsValid()) {
 			return false;
 		}
+		if (object.objp->flags[Object::Object_Flags::Should_be_dead]) {
+			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",
@@ -270,6 +273,9 @@ struct Decal {
 			if (smi->blown_off) {
 				return false;
 			}
+		} else {
+			Assertion(false, "Only ships are currently supported for decals!");
+			return false;
 		}
 
 		return true;
@@ -405,7 +411,7 @@ matrix4 getDecalTransform(Decal& decal) {
 	auto pm = model_get(pmi->model_num);
 
 	vec3d worldPos;
-	model_instance_find_world_point(&worldPos,
+	model_instance_local_to_global_point(&worldPos,
 									&decal.position,
 									pm,
 									pmi,
@@ -414,16 +420,21 @@ matrix4 getDecalTransform(Decal& decal) {
 									&objp->pos);
 
 	vec3d worldDir;
-	model_instance_find_world_dir(&worldDir,
+	model_instance_local_to_global_dir(&worldDir,
 								  &decal.orientation.vec.fvec,
 								  pm,
 								  pmi,
 								  decal.submodel,
 								  &objp->orient);
 
+	// The decal API sees the "direction" of a decal to be along the normal of the surface it is attached to. However,
+	// this will lead to a situation where we would look at the decal texture "from behind" causing the texture to
+	// appear flipped. We fix that here for the graphics transform.
+	vm_vec_scale(&worldDir, -1.0f);
+
 	vec3d worldUp;
-	model_instance_find_world_dir(&worldUp,
-								  &decal.orientation.vec.fvec,
+	model_instance_local_to_global_dir(&worldUp,
+								  &decal.orientation.vec.uvec,
 								  pm,
 								  pmi,
 								  decal.submodel,

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

@@ -12,7 +12,7 @@ layout (std140) uniform genericData {
 	vec3 fog_color;
 	float fog_start;
 
-	float fog_scale;
+	float fog_density;
 	float zNear;
 	float zFar;
 };
@@ -31,9 +31,7 @@ void main()
 	if (isinf(view_depth)) {
 		fragOut0.rgb = color_in.rgb;
 	} else {
-		// This is the same formula that is also used by the main shader
-		float fog_dist = clamp((view_depth - fog_start) * 0.75 * fog_scale, 0.0, 1.0);
-
+		float fog_dist = clamp(1 - pow(fog_density, view_depth - fog_start) , 0.0, 1.0);
 		vec3 finalFogColor = srgb_to_linear(fog_color);
 
 		fragOut0.rgb = mix(color_in.rgb, finalFogColor, fog_dist);

code/def_files/data/effects/lighting.sdr

@@ -4,14 +4,8 @@ const int LT_POINT			= 1;		// A point light, like an explosion
 const int LT_TUBE			= 2;		// A tube light, like a fluorescent light
 const int LT_CONE			= 3;		// A cone light, like a flood light
 
-const float SPEC_INTENSITY_POINT		= 5.3 ;// Point light
-const float SPEC_INTENSITY_DIRECTIONAL	= 3.0 ;// Directional light
-const float SPECULAR_FACTOR				= 1.75;
-const float SPECULAR_ALPHA				= 0.1;
 const float SPEC_FACTOR_NO_SPEC_MAP		= 0.1;
-const float ENV_ALPHA_FACTOR			= 0.3;
 const float GLOW_MAP_INTENSITY			= 1.5;
-const float AMBIENT_LIGHT_BOOST			= 1.0;
 const float GLOW_MAP_SRGB_MULTIPLIER	= 3.0;
 
 vec3 FresnelSchlick(vec3 specColor, vec3 light, vec3 halfVec)

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

@@ -94,6 +94,8 @@ layout (std140) uniform modelData {
 	int sNormalmapIndex;
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
+
+	float alphaMult;
 };
 
 in VertexOutput {
@@ -261,6 +263,11 @@ void main()
    }
  #endif
 	baseColor = texture(sBasemap, vec3(diffuseTexCoord, float(sBasemapIndex)));
+
+#ifdef FLAG_ALPHA_MULT
+	baseColor.a *= alphaMult;
+#endif
+
 	if ( blend_alpha == 0 && baseColor.a < 0.95 ) discard; // if alpha blending is not on, discard transparent pixels
 	// premultiply alpha if blend_alpha is 1. assume that our blend function is srcColor + (1-Alpha)*destColor.
 	// if blend_alpha is 2, assume blend func is additive and don't modify color
@@ -429,7 +436,15 @@ void main()
 	fragOut0 = baseColor;
 #ifdef FLAG_DEFERRED
 	fragOut1 = vec4(vertIn.position.xyz, 1.0);
-	fragOut2 = vec4(normal, glossData);
+
+	// Anti-glint "trick" based on Valve's "Advanced VR Rendering" talk at GDC2015:
+	// http://media.steampowered.com/apps/valve/2015/Alex_Vlachos_Advanced_VR_Rendering_GDC2015.pdf Page 43
+	// basically make surfaces rougher if local normals change too fast in screenspace 
+	vec2 normDx = dFdx(normal.xy);
+	vec2 normDy = dFdy(normal.xy);
+	float glossGeo = 1.0f - pow(clamp(max(dot(normDx,normDx), dot(normDy,normDy)),0.0,1.0),0.33);
+	fragOut2 = vec4(normal, min(glossData, glossGeo));
+
 	fragOut3 = vec4(specColor.rgb, fresnelFactor);
 	fragOut4 = emissiveColor;
 #endif

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

@@ -103,6 +103,8 @@ layout (std140) uniform modelData {
 	int sNormalmapIndex;
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
+
+	float alphaMult;
 };
 
 in VertexOutput {

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

@@ -97,6 +97,8 @@ layout (std140) uniform modelData {
 	int sNormalmapIndex;
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
+
+	float alphaMult;
 };
 
 #ifdef FLAG_TRANSFORM

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

@@ -7,9 +7,25 @@ uniform sampler2D tex;
 
 layout (std140) uniform genericData {
 	float exposure;
-};
+	int tonemapper;
+	float x0; //from here on these are for the PPC tonemappers
+	float y0;
 
-vec3 Uncharted2Tonemapping(vec3 hdr_color)
+	float x1;
+	float toe_B;
+	float toe_lnA;
+	float sh_B;
+
+	float sh_lnA;
+	float sh_offsetX;
+	float sh_offsetY;
+};
+//Tonemapping options, aside from the previous standard UC2, pulled from wookiejedi and qazwsxal's
+//work on testing them for FSO, which itself was based on these references:
+//https://64.github.io/tonemapping/ Delta - Blog by 64: Tone Mapping
+//http://filmicworlds.com/blog/filmic-tonemapping-operators/ Filmic Worlds: Filmic Tonemapping Operators by John Hable
+
+vec3 Uncharted2ToneMapping(vec3 hdr_color) // John Hable's filmic
 {
 	float A = 0.15;
 	float B = 0.50;
@@ -17,15 +33,185 @@ vec3 Uncharted2Tonemapping(vec3 hdr_color)
 	float D = 0.20;
 	float E = 0.02;
 	float F = 0.30;
-	return ((hdr_color*(A*hdr_color+C*B)+D*E)/(hdr_color*(A*hdr_color+B)+D*F))-E/F;
+	float W = 11.2;
+	hdr_color = ((hdr_color * (A * hdr_color + C * B) + D * E) / (hdr_color * (A * hdr_color + B) + D * F)) - E / F;
+	float white = ((W * (A * W + C * B) + D * E) / (W * (A * W + B) + D * F)) - E / F;
+	hdr_color /= white;
+	hdr_color = linear_to_srgb(hdr_color); // return from linear color space to SRGB color space
+
+	return hdr_color;
 }
 
+vec3 rtt_and_odt_fit(vec3 v)
+{
+    vec3 a = v * (v + 0.0245786f) - 0.000090537f;
+    vec3 b = v * (0.983729f * v + 0.4329510f) + 0.238081f;
+    return a / 	b;
+}
+
+
+const mat3 aces_input = mat3(vec3(0.59719, 0.07600, 0.02840),
+                             vec3(0.35458, 0.90834, 0.13383),
+                             vec3(0.04823, 0.01566, 0.83777)
+                            );
+
+const mat3 aces_output = mat3(vec3( 1.60475, -0.10208, -0.00327),
+                              vec3(-0.53108,  1.10813, -0.07276),
+                              vec3(-0.07367, -0.00605,  1.07602)
+                             );
+
+vec3 aces(vec3 hdr_color)
+{
+    hdr_color = aces_input * hdr_color;
+    hdr_color = rtt_and_odt_fit(hdr_color);
+    hdr_color = aces_output * hdr_color;
+    hdr_color = linear_to_srgb(hdr_color);
+	return hdr_color;
+}
+
+vec3 aces_approx(vec3 hdr_color) // also filmic, higher contrast then Uncharted2ToneMapping
+{
+	const float a = 2.51f;
+	const float b = 0.03f;
+	const float c = 2.43f;
+	const float d = 0.59f;
+	const float e = 0.14f;
+    hdr_color *= 0.6f;
+
+    hdr_color = clamp((hdr_color*(a*hdr_color+b))/(hdr_color*(c*hdr_color+d)+e), 0.0f, 1.0f);
+	hdr_color = linear_to_srgb(hdr_color); // return from linear color space to SRGB color space
+	return hdr_color;
+}
+
+vec3 OptimizedCineonToneMapping( vec3 color ) {
+	// optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
+	color = max( vec3( 0.0 ), color - 0.004 );
+	color =  (color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 );
+    // linear to sRGB conversion embedded in shader
+    return color;
+}
+
+vec3 rhj_lumaToneMapping(vec3 hdr_color) // reinhard_jodie
+{
+	float luma = dot(hdr_color, vec3(0.2126, 0.7152, 0.0722)); //dot products are a bit more expensive
+	float toneMappedLuma = luma / (1.0 + luma);
+	hdr_color *= toneMappedLuma / luma;
+	hdr_color = linear_to_srgb(hdr_color); // return from linear color space to SRGB color space
+	return hdr_color;
+}
+
+vec3 reinhard_extended(vec3 hdr_color)
+{
+	float max_white = 1.0;
+	vec3 numerator = hdr_color * (1.0f + (hdr_color / vec3(max_white * max_white)));
+    hdr_color = numerator / (1.0f + hdr_color);
+	hdr_color = linear_to_srgb(hdr_color); // return from linear color space to SRGB color space
+	return hdr_color;
+}
+
+vec3 linearToneMapping(vec3 hdr_color)
+{
+	hdr_color = clamp(hdr_color, 0., 1.);
+	hdr_color = linear_to_srgb(hdr_color); // return from linear color space to SRGB color space
+	return hdr_color;
+}
+
+float toe( float x ) {
+	return exp(toe_lnA + toe_B * log(x));
+}
+
+float linear( float x ) {
+	// Slope is 1 by definition
+	return y0 + (x - x0);
+}
+
+float shoulder ( float x ) {
+	// Scale is -1 so reverse subtraction to save a mult
+	x = sh_offsetX - x;
+	x = exp(sh_lnA + sh_B * log(x));
+	x = sh_offsetY - x;
+	return x;
+}
+
+float funswitch (float x) {
+	float x_tone;
+	if (x <= x0) {
+		x_tone = toe(x);
+	}
+	else if (x <= x1) {
+		x_tone = linear(x);
+	}
+	else if ( x < sh_offsetX ){
+		x_tone = shoulder(x);
+	}
+	else {
+		x_tone = sh_offsetY;
+	}
+	return x_tone;
+}
+
+vec3 PPC_RGB( vec3 color ) {
+	color = vec3(	funswitch(color.r),
+				 	funswitch(color.g),
+					funswitch(color.b));
+
+	return linear_to_srgb(color);
+}
+
+
+vec3 PPC( vec3 color ) {
+	float luma = dot(color, vec3(0.2126, 0.7152, 0.0722));
+	float luma_tone;
+	if ( luma <= x0 ) {
+		luma_tone = toe(luma);
+	} 
+	else if ( luma <= x1 ) {
+		luma_tone = linear(luma);
+	}
+	else if ( luma < sh_offsetX ){
+		luma_tone = shoulder(luma);
+	}
+	else {
+		luma_tone = sh_offsetY;
+	}
+	return linear_to_srgb(color * luma_tone / luma);
+}
+
+
 void main()
 {
 	vec4 color = texture(tex, fragTexCoord.xy);
-	// Tone mapping using John Hable's Uncharted 2 tonemapping algorithm.
-	float whitepoint = 11.2f; // hardcoded whitepoint value from Hable's algo
-	color.rgb = Uncharted2Tonemapping(color.rgb * exposure) / Uncharted2Tonemapping(vec3(whitepoint));
-	color.rgb = linear_to_srgb(color.rgb); // return from linear color space to SRGB color space
+	color *= exposure;
+
+	switch(tonemapper){
+		case 0:
+			color.rgb = linearToneMapping(color.rgb);
+			break;
+		case 1:
+			color.rgb = Uncharted2ToneMapping(color.rgb);
+			break;
+		case 2:
+			color.rgb = aces(color.rgb);
+			break;
+		case 3:
+			color.rgb = aces_approx(color.rgb);
+			break;
+		case 4:
+			color.rgb = OptimizedCineonToneMapping(color.rgb);
+			break;
+		case 5:
+			color.rgb = rhj_lumaToneMapping(color.rgb);
+			break;
+		case 6:
+			color.rgb = reinhard_extended(color.rgb);
+			break;
+		case 7:
+			color.rgb = PPC(color.rgb);
+			break;
+		case 8:
+			color.rgb = PPC_RGB(color.rgb);
+			break;
+
+	}
 	fragOut0 = vec4(color.rgb, 1.0);
 }

code/fireball/fireballs.cpp

@@ -14,6 +14,7 @@
 #include "graphics/tmapper.h"
 #include "localization/localize.h"
 #include "model/model.h"
+#include "nebula/neb.h"
 #include "object/object.h"
 #include "options/Option.h"
 #include "parse/parselo.h"
@@ -25,7 +26,7 @@
 #include <cstdlib>
 
 
-int Knossos_warp_ani_used;
+bool Knossos_warp_ani_used;
 
 #define WARPHOLE_GROW_TIME		(2.35f)	// time for warphole to reach max size (also time to shrink to nothing once it begins to shrink)
 
@@ -202,6 +203,10 @@ static void fireball_set_default_warp_attributes(int idx)
 			strcpy_s(Fireball_info[idx].warp_glow, "warpglow01");
 			strcpy_s(Fireball_info[idx].warp_ball, "warpball01");
 			strcpy_s(Fireball_info[idx].warp_model, "warp.pof");
+
+			if (Fireball_use_3d_warp)
+				Fireball_info[idx].use_3d_warp = true;
+
 			break;
 	}
 }
@@ -286,11 +291,13 @@ static void parse_fireball_tbl(const char *table_filename)
 				}
 			}
 
+			bool first_time;
 			// now select our entry accordingly...
 			// are we using a previous entry?
 			if (existing_idx >= 0)
 			{
 				fi = &Fireball_info[existing_idx];
+				first_time = false;
 			}
 			// we are creating a new entry, so set some defaults
 			else
@@ -314,6 +321,7 @@ static void parse_fireball_tbl(const char *table_filename)
 				fireball_set_default_warp_attributes(Num_fireball_types);
 
 				Num_fireball_types++;
+				first_time = true;
 			}
 
 			// copy over what we already parsed
@@ -321,6 +329,7 @@ static void parse_fireball_tbl(const char *table_filename)
 				strcpy_s(fi->unique_id, unique_id);
 			strcpy_s(fi->lod[0].filename, fireball_filename);
 
+			
 			// Do we have a LOD num?
 			if (optional_string("$LOD:"))
 			{
@@ -328,6 +337,9 @@ static void parse_fireball_tbl(const char *table_filename)
 
 				if (fi->lod_count > MAX_FIREBALL_LOD)
 					fi->lod_count = MAX_FIREBALL_LOD;
+			} else if (first_time) {
+				//assume a LOD of at least 1
+				fi->lod_count = 1;
 			}
 
 			// check for particular lighting color
@@ -358,7 +370,13 @@ static void parse_fireball_tbl(const char *table_filename)
 
 			// check for custom warp model
 			if (optional_string("$Warp model:"))
+			{
 				stuff_string(fi->warp_model, F_NAME, NAME_LENGTH);
+
+				// if we are explicitly specifying a model, then we'll want to use it,
+				// rather than just having the default model that might or might not be used
+				fi->use_3d_warp = true;
+			}
 		}
 
 		required_string("#End");
@@ -452,7 +470,7 @@ void fireball_init()
 	Unused_fireball_indices.reserve(INTITIAL_FIREBALL_CONTAINTER_SIZE);
 
 	// Goober5000 - reset Knossos warp flag
-	Knossos_warp_ani_used = 0;
+	Knossos_warp_ani_used = false;
 }
 
 MONITOR( NumFireballsRend )
@@ -830,7 +848,7 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 	
     flagset<Object::Object_Flags> default_flags;
     default_flags.set(Object::Object_Flags::Renders);
-	objnum = obj_create(OBJ_FIREBALL, parent_obj, n, &orient, pos, size, default_flags);
+	objnum = obj_create(OBJ_FIREBALL, parent_obj, n, &orient, pos, size, default_flags, false);
 
 	obj = &Objects[objnum];
 
@@ -843,11 +861,11 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 	switch( new_fireball->fireball_render_type )	{
 
 		case FIREBALL_MEDIUM_EXPLOSION:	
-			new_fireball->orient = (myrand()>>8) & 7;							// 0 - 7
+			new_fireball->orient = Random::next() & 7;							// 0 - 7
 			break;
 
 		case FIREBALL_LARGE_EXPLOSION:
-			new_fireball->orient = (myrand()>>8) % 360;						// 0 - 359
+			new_fireball->orient = Random::next(360);						// 0 - 359
 			break;
 
 		case FIREBALL_WARP_EFFECT:
@@ -978,9 +996,9 @@ int fireball_ship_explosion_type(ship_info *sip)
 	}
 
 	if(ship_fireballs > 0){
-		index = sip->explosion_bitmap_anims[rand()%ship_fireballs];
+		index = sip->explosion_bitmap_anims[Random::next(ship_fireballs)];
 	} else if(objecttype_fireballs > 0){
-		index = Ship_types[sip->class_type].explosion_bitmap_anims[rand()%objecttype_fireballs];
+		index = Ship_types[sip->class_type].explosion_bitmap_anims[Random::next(objecttype_fireballs)];
 	}
 
 	return index;
@@ -997,7 +1015,7 @@ int fireball_asteroid_explosion_type(asteroid_info *aip)
 	int roid_fireballs = (int)aip->explosion_bitmap_anims.size();
 
 	if (roid_fireballs > 0) {
-		index = aip->explosion_bitmap_anims[rand()%roid_fireballs];
+		index = aip->explosion_bitmap_anims[Random::next(roid_fireballs)];
 	}
 
 	return index;
@@ -1037,19 +1055,25 @@ void fireball_render(object* obj, model_draw_list *scene)
 
 	if ( fb->current_bitmap < 0 )
 		return;
+
+	float alpha = 1.0f;
+
+	if (The_mission.flags[Mission::Mission_Flags::Fullneb] && Neb_affects_fireballs)
+		alpha *= neb2_get_fog_visibility(&obj->pos, 
+			Neb2_fog_visibility_fireball_const + (obj->radius * Neb2_fog_visibility_fireball_scaled_factor));
 	
 	g3_transfer_vertex(&p, &obj->pos);
 
 	switch ( fb->fireball_render_type )	{
 
 		case FIREBALL_MEDIUM_EXPLOSION: {
-			batching_add_volume_bitmap(fb->current_bitmap, &p, fb->orient, obj->radius);
+			batching_add_volume_bitmap(fb->current_bitmap, &p, fb->orient, obj->radius, alpha);
 		}
 		break;
 
 		case FIREBALL_LARGE_EXPLOSION: {
 			// Make the big explosions rotate with the viewer.
-			batching_add_volume_bitmap_rotated(fb->current_bitmap, &p, (i2fl(fb->orient)*PI) / 180.0f, obj->radius);
+			batching_add_volume_bitmap_rotated(fb->current_bitmap, &p, (i2fl(fb->orient)*PI) / 180.0f, obj->radius, alpha);
 		}
 		break;
 
@@ -1058,7 +1082,7 @@ void fireball_render(object* obj, model_draw_list *scene)
 			float rad = obj->radius * fireball_wormhole_intensity(fb);
 
 			fireball_info *fi = &Fireball_info[fb->fireball_info_index];
-			warpin_queue_render(scene, obj, &obj->orient, &obj->pos, fb->current_bitmap, rad, percent_life, obj->radius, (fb->flags & FBF_WARP_3D) != 0, fi->warp_glow_bitmap, fi->warp_ball_bitmap, fi->warp_model_id);
+			warpin_queue_render(scene, obj, &obj->orient, &obj->pos, fb->current_bitmap, rad, percent_life, obj->radius, fi->use_3d_warp || (fb->flags & FBF_WARP_3D) != 0, fi->warp_glow_bitmap, fi->warp_ball_bitmap, fi->warp_model_id);
 		}
 		break;
 

code/fireball/fireballs.h

@@ -58,6 +58,8 @@ typedef struct fireball_info {
 	fireball_lod		lod[MAX_FIREBALL_LOD];
 	float				exp_color[3];	// red, green, blue
 
+	bool	use_3d_warp;
+
 	char	warp_glow[NAME_LENGTH];
 	int		warp_glow_bitmap;
 	char	warp_ball[NAME_LENGTH];
@@ -141,7 +143,7 @@ int fireball_asteroid_explosion_type(asteroid_info *aip);
 float fireball_wormhole_intensity( fireball *fb );
 
 // Goober5000
-extern int Knossos_warp_ani_used;
+extern bool Knossos_warp_ani_used;
 
 extern bool Fireball_use_3d_warp;
 

code/fireball/warpineffect.cpp

@@ -91,14 +91,14 @@ void warpin_queue_render(model_draw_list *scene, object *obj, matrix *orient, ve
 
 			g3_transfer_vertex( &verts[4], &vecs[4] );
 
-			float alpha = (The_mission.flags[Mission::Mission_Flags::Fullneb]) ? (1.0f - neb2_get_fog_intensity(obj)) : 1.0f;
+			float alpha = (The_mission.flags[Mission::Mission_Flags::Fullneb]) ? neb2_get_fog_visibility(&obj->pos, 1.0f) : 1.0f;
 
 			//batch_add_bitmap(warp_glow_bitmap, TMAP_FLAG_TEXTURED | TMAP_HTL_3D_UNLIT, &verts[4], 0, r, alpha);
 			batching_add_bitmap(warp_glow_bitmap, &verts[4], 0, r, alpha);
 		}
 	}
 
-	if ( (warp_model_id >= 0) && (warp_3d || Fireball_use_3d_warp) ) {
+	if ( (warp_model_id >= 0) && (warp_3d) ) {
 		model_render_params render_info;
 
 		float scale = radius / 25.0f;

code/gamesequence/gamesequence.cpp

@@ -239,7 +239,10 @@ bool GameState_Stack_Valid()
 
 // returns one of the GS_STATE_ macros
 int gameseq_get_state(int depth)
-{	
+{
+	if (!GameState_Stack_Valid())
+		return GS_STATE_INVALID;
+
 	Assert(depth <= gs_current_stack);
 			
 	return gs[gs_current_stack - depth].current_state;

code/gamesnd/eventmusic.cpp

@@ -659,7 +659,12 @@ void event_music_first_pattern()
 			audiostream_stop( Patterns[Current_pattern].handle );
 	}
 
-	Pattern_timer_id = 2000;	// start music delay
+	// if we really are initializing the level
+	if (Missiontime == 0) {
+		Pattern_timer_id = timestamp(-1);	// don't let this start quite yet; see event_music_set_start_delay()
+	} else {
+		Pattern_timer_id = timestamp(0);	// start immediately
+	}
 	
 	Event_music_begun = FALSE;
 	if ( Event_Music_battle_started == TRUE ) {
@@ -670,6 +675,13 @@ void event_music_first_pattern()
 	}
 }
 
+// Event music was originally hard-coded to start at 2 seconds, regardless of the timestamp.  Since the default player entry delay is 1 second,
+// this yields a relative start time of 1 second.  Mission start will now use relative rather than absolute delay.
+void event_music_set_start_delay()
+{
+	Pattern_timer_id = timestamp(1000);
+}
+
 // -------------------------------------------------------------------------------------------------
 // event_music_level_close() 
 //

code/gamesnd/eventmusic.h

@@ -107,6 +107,7 @@ void	event_music_parse_musictbl(const char *filename);
 void	event_music_change_pattern(int new_pattern);
 int	event_music_return_current_pattern();
 void	event_music_first_pattern();
+void event_music_set_start_delay();
 int	event_music_battle_start();
 int	event_music_enemy_arrival();
 int	event_music_friendly_arrival();

code/gamesnd/gamesnd.cpp

@@ -526,7 +526,7 @@ void parse_iface_sound_list(const char* tag, SCP_vector<interface_snd_id>& desti
 		//if we're using the old format, double check the size)
 		if(!scp_list && (destination.size() != (unsigned)check))
 		{
-			mprintf(("%s in '%s' has " SIZE_T_ARG " entries. This does not match entered size of %i.", tag, object_name, destination.size(), check));
+			mprintf(("%s in '%s' has " SIZE_T_ARG " entries. This does not match entered size of %i.\n", tag, object_name, destination.size(), check));
 		}
 	}
 }
@@ -544,12 +544,12 @@ void gamesnd_preload_common_sounds()
 		return;
 
 	Assert( Snds.size() <= INT_MAX );
-	for (SCP_vector<game_snd>::iterator gs = Snds.begin(); gs != Snds.end(); ++gs) {
-		if ( gs->preload ) {
-			for (auto& entry : gs->sound_entries) {
+	for (auto& gs: Snds) {
+		if ( gs.preload ) {
+			for (auto& entry : gs.sound_entries) {
 				if ( entry.filename[0] != 0 && strnicmp(entry.filename, NOX("none.wav"), 4) != 0 ) {
 					game_busy( NOX("** preloading common game sounds **") );	// Animate loading cursor... does nothing if loading screen not active.
-					entry.id = snd_load(&entry, gs->flags);
+					entry.id = snd_load(&entry, &gs.flags);
 				}
 			}
 		}
@@ -565,12 +565,12 @@ void gamesnd_load_gameplay_sounds()
 		return;
 
 	Assert( Snds.size() <= INT_MAX );
-	for (SCP_vector<game_snd>::iterator gs = Snds.begin(); gs != Snds.end(); ++gs) {
-		if ( !gs->preload ) { // don't try to load anything that's already preloaded
-			for (auto& entry : gs->sound_entries) {
+	for (auto& gs: Snds) {
+		if ( !gs.preload ) { // don't try to load anything that's already preloaded
+			for (auto& entry : gs.sound_entries) {
 				if (entry.filename[0] != 0 && strnicmp(entry.filename, NOX("none.wav"), 4) != 0) {
 					game_busy(NOX("** preloading gameplay sounds **"));        // Animate loading cursor... does nothing if loading screen not active.
-					entry.id = snd_load(&entry, gs->flags);
+					entry.id = snd_load(&entry, &gs.flags);
 				}
 			}
 		}
@@ -583,8 +583,8 @@ void gamesnd_load_gameplay_sounds()
 void gamesnd_unload_gameplay_sounds()
 {
 	Assert( Snds.size() <= INT_MAX );
-	for (SCP_vector<game_snd>::iterator gs = Snds.begin(); gs != Snds.end(); ++gs) {
-		for (auto& entry : gs->sound_entries) {
+	for (auto& gs: Snds) {
+		for (auto& entry : gs.sound_entries) {
 			if (entry.id.isValid()) {
 				snd_unload(entry.id);
 				entry.id = sound_load_id::invalid();
@@ -602,10 +602,10 @@ void gamesnd_load_interface_sounds()
 		return;
 
 	Assert( Snds_iface.size() < INT_MAX );
-	for (SCP_vector<game_snd>::iterator si = Snds_iface.begin(); si != Snds_iface.end(); ++si) {
-		for (auto& entry : si->sound_entries) {
+	for (auto& gs: Snds) {
+		for (auto& entry : gs.sound_entries) {
 			if ( entry.filename[0] != 0 && strnicmp(entry.filename, NOX("none.wav"), 4) != 0 ) {
-				entry.id = snd_load(&entry, si->flags);
+				entry.id = snd_load(&entry, &gs.flags);
 			}
 		}
 	}
@@ -642,10 +642,11 @@ void parse_gamesnd_old(game_snd* gs)
 
 	stuff_string(entry.filename, F_NAME, MAX_FILENAME_LEN, ",");
 
-	if (!stricmp(entry.filename, NOX("empty")))
+	if (!stricmp(entry.filename, NOX("empty")) || !stricmp(entry.filename, NOX("none")))
 	{
 		entry.filename[0] = 0;
-		advance_to_eoln(NULL);
+		advance_to_eoln(nullptr);
+		gs->flags |= GAME_SND_NOT_VALID;
 		return;
 	}
 	Mp++;
@@ -751,14 +752,14 @@ bool required_string_no_create(const char* token, bool no_create)
 
 static GameSoundCycleType parse_cycle_type() {
 	if (optional_string("Sequential")) {
-		return GameSoundCycleType::Sequential;
+		return GameSoundCycleType::SequentialCycle;
 	} else if (optional_string("Random")) {
-		return GameSoundCycleType::Random;
+		return GameSoundCycleType::RandomCycle;
 	} else {
 		error_display(0, "Failed to parse sound cycle type. Expected 'sequential' or 'random'. Got [%.32s]", next_tokens());
 		// Ignore everything until the end of the line. That should hopefully skip the bad token.
 		advance_to_eoln(nullptr);
-		return GameSoundCycleType::Sequential;
+		return GameSoundCycleType::SequentialCycle;
 	}
 }
 
@@ -860,9 +861,10 @@ void parse_gamesnd_new(game_snd* gs, bool no_create)
 	// Default pitch is 1.0. This is set here in case we don't have a valid file name
 	gs->pitch_range = util::UniformFloatRange(1.0f);
 
-	if (!stricmp(name, NOX("empty")))
+	if (!stricmp(name, NOX("empty")) || !stricmp(name, NOX("none")))
 	{
 		entry->filename[0] = 0;
+		gs->flags |= GAME_SND_NOT_VALID;
 		return;
 	}
 
@@ -1343,13 +1345,31 @@ bool gamesnd_interface_sound_valid(interface_snd_id sound) {
 	return sound.isValid() && sound.value() < (int) Snds_iface.size();
 }
 
+bool gamesnd_game_sound_try_load(gamesnd_id sound)
+{
+	if (!gamesnd_game_sound_valid(sound)) {
+		return false;
+	}
+	auto gs = gamesnd_get_game_sound(sound);
+
+	for (auto& entry : gs->sound_entries) {
+		if (!entry.id.isValid()) {
+			// Lazily load unloaded sound entries when required
+			entry.id = snd_load(&entry, &gs->flags);
+		}
+	}
+
+	// check flag
+	return (gs->flags & GAME_SND_NOT_VALID) == 0;
+}
+
 float gamesnd_get_max_duration(game_snd* gs) {
 	int max_length = 0;
 
 	for (auto& entry : gs->sound_entries) {
 		if (!entry.id.isValid()) {
 			// Lazily load unloaded sound entries when required
-			entry.id = snd_load(&entry, gs->flags);
+			entry.id = snd_load(&entry, &gs->flags);
 		}
 
 		max_length = std::max(max_length, snd_get_duration(entry.id));
@@ -1362,14 +1382,14 @@ game_snd_entry* gamesnd_choose_entry(game_snd* gs) {
 
 	size_t index = 0;
 	switch(gs->cycle_type) {
-	case GameSoundCycleType::Random:
+	case GameSoundCycleType::RandomCycle:
 		if (gs->sound_entries.size() == 1) {
 			index = 0;
 		} else {
 			index = util::UniformRange<size_t>(0, gs->sound_entries.size() - 1).next();
 		}
 		break;
-	case GameSoundCycleType::Sequential:
+	case GameSoundCycleType::SequentialCycle:
 		if (gs->last_entry_index == std::numeric_limits<size_t>::max()) {
 			// If this is the first time we must return the first sound to keep everything consistent
 			index = 0;

code/gamesnd/gamesnd.h

@@ -401,6 +401,11 @@ game_snd* gamesnd_get_interface_sound(interface_snd_id handle);
  */
 bool gamesnd_game_sound_valid(gamesnd_id sound);
 
+/**
+* @brief Checks if the given sound handle can be loaded
+*/
+bool gamesnd_game_sound_try_load(gamesnd_id sound);
+
 /**
  * @brief Checks if the given sound handle is a valid interface sound handle
  * @param sound The handle to check

code/globalincs/globals.h

@@ -31,8 +31,6 @@
 #define CALLSIGN_LEN					(MAX_FILENAME_LEN - 4 - 1)		//	shortened from 32 to allow .json to be attached without exceeding MAX_FILENAME_LEN
 #define SHORT_CALLSIGN_PIXEL_W	80		// max width of short_callsign[] in pixels
 
-#define MAX_IFFS		10
-
 // from ship.h
 #define MAX_SHIPS					400			// max number of ship instances there can be.DTP; bumped from 200 to 400
 #define SHIPS_LIMIT					400			// what MAX_SHIPS will be at release time (for error checking in debug mode); dtp Bumped from 200 to 400

code/globalincs/pstypes.h

@@ -113,6 +113,8 @@ typedef struct vec2d {
 	float x, y;
 } vec2d;
 
+// Euler angles for a rotation: h=heading, b=bank and p=pitch; angles are around the y, z and x axes
+// respectively and are performed in that order.
 typedef struct angles {
 	float	p, b, h;
 } angles_t;
@@ -128,6 +130,7 @@ typedef struct matrix {
 	};
 } matrix;
 
+// You might think this is also row-major. You fool! It is actually column-major.
 typedef struct matrix4 {
 	union {
 		struct {
@@ -303,8 +306,6 @@ constexpr bool LoggingEnabled = false;
 const float PI2			= (PI*2.0f);
 // half values
 const float PI_2		= (PI/2.0f);
-const int RAND_MAX_2	= (RAND_MAX/2);
-const float RAND_MAX_1f	= (1.0f / RAND_MAX);
 
 
 extern int Fred_running;  // Is Fred running, or FreeSpace?
@@ -350,14 +351,6 @@ const size_t INVALID_SIZE = static_cast<size_t>(-1);
 #define TRUE	1
 #define FALSE	0
 
-int myrand();
-
-// Returns a random number between 0 and 0x7fffffff
-int rand32();
-
-// Returns a random integer from low to high, inclusive
-int rand32(int low, int high);
-
 
 // lod checker for (modular) table parsing
 typedef struct lod_checker {
@@ -463,7 +456,6 @@ SCP_string dump_stacktrace();
 // DEBUG compile time catch for dangerous uses of memset/memcpy/memmove
 // This is disabled for VS2013 and lower since that doesn't support the necessary features
 #if !defined(NDEBUG) && !defined(USING_THIRD_PARTY_LIBS) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-	#if SCP_COMPILER_CXX_AUTO_TYPE && SCP_COMPILER_CXX_STATIC_ASSERT && HAVE_STD_IS_TRIVIALLY_COPYABLE
 	// feature support seems to be: gcc   clang   msvc
 	// auto                         4.4   2.9     2010
 	// std::is_trivial              4.5   ?       2012 (2010 only duplicates std::is_pod)
@@ -563,7 +555,6 @@ using std::memcpy_if_trivial_else_error;
 using std::memmove_if_trivial_else_error;
 using std::memset_if_trivial_else_error;
 
-	#endif // HAVE_CXX11
 #endif // NDEBUG
 
-#endif		// PS_TYPES_H
+#endif		// _PSTYPES_H

code/globalincs/scp_defines.h

@@ -3,8 +3,6 @@
 #define SCP_DEFINES_H
 #pragma once
 
-#include "scp_compiler_detection.h"
-
 #define SCP_TOKEN_CONCAT1(x, y) x ## y
 #define SCP_TOKEN_CONCAT(x, y) SCP_TOKEN_CONCAT1(x, y)
 

code/globalincs/systemvars.cpp

@@ -57,7 +57,6 @@ vci		Viewer_chase_info;			// View chase camera information
 vec3d leaning_position;
 
 int Is_standalone;
-int Rand_count;
 
 int Interface_last_tick = -1;			// last timer tick on flip
 
@@ -109,47 +108,6 @@ float Noise[NOISE_NUM_FRAMES] = {
 	0.000000f
 };
 
-
-int myrand()
-{
-	int rval;
-	rval = rand();
-	Rand_count++;
-//	nprintf(("Alan","RAND: %d\n", rval));
-	return rval;
-}
-
-// returns a random number between 0 and 0x7fffffff, or something close to it.
-int rand32()
-{
-	if (RAND_MAX == 0x7fff) {
-		int random32;
-		// this gets two random 16 bit numbers and stuffs them into a 32 bit number
-		random32 = (rand() << 16) | rand();
-		//since rand() returns between 0 and 0x7fff, there needs to be a thing to randomly generate the 16th bit
-		random32 |= ((rand() & 1) << 15);
-		
-		return random32;
-	}
-	else {
-		return rand();
-	}
-}
-
-int rand32(int low, int high)
-{
-	int diff;
-
-	// get diff - don't allow negative or zero
-	diff = high - low;
-	if (diff < 0)
-		diff = 0;
-
-	// To get a range of values between min and max, inclusive:
-	// random value = min + random number % (max - min + 1)
-	return (low + rand32() % (diff + 1));
-}
-
 // Variables for the loading callback hooks
 static int cf_timestamp = -1;
 static void (*cf_callback)(int count) = NULL;
@@ -285,8 +243,8 @@ detail_levels Detail_defaults[NUM_DEFAULT_DETAIL_LEVELS] = {
 	{				// Highest level
 		3,			// setting
 					// ===== Analogs (0-MAX_DETAIL_LEVEL) ====
-		3,			// nebula_detail;				// 0=lowest detail, MAX_DETAIL_LEVEL=highest detail
-		3,			// detail_distance;			// 0=lowest MAX_DETAIL_LEVEL=highest		
+		4,			// nebula_detail;				// 0=lowest detail, MAX_DETAIL_LEVEL=highest detail
+		4,			// detail_distance;			// 0=lowest MAX_DETAIL_LEVEL=highest		
 		4,			//	hardware_textures;			// 0=max culling, MAX_DETAIL_LEVEL=no culling
 		4,			//	num_small_debris;			// 0=min number, MAX_DETAIL_LEVEL=max number
 		4,			//	num_particles;				// 0=min number, MAX_DETAIL_LEVEL=max number
@@ -370,9 +328,6 @@ void detail_level_set(int level)
 	Assert( level < NUM_DEFAULT_DETAIL_LEVELS );
 
 	Detail = Detail_defaults[level];
-
-	// reset nebula stuff
-	neb2_set_detail_level(level);
 }
 
 // Returns the current detail level or -1 if custom.

code/globalincs/systemvars.h

@@ -94,7 +94,6 @@ extern int Game_mode;
 #define SINGLEPLAYER !(Game_mode & GM_MULTIPLAYER)
 
 extern int Viewer_mode;
-extern int Rand_count;
 
 extern int Game_restoring;		// If set, this means we are restoring data from disk
 

code/globalincs/toolchain/gcc.h

@@ -67,7 +67,7 @@
 
 #define USED_VARIABLE __attribute__((used))
 
-#if SCP_COMPILER_VERSION_MAJOR >= 7
+#if __GNUC__ >= 7
 #define FALLTHROUGH [[fallthrough]]
 #else
 #define FALLTHROUGH

code/globalincs/toolchain/mingw.h

@@ -64,7 +64,7 @@
 
 #define USED_VARIABLE __attribute__((used))
 
-#if SCP_COMPILER_VERSION_MAJOR >= 7
+#if __GNUC__ >= 7
 #define FALLTHROUGH __attribute__((fallthrough))
 #else
 #define FALLTHROUGH

code/graphics/2d.cpp

@@ -41,6 +41,7 @@
 #include "scripting/scripting.h"
 #include "tracing/tracing.h"
 #include "utils/boost/hash_combine.h"
+#include "gamesequence/gamesequence.h"
 
 #ifdef WITH_OPENGL
 #include "graphics/opengl/gropengl.h"
@@ -1604,8 +1605,6 @@ bool gr_init(std::unique_ptr<os::GraphicsOperations>&& graphicsOps, int d_mode,
 		return false;
 	}
 
-	gr_light_init();
-
 	gr_set_palette_internal(Gr_current_palette_name, NULL, 0);
 
 	bm_init();
@@ -1617,10 +1616,14 @@ bool gr_init(std::unique_ptr<os::GraphicsOperations>&& graphicsOps, int d_mode,
 	mprintf(("Initializing path renderer...\n"));
 	graphics::paths::PathRenderer::init();
 
-	// Initialize uniform buffer managers
-	uniform_buffer_managers_init();
+	if ( !Is_standalone ) {
+		gr_light_init();
 
-	gpu_heap_init();
+		// Initialize uniform buffer managers
+		uniform_buffer_managers_init();
+
+		gpu_heap_init();
+	}
 
 	mprintf(("Checking graphics capabilities:\n"));
 	mprintf(("  Persistent buffer mapping: %s\n",
@@ -2547,7 +2550,8 @@ void gr_flip(bool execute_scripting)
 	executor::OnFrameExecutor->process();
 
 	// m!m avoid running CHA_ONFRAME when the "Quit mission" popup is shown. See mantis 2446 for reference
-	if (execute_scripting && !popup_active()) {
+	// Cyborg - A similar bug will occur when a mission is restarted so check for that, too.
+	if (execute_scripting && !popup_active() && !((gameseq_get_state() == GS_STATE_GAME_PLAY) && !(Game_mode & GM_IN_MISSION))) {
 		TRACE_SCOPE(tracing::LuaOnFrame);
 
 		// WMC - Do conditional hooks. Yippee!

code/graphics/2d.h

@@ -230,6 +230,7 @@ enum shader_type {
 #define SDR_FLAG_MODEL_AMBIENT_MAP	(1<<19)
 #define SDR_FLAG_MODEL_NORMAL_ALPHA	(1<<20)
 #define SDR_FLAG_MODEL_THICK_OUTLINES (1<<21) // Renders the model geometry as an outline with configurable line width
+#define SDR_FLAG_MODEL_ALPHA_MULT (1<<22) 
 
 #define SDR_FLAG_PARTICLE_POINT_GEN			(1<<0)
 
@@ -808,7 +809,7 @@ typedef struct screen {
 	std::function<void(int bitmap_handle, int bpp, const ubyte* data, int width, int height)> gf_update_texture;
 	std::function<void(void* data_out, int bitmap_num)> gf_get_bitmap_from_texture;
 
-	std::function<void(matrix4* shadow_view_matrix, const matrix* light_matrix)> gf_shadow_map_start;
+	std::function<void(matrix4* shadow_view_matrix, const matrix* light_matrix, vec3d* eye_pos)> gf_shadow_map_start;
 	std::function<void()> gf_shadow_map_end;
 
 	std::function<void()> gf_start_decal_pass;
@@ -982,6 +983,9 @@ extern void gr_get_string_size( int *w, int *h, const char * text, int len = 999
 // Returns the height of the current font
 extern int gr_get_font_height();
 
+// Returns a scaled amount of lines per the current font --wookieejedi
+extern int gr_get_dynamic_font_lines(int number_default_lines);
+
 extern io::mouse::Cursor* Web_cursor;
 
 // Called by OS when application gets/looses focus

code/graphics/decal_draw_list.cpp

@@ -149,8 +149,10 @@ void decal_draw_list::render() {
 	source.Ibuffer_handle = box_index_buffer;
 
 	// Bind the global data only once
-	gr_bind_uniform_buffer(uniform_block_type::DecalGlobals, 0, sizeof(graphics::decal_globals),
-	                       _buffer.bufferHandle());
+	gr_bind_uniform_buffer(uniform_block_type::DecalGlobals,
+		_buffer.getBufferOffset(0),
+		sizeof(graphics::decal_globals),
+		_buffer.bufferHandle());
 	gr_screen.gf_start_decal_pass();
 
 	for (auto& draw : _draws) {

code/graphics/generic.cpp

@@ -630,7 +630,7 @@ void generic_anim_render_variable_frame_delay(generic_anim* ga, float frametime,
 		else {
 			// playing forwards
 			ga->anim_time += frametime;
-			if(ga->anim_time >= ga->total_time && ga->png.anim->current_frame >= ga->png.anim->nframes-1) {
+			if(ga->anim_time >= ga->total_time && ga->png.anim->current_frame >= ga->png.anim->nframes) {
 				if(ga->direction & GENERIC_ANIM_DIRECTION_NOLOOP) {
 					ga->anim_time = ga->total_time;  // stop on last frame when playing
 				}
@@ -660,7 +660,7 @@ void generic_anim_render_variable_frame_delay(generic_anim* ga, float frametime,
 		}
 		else {
 			if (ga->anim_time >= ga->png.previous_frame_time + ga->png.anim->frame.delay &&
-					ga->png.anim->current_frame < ga->png.anim->nframes-1) {
+					ga->png.anim->current_frame < ga->png.anim->nframes) {
 				ga->png.previous_frame_time += ga->png.anim->frame.delay;
 				ga->current_frame++;
 			}
@@ -725,3 +725,17 @@ void generic_anim_render(generic_anim *ga, float frametime, int x, int y, bool m
 		}
 	}
 }
+
+/*
+ * @brief reset an animation back to the start
+ *
+ * @param [in] *ga  animation data
+ */
+void generic_anim_reset(generic_anim *ga) {
+	ga->anim_time = 0.0f;
+	ga->current_frame = 0;
+	if (ga->type == BM_TYPE_PNG) {
+		ga->png.previous_frame_time = 0.0f;
+		ga->png.anim->goto_start();
+	}
+}

code/graphics/generic.h

@@ -89,5 +89,5 @@ int generic_anim_stream(generic_anim *ga, const bool cache = true);
 int generic_bitmap_load(generic_bitmap *gb);
 void generic_anim_unload(generic_anim *ga);
 void generic_anim_render(generic_anim *ga, float frametime, int x, int y, bool menu = false, const generic_extras *ge = nullptr);
-
+void generic_anim_reset(generic_anim *ga);
 #endif

code/graphics/grstub.cpp

@@ -285,7 +285,7 @@ int gr_stub_maybe_create_shader(shader_type  /*shader_t*/, unsigned int  /*flags
 	return -1;
 }
 
-void gr_stub_shadow_map_start(matrix4 * /*shadow_view_matrix*/, const matrix*  /*light_matrix*/)
+void gr_stub_shadow_map_start(matrix4 * /*shadow_view_matrix*/, const matrix*  /*light_matrix*/, vec3d* /*eye_pos*/)
 {
 }
 

code/graphics/light.cpp

@@ -294,10 +294,7 @@ void gr_light_init() {
 	gr_lights.reserve(1024);
 }
 
-void gr_set_lighting(bool  /*set*/, bool state) {
-	if (!state) {
-		return;
-	}
+void gr_set_lighting() {
 
 	//Valathil: Sort lights by priority
 	extern bool Deferred_lighting;

code/graphics/light.h

@@ -17,7 +17,7 @@ extern float gr_user_ambient;
 //Functions
 void gr_set_light(light *fs_light);
 void gr_reset_lighting();
-void gr_set_lighting(bool set, bool state);
+void gr_set_lighting();
 void gr_set_center_alpha(int type);
 void gr_set_ambient_light(int red, int green, int blue);
 

code/graphics/material.cpp

@@ -688,6 +688,24 @@ bool model_material::uses_thick_outlines() const {
 	return Outline_thickness > 0.0f;
 }
 
+float model_material::get_alpha_mult() const {
+	return Alpha_mult;
+}
+
+bool model_material::is_alpha_mult_active() const {
+	return Use_alpha_mult;
+}
+
+void model_material::set_alpha_mult(float alpha) {
+	Use_alpha_mult = true;
+	Alpha_mult = alpha;
+}
+
+void model_material::reset_alpha_mult() {
+	Use_alpha_mult = false;
+	Alpha_mult = 1.0f;
+}
+
 uint model_material::get_shader_flags() const
 {
 	uint Shader_flags = 0;
@@ -779,6 +797,10 @@ uint model_material::get_shader_flags() const
 		Shader_flags |= SDR_FLAG_MODEL_THICK_OUTLINES;
 	}
 
+	if (is_alpha_mult_active()) {
+		Shader_flags |= SDR_FLAG_MODEL_ALPHA_MULT;
+	}
+
 	return Shader_flags;
 }
 

code/graphics/material.h

@@ -204,6 +204,9 @@ class model_material : public material
 
 	float Outline_thickness = -1.0f;
 
+	bool Use_alpha_mult = false;
+	float Alpha_mult = 1.0f;
+
 public:
 	model_material();
 
@@ -259,6 +262,12 @@ public:
 	void set_fog();
 	bool is_fogged() const;
 	const fog& get_fog() const;
+
+	float get_alpha_mult() const;
+	bool is_alpha_mult_active() const;
+	void set_alpha_mult(float alpha);
+	void reset_alpha_mult();
+
 };
 
 class particle_material : public material

code/graphics/opengl/ShaderProgram.h

@@ -55,8 +55,8 @@ class ShaderProgram {
 
 	ShaderUniforms Uniforms;
 
-	ShaderProgram(const ShaderProgram&) SCP_DELETED_FUNCTION;
-	ShaderProgram& operator=(const ShaderProgram&) SCP_DELETED_FUNCTION;
+	ShaderProgram(const ShaderProgram&) = delete;
+	ShaderProgram& operator=(const ShaderProgram&) = delete;
 
 	ShaderProgram(ShaderProgram&& other) noexcept;
 	ShaderProgram& operator=(ShaderProgram&& other) noexcept;

code/graphics/opengl/gropengldeferred.cpp

@@ -301,8 +301,8 @@ void gr_opengl_deferred_lighting_finish()
 		GL_state.Texture.Enable(0, GL_TEXTURE_2D, Scene_emissive_texture);
 		GL_state.Texture.Enable(1, GL_TEXTURE_2D, Scene_depth_texture);
 
-		float fog_near, fog_far;
-		neb2_get_adjusted_fog_values(&fog_near, &fog_far, nullptr);
+		float fog_near, fog_far, fog_density;
+		neb2_get_adjusted_fog_values(&fog_near, &fog_far, &fog_density);
 		unsigned char r, g, b;
 		neb2_get_fog_color(&r, &g, &b);
 
@@ -311,7 +311,7 @@ void gr_opengl_deferred_lighting_finish()
 
 		opengl_set_generic_uniform_data<graphics::generic_data::fog_data>([&](graphics::generic_data::fog_data* data) {
 			data->fog_start       = fog_near;
-			data->fog_scale       = 1.0f / (fog_far - fog_near);
+			data->fog_density     = fog_density;
 			data->fog_color.xyz.x = r / 255.f;
 			data->fog_color.xyz.y = g / 255.f;
 			data->fog_color.xyz.z = b / 255.f;
@@ -439,13 +439,15 @@ void gr_opengl_deferred_light_cylinder_init(int segments) // Generate a VBO of a
 		if ( opengl_check_for_errors() ) {
 			glDeleteBuffers(1, &deferred_light_cylinder_vbo);
 			deferred_light_cylinder_vbo = 0;
+
+			vm_free(Indices);
+			Indices = nullptr;
+			vm_free(Vertices);
+			Vertices = nullptr;
 			return;
 		}
 
 		glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-		vm_free(Vertices);
-		Vertices = NULL;
 	}
 
 	glGenBuffers(1, &deferred_light_cylinder_ibo);
@@ -459,15 +461,21 @@ void gr_opengl_deferred_light_cylinder_init(int segments) // Generate a VBO of a
 		if ( opengl_check_for_errors() ) {
 			glDeleteBuffers(1, &deferred_light_cylinder_ibo);
 			deferred_light_cylinder_ibo = 0;
+
+			vm_free(Indices);
+			Indices = nullptr;
+			vm_free(Vertices);
+			Vertices = nullptr;
 			return;
 		}
 
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
-		vm_free(Indices);
-		Indices = NULL;
 	}
 
+	vm_free(Indices);
+	Indices = nullptr;
+	vm_free(Vertices);
+	Vertices = nullptr;
 }
 
 static GLuint deferred_light_sphere_vbo = 0;
@@ -531,13 +539,15 @@ void gr_opengl_deferred_light_sphere_init(int rings, int segments) // Generate a
 		if ( opengl_check_for_errors() ) {
 			glDeleteBuffers(1, &deferred_light_sphere_vbo);
 			deferred_light_sphere_vbo = 0;
+			
+			vm_free(Vertices);
+			Vertices = nullptr;
+			vm_free(Indices);
+			Indices = nullptr;
 			return;
 		}
 
 		glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-		vm_free(Vertices);
-		Vertices = NULL;
 	}
 
 	glGenBuffers(1, &deferred_light_sphere_ibo);
@@ -551,14 +561,21 @@ void gr_opengl_deferred_light_sphere_init(int rings, int segments) // Generate a
 		if ( opengl_check_for_errors() ) {
 			glDeleteBuffers(1, &deferred_light_sphere_ibo);
 			deferred_light_sphere_ibo = 0;
+			
+			vm_free(Vertices);
+			Vertices = nullptr;
+			vm_free(Indices);
+			Indices = nullptr;
 			return;
 		}
 
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
-		vm_free(Indices);
-		Indices = NULL;
 	}
+	
+	vm_free(Vertices);
+	Vertices = nullptr;
+	vm_free(Indices);
+	Indices = nullptr;
 }
 
 void opengl_draw_sphere()

code/graphics/opengl/gropengldraw.cpp

@@ -706,8 +706,8 @@ void gr_opengl_update_distortion()
 
 	for(int i = 0; i < 33; i++)
 	{
-		distortion_verts[i].r = (ubyte)rand() % 256;
-		distortion_verts[i].g = (ubyte)rand() % 256;
+		distortion_verts[i].r = (ubyte)Random::next(256);
+		distortion_verts[i].g = (ubyte)Random::next(256);
 		distortion_verts[i].b = 255;
 		distortion_verts[i].a = 255;
 

code/graphics/opengl/gropengldraw.h

@@ -34,7 +34,7 @@ void gr_opengl_update_distortion();
 
 void gr_opengl_sphere(material *material_def, float rad);
 
-void gr_opengl_shadow_map_start(matrix4 *shadow_view_matrix, const matrix *light_orient);
+void gr_opengl_shadow_map_start(matrix4 *shadow_view_matrix, const matrix *light_orient, vec3d* eye_pos);
 void gr_opengl_shadow_map_end();
 
 void gr_opengl_render_shield_impact(shield_material* material_info,

code/graphics/opengl/gropenglpostprocessing.cpp

@@ -16,6 +16,7 @@
 #include "graphics/util/uniform_structs.h"
 #include "io/timer.h"
 #include "lighting/lighting.h"
+#include "lighting/lighting_profiles.h"
 #include "mod_table/mod_table.h"
 #include "nebula/neb.h"
 #include "parse/parselo.h"
@@ -24,7 +25,6 @@
 
 extern bool PostProcessing_override;
 extern int opengl_check_framebuffer();
-
 // Needed to track where the FXAA shaders are
 // In case we don't find the shaders at all, this override is needed
 bool fxaa_unavailable = false;
@@ -66,9 +66,22 @@ void opengl_post_pass_tonemap()
 	opengl_shader_set_current(gr_opengl_maybe_create_shader(SDR_TYPE_POST_PROCESS_TONEMAPPING, 0));
 
 	Current_shader->program->Uniforms.setTextureUniform("tex", 0);
-
+	
 	opengl_set_generic_uniform_data<graphics::generic_data::tonemapping_data>(
-		[](graphics::generic_data::tonemapping_data* data) { data->exposure = 4.0f; });
+		[](graphics::generic_data::tonemapping_data* data) {
+		auto ppc = lighting_profile::current_piecewise_intermediates();
+		auto tn = lighting_profile::current_tonemapper();
+		data->tonemapper = tn;
+		data->sh_B = ppc.sh_B;
+		data->sh_lnA = ppc.sh_lnA;
+		data->sh_offsetX =ppc.sh_offsetX;
+		data->sh_offsetY = ppc.sh_offsetY;
+		data->toe_B = ppc.toe_B;
+		data->toe_lnA = ppc.toe_lnA;
+		data->x0 = ppc.x0;
+		data->x1 = ppc.x1;
+		data->y0 = ppc.y0; 
+		data->exposure = lighting_profile::current_exposure(); });
 
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Scene_ldr_texture, 0);
 
@@ -170,7 +183,7 @@ void opengl_post_pass_bloom()
 		opengl_set_generic_uniform_data<graphics::generic_data::bloom_composition_data>(
 			[](graphics::generic_data::bloom_composition_data* data) {
 				data->levels          = MAX_MIP_BLUR_LEVELS;
-				data->bloom_intensity = Cmdline_bloom_intensity / 100.0f;
+				data->bloom_intensity = gr_bloom_intensity() / 100.0f;
 			});
 
 		GL_state.Texture.Enable(0, GL_TEXTURE_2D, Bloom_textures[0]);
@@ -442,9 +455,9 @@ void opengl_post_lightshafts()
 			float dot;
 			if ( (dot = vm_vec_dot(&light_dir, &Eye_matrix.vec.fvec)) > 0.7f ) {
 
-				x = asinf(vm_vec_dot(&light_dir, &Eye_matrix.vec.rvec)) / PI * 1.5f +
+				x = asinf_safe(vm_vec_dot(&light_dir, &Eye_matrix.vec.rvec)) / PI * 1.5f +
 					0.5f; // cant get the coordinates right but this works for the limited glare fov
-				y = asinf(vm_vec_dot(&light_dir, &Eye_matrix.vec.uvec)) / PI * 1.5f * gr_screen.clip_aspect + 0.5f;
+				y = asinf_safe(vm_vec_dot(&light_dir, &Eye_matrix.vec.uvec)) / PI * 1.5f * gr_screen.clip_aspect + 0.5f;
 
 				opengl_set_generic_uniform_data<graphics::generic_data::lightshaft_data>(
 					[&](graphics::generic_data::lightshaft_data* data) {
@@ -871,7 +884,7 @@ bool opengl_post_init_shaders()
 		gr_opengl_maybe_create_shader(SDR_TYPE_POST_PROCESS_BLUR, SDR_FLAG_BLUR_VERTICAL) < 0 ||
 		gr_opengl_maybe_create_shader(SDR_TYPE_POST_PROCESS_BLOOM_COMP, 0) < 0) {
 		// disable bloom if we don't have those shaders available
-		Cmdline_bloom_intensity = 0;
+		graphics::Post_processing_manager->setBloomShadersOk(false);
 	}
 
 	if (gr_is_fxaa_mode(Gr_aa_mode))
@@ -1185,4 +1198,4 @@ void opengl_post_process_shutdown()
 	Post_active_shader_index = 0;
 
 	Post_initialized = 0;
-}
+}